./PaxHeaders.X/.clang-format0100644 0000000 0000000 00000000034 15172120304 014647 xustar000000000 0000000 28 mtime=1776853188.2590000 .clang-format0100644 0000000 0000000 00000000000 15172120304 022673 2../../../build/soong/scripts/system-clang-format-2ustar000000000 0000000 ./PaxHeaders.X/Android.bp0100644 0000000 0000000 00000000034 15172120304 014177 xustar000000000 0000000 28 mtime=1776853188.2680000 Android.bp0100644 0000000 0000000 00000070727 15172120304 011520 0ustar000000000 0000000 // // Copyright (C) 2015 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. // package { default_applicable_licenses: ["system_tools_aidl_license"], } // Added automatically by a large-scale-change // See: http://go/android-license-faq license { name: "system_tools_aidl_license", visibility: [":__subpackages__"], license_kinds: [ "SPDX-license-identifier-Apache-2.0", ], license_text: [ "NOTICE", ], } cc_defaults { name: "aidl_defaults", cflags: [ "-Wall", "-Werror", "-Wextra", ], tidy: true, tidy_checks: [ "-bugprone-argument-comment", "-bugprone-branch-clone", "-bugprone-macro-parentheses", "-bugprone-misplaced-widening-cast", "-bugprone-signed-char-misuse", "-bugprone-sizeof-expression", "-cert-err34-c", "-cert-err52-cpp", "-cert-str34-c", "-clang-analyzer-optin.performance.Padding", "-misc-unused-using-decls", "-performance-for-range-copy", "-performance-inefficient-string-concatenation", "-performance-inefficient-vector-operation", "-performance-no-automatic-move", "-performance-unnecessary-copy-initialization", "-performance-unnecessary-value-param", ], header_libs: ["libgtest_prod_headers"], static_libs: [ "libbase", "libgtest", ], // TODO(b/174366536): basic_stringbuf::overflow causes "ubsan: implicit-conversion" // sanitize: { // integer_overflow: true, // misc_undefined: ["integer"], // }, target: { windows: { enabled: true, }, host: { cflags: [ "-O0", "-g", ], }, }, product_variables: { platform_sdk_version: { cflags: ["-DPLATFORM_SDK_VERSION=%d"], }, }, defaults_visibility: [":__subpackages__"], } // Logic shared between aidl and its unittests cc_library_static { name: "libaidl-common", defaults: ["aidl_defaults"], host_supported: true, srcs: [ "aidl_checkapi.cpp", "aidl_const_expressions.cpp", "aidl_dumpapi.cpp", "aidl_language_l.ll", "aidl_language_y.yy", "aidl_language.cpp", "aidl_to_common.cpp", "aidl_to_cpp_common.cpp", "aidl_to_cpp.cpp", "aidl_to_java.cpp", "aidl_to_ndk.cpp", "aidl_to_rust.cpp", "aidl_typenames.cpp", "aidl.cpp", "ast_java.cpp", "check_valid.cpp", "code_writer.cpp", "comments.cpp", "diagnostics.cpp", "generate_aidl_mappings.cpp", "generate_cpp.cpp", "generate_cpp_analyzer.cpp", "generate_java_binder.cpp", "generate_java.cpp", "generate_ndk.cpp", "generate_rust.cpp", "import_resolver.cpp", "io_delegate.cpp", "location.cpp", "logging.cpp", "options.cpp", "parser.cpp", "permission.cpp", "preprocess.cpp", ], yacc: { gen_location_hh: true, gen_position_hh: true, }, visibility: [":__subpackages__"], } // aidl executable cc_binary_host { name: "aidl", defaults: ["aidl_defaults"], srcs: ["main.cpp"], static_libs: [ "libaidl-common", "libbase", "liblog", ], } // aidl-cpp legacy executable, please use 'aidl' instead cc_binary_host { name: "aidl-cpp", defaults: ["aidl_defaults"], srcs: ["main.cpp"], cflags: ["-DAIDL_CPP_BUILD"], static_libs: [ "libaidl-common", "libbase", "liblog", ], } // Unit tests cc_test { name: "aidl_unittests", host_supported: true, test_suites: ["general-tests"], cflags: [ "-Wall", "-Wextra", "-Werror", "-g", ], tidy_timeout_srcs: [ "aidl_unittest.cpp", "options_unittest.cpp", ], srcs: [ "aidl_unittest.cpp", "ast_java_unittest.cpp", "code_writer_unittest.cpp", "diagnostics_unittest.cpp", "generate_cpp_unittest.cpp", "io_delegate_unittest.cpp", "options_unittest.cpp", "tests/fake_io_delegate.cpp", "tests/main.cpp", "tests/test_util.cpp", ], static_libs: [ "libaidl-common", "libbase", "libcutils", "libgmock", "liblog", ], target: { host: { sanitize: { address: true, }, }, }, data: [ ":aidl-golden-test-build-hook-gen", ], } cc_fuzz { name: "aidl_parser_fuzzer", host_supported: true, dictionary: "tests/aidl_parser_fuzzer.dict", corpus: [ "tests/corpus/*", ], fuzz_config: { cc: [ "aidl-bugs@google.com", ], triage_assignee: "smoreland@google.com", use_for_presubmit: true, }, srcs: [ "tests/aidl_parser_fuzzer.cpp", "tests/fake_io_delegate.cpp", "tests/test_util.cpp", ], static_libs: [ "libaidl-common", "libbase", "libcutils", "libgtest", "liblog", ], // Enable this to show additional information about what is being parsed during fuzzing. // cflags: ["-DFUZZ_LOG"], } // // Integration testing of generated AIDL code. // python_test_host { name: "aidl_integration_test", main: "tests/aidl_integration_test.py", srcs: ["tests/aidl_integration_test.py"], test_config: "tests/aidl_integration_test.xml", data: [ ":aidl_test_java_client", ":aidl_test_java_service", ":aidl_test_java_client_sdk1", ":aidl_test_java_service_sdk1", ":aidl_test_java_client_sdk29", ":aidl_test_java_service_sdk29", ":aidl_test_java_client_permission", ":aidl_test_java_service_permission", ], data_device_bins_both: [ "aidl_test_client", "aidl_test_v1_client", "aidl_test_service", "aidl_test_client_ndk", "aidl_test_service_ndk", "aidl_test_rust_client", "aidl_test_rust_service", "aidl_test_rust_service_async", ], test_suites: ["general-tests"], test_options: { unit_test: false, }, } cc_defaults { name: "aidl_test_defaults", cflags: [ "-Wall", "-Wextra", "-Werror", ], shared_libs: [ "libbase", "libbinder", "liblog", "libutils", ], compile_multilib: "both", multilib: { lib32: { suffix: "32", }, lib64: { suffix: "64", }, }, test_suites: ["general-tests"], } // Header-only library used for atrace in platform NDK builds cc_library_headers { name: "libandroid_aidltrace", host_supported: true, vendor_available: true, export_include_dirs: ["trace"], apex_available: [ "//apex_available:platform", "//apex_available:anyapex", ], } cc_library { name: "libsimpleparcelable", export_include_dirs: [ ".", ], srcs: [ "tests/bad_parcelable.cpp", "tests/simple_parcelable.cpp", ], shared_libs: [ "libbase", "libbinder", "libutils", ], } java_library { name: "libsimpleparcelable_java", srcs: [ "tests/java/src/android/aidl/tests/BadParcelable.java", "tests/java/src/android/aidl/tests/SimpleParcelable.java", "tests/java/src/android/aidl/tests/generic/Pair.java", ], } cc_library { name: "libsimpleparcelable_ndk", export_include_dirs: [ ".", ], srcs: [ "tests/simple_parcelable_ndk.cpp", ], shared_libs: [ "libbase", "libbinder_ndk", ], } rust_library { name: "libsimple_parcelable_rust", crate_name: "simple_parcelable", srcs: [ "tests/rust/simple_parcelable.rs", ], rustlibs: [ "libbinder_rs", ], } aidl_interface { name: "aidl-test-interface", unstable: true, flags: ["-Werror"], srcs: [ "tests/android/aidl/tests/ArrayOfInterfaces.aidl", "tests/android/aidl/tests/BackendType.aidl", "tests/android/aidl/tests/ByteEnum.aidl", "tests/android/aidl/tests/CircularParcelable.aidl", "tests/android/aidl/tests/ConstantExpressionEnum.aidl", "tests/android/aidl/tests/DeprecatedEnum.aidl", "tests/android/aidl/tests/DeprecatedParcelable.aidl", "tests/android/aidl/tests/GenericStructuredParcelable.aidl", "tests/android/aidl/tests/FixedSize.aidl", "tests/android/aidl/tests/ICircular.aidl", "tests/android/aidl/tests/IDeprecated.aidl", "tests/android/aidl/tests/INamedCallback.aidl", "tests/android/aidl/tests/INewName.aidl", "tests/android/aidl/tests/IOldName.aidl", "tests/android/aidl/tests/ITestService.aidl", "tests/android/aidl/tests/IntEnum.aidl", "tests/android/aidl/tests/ListOfInterfaces.aidl", "tests/android/aidl/tests/LongEnum.aidl", "tests/android/aidl/tests/OtherParcelableForToString.aidl", "tests/android/aidl/tests/ParcelableForToString.aidl", "tests/android/aidl/tests/RecursiveList.aidl", "tests/android/aidl/tests/StructuredParcelable.aidl", "tests/android/aidl/tests/Union.aidl", "tests/android/aidl/tests/UnionWithFd.aidl", "tests/android/aidl/tests/extension/*.aidl", "tests/android/aidl/tests/nested/*.aidl", "tests/android/aidl/tests/unions/*.aidl", ], local_include_dir: "tests", backend: { cpp: { additional_shared_libraries: [ "libsimpleparcelable", ], }, java: { additional_libs: [ "libsimpleparcelable_java", ], platform_apis: true, }, rust: { enabled: true, additional_rustlibs: [ "libsimple_parcelable_rust", ], }, ndk: { apps_enabled: false, additional_shared_libraries: [ "libsimpleparcelable_ndk", ], }, }, } aidl_interface { name: "aidl-cpp-java-test-interface", unstable: true, srcs: [ "tests/android/aidl/tests/BadParcelable.aidl", "tests/android/aidl/tests/ICppJavaTests.aidl", ], local_include_dir: "tests", include_dirs: [ "frameworks/native/aidl/binder", ], imports: ["aidl-test-interface"], backend: { cpp: { additional_shared_libraries: ["libsimpleparcelable"], enabled: true, }, java: { additional_libs: [ "libsimpleparcelable_java", ], platform_apis: true, enabled: true, }, rust: { enabled: false, }, ndk: { enabled: false, }, }, } aidl_interface { name: "aidl-test-interface-permission", srcs: [ "tests/android/aidl/tests/permission/**/*.aidl", ], unstable: true, flags: ["-Werror"], include_dirs: [ "frameworks/base/core/java", ], local_include_dir: "tests", backend: { cpp: { enabled: false, }, java: { platform_apis: true, }, rust: { enabled: false, }, ndk: { enabled: false, }, }, } aidl_interface { name: "aidl-test-versioned-interface", local_include_dir: "tests/versioned", flags: ["-Werror"], srcs: [ "tests/versioned/**/*.aidl", ], backend: { java: { gen_rpc: true, }, rust: { enabled: true, }, }, versions_with_info: [ { version: "1", imports: [], }, { version: "2", imports: [], }, { version: "3", imports: [], }, ], frozen: true, } cc_test { name: "aidl_test_service", gtest: false, defaults: ["aidl_test_defaults"], static_libs: [ "aidl-test-interface-cpp", "aidl-cpp-java-test-interface-cpp", "libsimpleparcelable", "libcutils", // service uses the old version "aidl-test-versioned-interface-V1-cpp", "aidl_test_loggable_interface-cpp", "aidl-test-fixedsizearray-cpp", "android.aidl.test.trunk-V2-cpp", ], srcs: ["tests/aidl_test_service.cpp"], } cc_test { name: "aidl_test_service_ndk", gtest: false, defaults: ["aidl_test_defaults"], shared_libs: [ "libbinder_ndk", "libcutils", ], static_libs: [ // service uses the old version "aidl-test-versioned-interface-V1-ndk", "aidl-test-interface-ndk", "aidl_test_loggable_interface-ndk", "aidl-test-fixedsizearray-ndk", "android.aidl.test.trunk-V2-ndk", "libsimpleparcelable_ndk", ], srcs: ["tests/aidl_test_service_ndk.cpp"], } cc_test { name: "aidl_test_client", defaults: ["aidl_test_defaults"], static_libs: [ "aidl-test-interface-cpp", "aidl-cpp-java-test-interface-cpp", "libsimpleparcelable", "libcutils", "libgmock", // client uses the latest version "aidl-test-versioned-interface-V2-cpp", "aidl_test_loggable_interface-cpp", "aidl-test-fixedsizearray-cpp", "android.aidl.test.trunk-V2-cpp", ], product_variables: { release_aidl_use_unfrozen: { cflags: ["-DAIDL_USE_UNFROZEN"], }, }, tidy_timeout_srcs: [ "tests/aidl_test_client_parcelables.cpp", "tests/aidl_test_client_primitives.cpp", ], srcs: [ "tests/aidl_test_client.cpp", "tests/aidl_test_client_builtin_transactions.cpp", "tests/aidl_test_client_file_descriptors.cpp", "tests/aidl_test_client_parcelables.cpp", "tests/aidl_test_client_nullables.cpp", "tests/aidl_test_client_primitives.cpp", "tests/aidl_test_client_utf8_strings.cpp", "tests/aidl_test_client_service_exceptions.cpp", "tests/aidl_test_client_defaultimpl.cpp", "tests/aidl_test_client_delegate.cpp", "tests/aidl_test_client_versioned_interface.cpp", "tests/aidl_test_client_renamed_interface.cpp", "tests/aidl_test_client_loggable_interface.cpp", "tests/aidl_test_client_nested.cpp", "tests/aidl_test_client_trunk_stable.cpp", ], cflags: ["-DAIDL_USE_V2_INTERFACE"], } cc_test { name: "aidl_test_v1_client", defaults: ["aidl_test_defaults"], static_libs: [ "aidl-test-interface-cpp", "aidl-cpp-java-test-interface-cpp", "libsimpleparcelable", "libcutils", "libgmock", "android.aidl.test.trunk-V1-cpp", ], product_variables: { release_aidl_use_unfrozen: { cflags: ["-DAIDL_USE_UNFROZEN"], }, }, srcs: [ "tests/aidl_test_client_trunk_stable.cpp", "tests/aidl_test_client.cpp", ], } cc_test { name: "aidl_test_client_ndk", defaults: ["aidl_test_defaults"], static_libs: [ "libcutils", "libgmock", // client uses the latest version "aidl-test-versioned-interface-V2-ndk", "aidl-test-interface-ndk", "aidl_test_loggable_interface-ndk", "aidl-test-fixedsizearray-ndk", "android.aidl.test.trunk-V2-ndk", "libsimpleparcelable_ndk", ], shared_libs: [ "libbinder_ndk", ], product_variables: { release_aidl_use_unfrozen: { cflags: ["-DAIDL_USE_UNFROZEN"], }, }, srcs: [ "tests/aidl_test_client_ndk_delegate.cpp", "tests/aidl_test_client_ndk_loggable_interface.cpp", "tests/aidl_test_client_ndk_nested.cpp", "tests/aidl_test_client_ndk_nullables.cpp", "tests/aidl_test_client_ndk_parcelables.cpp", "tests/aidl_test_client_ndk_primitives_test.cpp", "tests/aidl_test_client_ndk_strings_test.cpp", "tests/aidl_test_client_ndk_versioned_interface.cpp", "tests/aidl_test_client_ndk_trunk_stable.cpp", ], } aidl_interface { name: "aidl-test-fixedsizearray", srcs: ["tests/android/aidl/fixedsizearray/FixedSizeArrayExample.aidl"], local_include_dir: "tests", unstable: true, backend: { cpp: { enabled: true, }, java: { enabled: true, }, ndk: { enabled: true, }, rust: { enabled: true, }, }, } java_defaults { name: "aidl_test_java_integration_defaults", platform_apis: true, // Turn off Java optimization tools to speed up our test iterations. optimize: { enabled: false, }, dex_preopt: { enabled: false, }, static_libs: [ "androidx.test.core", "androidx.test.runner", ], aidl: { include_dirs: [ "frameworks/native/aidl/binder", ], }, test_suites: ["general-tests"], } java_defaults { name: "aidl_test_java_defaults", defaults: ["aidl_test_java_integration_defaults"], static_libs: [ "aidl_test_nonvintf_parcelable-V1-java", "aidl_test_unstable_parcelable-java", "aidl_test_vintf_parcelable-V1-java", "aidl-test-fixedsizearray-java", "aidl-cpp-java-test-interface-java", // TODO: remove once Android migrates to JUnit 4.12, // which provides assertThrows "testng", ], } java_test { name: "aidl_test_java_client", defaults: ["aidl_test_java_defaults"], static_libs: [ "aidl-test-extras-java", // client uses the new version "aidl-test-versioned-interface-V3-java", "android.aidl.test.trunk-V2-java", ], // tests are included in defaults srcs: [ "tests/java/src/android/aidl/tests/MapTests.java", "tests/java/src/android/aidl/tests/TestServiceClient.java", "tests/java/src/android/aidl/tests/JavaOnlyImmutableAnnotationTests.java", "tests/java/src/android/aidl/tests/AidlJavaTests.java", "tests/java/src/android/aidl/tests/BuiltInTests.java", "tests/java/src/android/aidl/tests/DelegatorTests.java", "tests/java/src/android/aidl/tests/GenericTests.java", "tests/java/src/android/aidl/tests/NestedTypesTests.java", "tests/java/src/android/aidl/tests/TestVersionedInterface.java", "tests/java/src/android/aidl/tests/TrunkStableTests.java", "tests/java/src/android/aidl/tests/UnionTests.java", "tests/java/src/android/aidl/tests/ExtensionTests.java", "tests/java/src/android/aidl/tests/NullableTests.java", "tests/java/src/android/aidl/tests/VintfTests.java", ], data: [ ":cts-dalvik-device-test-runner", ], } java_test { name: "aidl_test_java_service", defaults: ["aidl_test_java_defaults"], static_libs: [ // service uses the old version "aidl-test-versioned-interface-V1-java", "android.aidl.test.trunk-V2-java", ], srcs: [ "tests/java/src/android/aidl/service/**/*.java", ], data: [ ":cts-dalvik-device-test-runner", ], } filegroup { name: "aidl-for-sdkversion-tests", srcs: [ "tests/java/src/android/aidl/sdkversion/ITestService.aidl", ], path: "tests/java/src", } java_defaults { name: "aidl_test_java_sdkversion_defaults", defaults: ["aidl_test_java_integration_defaults"], srcs: [ ":aidl-for-sdkversion-tests", ], } java_test { name: "aidl_test_java_client_sdk29", defaults: ["aidl_test_java_sdkversion_defaults"], min_sdk_version: "29", data: [ ":cts-dalvik-device-test-runner", ], srcs: [ "tests/java/src/android/aidl/sdkversion/tests/*.java", ], } java_test { name: "aidl_test_java_service_sdk29", defaults: ["aidl_test_java_sdkversion_defaults"], min_sdk_version: "29", srcs: [ "tests/java/src/android/aidl/sdkversion/service/*.java", ], data: [ ":cts-dalvik-device-test-runner", ], } java_test { name: "aidl_test_java_client_sdk1", defaults: ["aidl_test_java_sdkversion_defaults"], min_sdk_version: "1", srcs: [ "tests/java/src/android/aidl/sdkversion/tests/*.java", ], data: [ ":cts-dalvik-device-test-runner", ], } java_test { name: "aidl_test_java_service_sdk1", defaults: ["aidl_test_java_sdkversion_defaults"], min_sdk_version: "1", data: [ ":cts-dalvik-device-test-runner", ], srcs: [ "tests/java/src/android/aidl/sdkversion/service/*.java", ], } java_test { name: "aidl_test_java_client_permission", defaults: ["aidl_test_java_integration_defaults"], static_libs: [ "aidl-test-interface-permission-java", "frameworks-base-testutils", ], srcs: [ "tests/java/src/android/aidl/permission/tests/*.java", "tests/java/src/android/aidl/permission/service/*.java", ], data: [ ":cts-dalvik-device-test-runner", ], } java_test { name: "aidl_test_java_service_permission", defaults: ["aidl_test_java_integration_defaults"], static_libs: [ "aidl-test-interface-permission-java", "frameworks-base-testutils", ], data: [ ":cts-dalvik-device-test-runner", ], srcs: [ "tests/java/src/android/aidl/permission/service/*.java", ], } // // "Golden" test of compiler output // sh_binary_host { name: "aidl-golden-test", src: "tests/golden_test.sh", } genrule { name: "aidl-golden-test-build-hook-gen", tools: ["aidl-golden-test"], // We don't have access to TARGET_RELEASE in the script when it's called from this // hook, so we pass it explicitly. All the script needs to know is whether or not // $TARGET_RELEASE is "next" product_variables: { release_aidl_use_unfrozen: { cmd: "TARGET_RELEASE=trunk_staging $(location aidl-golden-test) check $(in) && " + "touch $(out)", }, }, cmd: "TARGET_RELEASE=next $(location aidl-golden-test) check $(in) && touch $(out)", srcs: [ // warning: keep this list up to date with tests/golden_test.sh ":aidl-test-interface-cpp-source", ":aidl-test-interface-java-source", ":aidl-test-interface-ndk-source", ":aidl-test-interface-rust-source", ":aidl-test-extras-java-source", ":aidl-cpp-java-test-interface-cpp-source", ":aidl-cpp-java-test-interface-java-source", ":aidl-test-versioned-interface-V1-cpp-source", ":aidl-test-versioned-interface-V1-java-source", ":aidl-test-versioned-interface-V1-ndk-source", ":aidl-test-versioned-interface-V1-rust-source", ":aidl-test-versioned-interface-V2-cpp-source", ":aidl-test-versioned-interface-V2-java-source", ":aidl-test-versioned-interface-V2-ndk-source", ":aidl-test-versioned-interface-V2-rust-source", ":aidl-test-versioned-interface-V3-cpp-source", ":aidl-test-versioned-interface-V3-java-source", ":aidl-test-versioned-interface-V3-ndk-source", ":aidl-test-versioned-interface-V3-rust-source", ":aidl_test_loggable_interface-cpp-source", ":aidl_test_loggable_interface-java-source", ":aidl_test_loggable_interface-ndk-source", ":aidl-test-interface-permission-java-source", ":aidl-test-fixedsizearray-cpp-source", ":aidl-test-fixedsizearray-java-source", ":aidl-test-fixedsizearray-ndk-source", ":aidl-test-fixedsizearray-rust-source", ":aidl-test-interface-cpp-analyzer-source", ":android.aidl.test.trunk-V1-cpp-source", ":android.aidl.test.trunk-V2-cpp-source", ":android.aidl.test.trunk-V1-ndk-source", ":android.aidl.test.trunk-V2-ndk-source", ":android.aidl.test.trunk-V1-java-source", ":android.aidl.test.trunk-V2-java-source", ":android.aidl.test.trunk-V1-rust-source", ":android.aidl.test.trunk-V2-rust-source", "tests/golden_output/**/*", ], out: ["aidl_golden_test_stamp.txt"], } // // Testing generation of logs // aidl_interface { name: "aidl_test_loggable_interface", unstable: true, local_include_dir: "tests", flags: ["-Werror"], srcs: [ "tests/android/aidl/loggable/ILoggableInterface.aidl", "tests/android/aidl/loggable/Data.aidl", "tests/android/aidl/loggable/Enum.aidl", "tests/android/aidl/loggable/Union.aidl", ], gen_trace: true, backend: { cpp: { gen_log: true, }, ndk: { gen_log: true, }, java: { platform_apis: true, }, }, } aidl_interface { name: "aidl-test-extras", unstable: true, flags: ["-Werror"], srcs: [ "tests/android/aidl/tests/generic/*.aidl", "tests/android/aidl/tests/immutable/*.aidl", "tests/android/aidl/tests/map/*.aidl", ], local_include_dir: "tests", // Map is only valid for Java for now backend: { cpp: { enabled: false, }, java: { additional_libs: [ "libsimpleparcelable_java", ], platform_apis: true, }, rust: { enabled: false, }, ndk: { enabled: false, }, }, } // // Rust tests // rust_test { name: "aidl_test_rust_client", srcs: [ "tests/rust/test_client.rs", ], rustlibs: [ "aidl-test-interface-rust", "aidl-test-versioned-interface-V2-rust", "aidl_test_nonvintf_parcelable-V1-rust", "aidl_test_unstable_parcelable-rust", "aidl_test_vintf_parcelable-V1-rust", "aidl-test-fixedsizearray-rust", "android.aidl.test.trunk-V2-rust", "liblibc", // We need to import binder_rs directly // for a few internal types like Parcel // and traits like Parcelable "libbinder_rs", "libsimple_parcelable_rust", ], prefer_rlib: true, compile_multilib: "both", multilib: { lib32: { suffix: "32", }, lib64: { suffix: "64", }, }, test_suites: ["general-tests"], } rust_test { name: "aidl_test_rust_service", test_harness: false, srcs: [ "tests/rust/test_service.rs", ], rustlibs: [ "aidl-test-interface-rust", "aidl-test-versioned-interface-V1-rust", "aidl-test-fixedsizearray-rust", "android.aidl.test.trunk-V2-rust", "liblibc", "libsimple_parcelable_rust", ], prefer_rlib: true, compile_multilib: "both", multilib: { lib32: { suffix: "32", }, lib64: { suffix: "64", }, }, test_suites: ["general-tests"], } rust_test { name: "aidl_test_rust_service_async", test_harness: false, srcs: [ "tests/rust/test_service_async.rs", ], rustlibs: [ "aidl-test-interface-rust", "aidl-test-versioned-interface-V1-rust", "aidl-test-fixedsizearray-rust", "android.aidl.test.trunk-V2-rust", "liblibc", "libbinder_tokio_rs", "libsimple_parcelable_rust", "libtokio", ], proc_macros: ["libasync_trait"], prefer_rlib: true, compile_multilib: "both", multilib: { lib32: { suffix: "32", }, lib64: { suffix: "64", }, }, test_suites: ["general-tests"], } cc_library_static { name: "aidl-analyzer-main", host_supported: true, vendor_available: true, shared_libs: [ "libbase", "libbinder", ], srcs: [ "analyzer/analyzerMain.cpp", "analyzer/Analyzer.cpp", ], export_include_dirs: ["analyzer/include"], } cc_binary { name: "record_binder", whole_static_libs: ["aidl-analyzer-main"], shared_libs: [ "libbase", "libbinder", "libutils", ], } ./PaxHeaders.X/CleanSpec.mk0100644 0000000 0000000 00000000034 15172120304 014462 xustar000000000 0000000 28 mtime=1776853188.2680000 CleanSpec.mk0100644 0000000 0000000 00000004662 15172120304 011776 0ustar000000000 0000000 # Copyright (C) 2007 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. # # If you don't need to do a full clean build but would like to touch # a file or delete some intermediate files, add a clean step to the end # of the list. These steps will only be run once, if they haven't been # run before. # # E.g.: # $(call add-clean-step, touch -c external/sqlite/sqlite3.h) # $(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj/STATIC_LIBRARIES/libz_intermediates) # # Always use "touch -c" and "rm -f" or "rm -rf" to gracefully deal with # files that are missing or have been moved. # # Use $(PRODUCT_OUT) to get to the "out/target/product/blah/" directory. # Use $(OUT_DIR) to refer to the "out" directory. # # If you need to re-do something that's already mentioned, just copy # the command and add it to the bottom of the list. E.g., if a change # that you made last week required touching a file and a change you # made today requires touching the same file, just copy the old # touch step and add it to the end of the list. # # ************************************************ # NEWER CLEAN STEPS MUST BE AT THE END OF THE LIST # ************************************************ # For example: #$(call add-clean-step, rm -rf $(OUT_DIR)/target/common/obj/APPS/AndroidTests_intermediates) #$(call add-clean-step, rm -rf $(OUT_DIR)/target/common/obj/JAVA_LIBRARIES/core_intermediates) #$(call add-clean-step, find $(OUT_DIR) -type f -name "IGTalkSession*" -print0 | xargs -0 rm -f) #$(call add-clean-step, rm -rf $(PRODUCT_OUT)/data/*) # ************************************************ # NEWER CLEAN STEPS MUST BE AT THE END OF THE LIST # ************************************************ $(call add-clean-step, rm -rf $(OUT_DIR)/out/soong/.intermediates/system/tools/aidl/) $(call add-clean-step, rm -rf $(OUT_DIR)/out/soong/.intermediates/system/tools/aidl/) $(call add-clean-step, rm -rf $(OUT_DIR)/soong/.intermediates/system/tools/aidl/) ./PaxHeaders.X/NOTICE0100644 0000000 0000000 00000000034 15172120304 013200 xustar000000000 0000000 28 mtime=1776853188.2690000 NOTICE0100644 0000000 0000000 00000024707 15172120304 010516 0ustar000000000 0000000 Copyright (c) 2005-2008, 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. 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. Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS ./PaxHeaders.X/OWNERS0100644 0000000 0000000 00000000034 15172120304 013234 xustar000000000 0000000 28 mtime=1776853188.2690000 OWNERS0100644 0000000 0000000 00000000236 15172120304 010541 0ustar000000000 0000000 # Bug component: 655781 devinmoore@google.com elsk@google.com jiyong@google.com jooyung@google.com malchev@google.com smoreland@google.com vmarko@google.com ./PaxHeaders.X/PREUPLOAD.cfg0100644 0000000 0000000 00000000034 15172120304 014310 xustar000000000 0000000 28 mtime=1776853188.2690000 PREUPLOAD.cfg0100644 0000000 0000000 00000000271 15172120304 011614 0ustar000000000 0000000 [Options] ignore_merged_commits = true [Builtin Hooks] clang_format = true gofmt = true aidl_format = true rustfmt = true [Builtin Hooks Options] rustfmt = --config-path=rustfmt.toml ./PaxHeaders.X/README.md0100644 0000000 0000000 00000000034 15172120304 013553 xustar000000000 0000000 28 mtime=1776853188.2690000 README.md0100644 0000000 0000000 00000000174 15172120304 011061 0ustar000000000 0000000 Documentation for this project is currently maintained here: https://source.android.com/devices/architecture/aidl/overview ./PaxHeaders.X/TEST_MAPPING0100644 0000000 0000000 00000000034 15172120304 014151 xustar000000000 0000000 28 mtime=1776853188.2690000 TEST_MAPPING0100644 0000000 0000000 00000001314 15172120304 011454 0ustar000000000 0000000 { "presubmit": [ { "name": "aidl_unittests" }, { "name": "aidl_integration_test" }, { "name": "aidl_lazy_test" }, { "name": "CtsNdkBinderTestCases" }, { "name": "hal_implementation_test" }, { "name": "resolv_integration_test" }, { "name": "FrameworksTelephonyTests", "options": [ { "include-filter": "com.android.internal.telephony.ServiceStateTrackerTest" } ] }, { "name": "EnforcePermissionTests" } ], "imports": [ { "path": "frameworks/native/libs/binder" } ], "auto-presubmit": [ { "name": "hal_implementation_test" } ] } ./PaxHeaders.X/aidl-format.sh0100644 0000000 0000000 00000000034 15172120304 015027 xustar000000000 0000000 28 mtime=1776853188.2700000 aidl-format.sh0100755 0000000 0000000 00000015074 15172120304 012345 0ustar000000000 0000000 #!/usr/bin/env bash # 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. set -e clang_format=clang-format # future considerations: # - could we make this work with git-clang-format instead? # - should we have our own formatter? function _aidl-format() ( # Find .aidl-format file to use. The file is located in one of the parent # directories of the source file function find-aidl-format-style() { local path="$1" while [[ "$path" != / ]]; do if find "$path" -maxdepth 1 -mindepth 1 -name .aidl-format | grep "."; then return fi path="$(readlink -f "$path"/..)" done } # Do a "reversible" conversion of the input file so that it is more friendly # to clang-format. For example 'oneway interface Foo{}' is not recognized as # an interface. Convert it to 'interface __aidl_oneway__ Foo{}'. function prepare() { # oneway interface Foo {} is not correctly recognized as an interface by # clang-format. Change it to interface __aidl_oneway__ Foo {}. sed -i -E 's/oneway[[:space:]]+interface/interface\ __aidl_oneway__/g' "$1" # When a declaration becomes too long, clang-format splits the declaration # into multiple lines. In doing so, annotations that are at the front of # the declaration are always split. i.e. # # @utf8InCpp @nullable void foo(int looooooo....ong, int looo....ong); # # becomes # # @utf8InCpp # @nullable # void foo(int loooooo...ong, # int looo.....ong); # # This isn't desirable for utf8InCpp and nullable annotations which are # semantically tagged to the type, not the member (field/method). We want # to have the annotations in the same line as the type that they actually # annotate. i.e. # # @utf8InCpp @nullable void foo(int looo....ong, # int looo.....ong); # # To do so, the annotations are temporarily replaced with tokens that are # not annotations. sed -i -E 's/@utf8InCpp/__aidl_utf8inCpp__/g' "$1" sed -i -E 's/@nullable/__aidl_nullable__/g' "$1" } function apply-clang-format() { local input="$1" local style="$2" local temp="$(mktemp)" local styletext="$([ -f "$style" ] && cat "$style" | tr '\n' ',' 2> /dev/null)" cat "$input" | $clang_format \ --style='{BasedOnStyle: Google, ColumnLimit: 100, IndentWidth: 4, ContinuationIndentWidth: 8, '"${styletext}"'}' \ --assume-filename=${input%.*}.java \ > "$temp" mv "$temp" "$input" } # clang-format is good, but doesn't perfectly fit to our needs. Fix the # minor mismatches manually. function fixup() { # Revert the changes done during the prepare call. Notice that the # original tokens (@utf8InCpp, etc.) are shorter than the temporary tokens # (__aidl_utf8InCpp, etc.). This can make the output text length shorter # than the specified column limit. We can try to reduce the undesirable # effect by keeping the tokens to have similar lengths, but that seems to # be an overkill at this moment. We can revisit this when this becomes a # real problem. sed -i -E 's/interface\ __aidl_oneway__/oneway\ interface/g' "$1" sed -i -E 's/__aidl_utf8inCpp__/@utf8InCpp/g' "$1" sed -i -E 's/__aidl_nullable__/@nullable/g' "$1" # clang-format adds space around "=" in annotation parameters. e.g. # @Anno(a = 100). The following awk script removes the spaces back. # @Anno(a = 1, b = 2) @Anno(c = 3, d = 4) int foo = 3; becomes # @Anno(a=1, b=2) @Anno(c=3, d=4) int foo = 3; # [^@,=] ensures that the match doesn't cross the characters, otherwise # "a = 1, b = 2" would match only once and will become "a = 1, b=2". awk -i inplace \ '/@[^@]+\(.*=.*\)/ { # matches a line having @anno(param = val) \ print(gensub(/([^@,=]+) = ([^@,=]+|"[^"]*")/, "\\1=\\2", "g", $0)); \ done=1;\ } \ {if (!done) {print($0);} done=0;}' "$1" } function format-one() { local mode="$1" local input="$2" local style="$3" local output="$(mktemp)" cp "$input" "$output" prepare "$output" apply-clang-format "$output" "$style" fixup "$output" if [ $mode = "diff" ]; then diff "$input" "$output" || ( echo "You can try to fix this by running:" echo "$0 -w " echo "" ) rm "$output" elif [ $mode = "write" ]; then if diff -q "$output" "$input" >/dev/null; then rm "$output" else mv "$output" "$input" fi elif [ $mode = "print" ]; then cat "$output" rm "$output" fi } function show-help-and-exit() { echo "Usage: $0 [options] [path...]" echo " -d: display diff instead of the formatted result" echo " -w: rewrite the result back to the source file, instead of stdout" echo " -h: show this help message" echo " --clang-format-path : set the path to the clang-format to " echo " [path...]: source files. if none, input is read from stdin" exit 1 } local mode=print while [ $# -gt 0 ]; do case "$1" in -d) mode=diff; shift;; -w) mode=write; shift;; -h) show-help-and-exit;; --clang-format-path) clang_format="$2"; shift 2;; *) break;; esac done if [ $# -lt 1 ]; then if [ $mode = "write" ]; then echo "-w not supported when input is stdin" exit 1 fi local input="$(mktemp)" cat /dev/stdin > "$input" local style="$(pwd)/.aidl-format" format-one $mode "$input" "$style" rm "$input" else for file in "$@" do if [ ! -f "$file" ]; then echo "$file": no such file exit 1 fi local style="$(find-aidl-format-style $(dirname "$filename"))" format-one $mode "$file" "$style" done fi ) _aidl-format "$@" ./PaxHeaders.X/aidl.cpp0100644 0000000 0000000 00000000034 15172120304 013711 xustar000000000 0000000 28 mtime=1776853188.2740000 aidl.cpp0100644 0000000 0000000 00000104240 15172120304 011216 0ustar000000000 0000000 /* * Copyright (C) 2015, 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 #include #include #include #include #include #include #include #include #include #include #ifdef _WIN32 #include #include #include #endif #include #include "aidl_checkapi.h" #include "aidl_dumpapi.h" #include "aidl_language.h" #include "aidl_typenames.h" #include "check_valid.h" #include "generate_aidl_mappings.h" #include "generate_cpp.h" #include "generate_cpp_analyzer.h" #include "generate_java.h" #include "generate_ndk.h" #include "generate_rust.h" #include "import_resolver.h" #include "logging.h" #include "options.h" #include "os.h" #include "parser.h" #include "preprocess.h" #ifndef O_BINARY # define O_BINARY 0 #endif using android::base::Error; using android::base::Join; using android::base::Result; using android::base::Split; using std::set; using std::string; using std::unique_ptr; using std::unordered_set; using std::vector; namespace android { namespace aidl { namespace { // Copied from android.is.IBinder.[FIRST|LAST]_CALL_TRANSACTION const int kFirstCallTransaction = 1; const int kLastCallTransaction = 0x00ffffff; // Following IDs are all offsets from kFirstCallTransaction // IDs for meta transactions. Most of the meta transactions are implemented in // the framework side (Binder.java or Binder.cpp). But these are the ones that // are auto-implemented by the AIDL compiler. const int kFirstMetaMethodId = kLastCallTransaction - kFirstCallTransaction; const int kGetInterfaceVersionId = kFirstMetaMethodId; const int kGetInterfaceHashId = kFirstMetaMethodId - 1; // Additional meta transactions implemented by AIDL should use // kFirstMetaMethodId -1, -2, ...and so on. // Reserve 100 IDs for meta methods, which is more than enough. If we don't reserve, // in the future, a newly added meta transaction ID will have a chance to // collide with the user-defined methods that were added in the past. So, // let's prevent users from using IDs in this range from the beginning. const int kLastMetaMethodId = kFirstMetaMethodId - 99; // Range of IDs that is allowed for user-defined methods. const int kMinUserSetMethodId = 0; const int kMaxUserSetMethodId = kLastMetaMethodId - 1; bool check_filename(const std::string& filename, const Options& options, const AidlDefinedType& defined_type) { const char* p; string expected; string fn; size_t len; bool valid = false; if (!IoDelegate::GetAbsolutePath(filename, &fn)) { return false; } const std::string package = defined_type.GetPackage(); if (!package.empty()) { expected = package; expected += '.'; } len = expected.length(); for (size_t i=0; i= expected.length()); if (valid) { p = fn.c_str() + (len - expected.length()); #ifdef _WIN32 if (OS_PATH_SEPARATOR != '/') { // Input filename under cygwin most likely has / separators // whereas the expected string uses \\ separators. Adjust // them accordingly. for (char *c = const_cast(p); *c; ++c) { if (*c == '/') *c = OS_PATH_SEPARATOR; } } #endif // aidl assumes case-insensitivity on Mac Os and Windows. #if defined(__linux__) valid = (expected == p); #else valid = !strcasecmp(expected.c_str(), p); #endif } if (!valid) { AIDL_ERROR(defined_type) << name << " should be declared in a file called " << expected; return false; } // Make sure that base directory of this AIDL file is one of the import directories. Base // directory of an AIDL file `some/dir/package/name/Iface.aidl` is defined as `some/dir` if the // package name is `package.name` and the type name is `Iface`. This check is needed because the // build system that invokes this aidl compiler doesn't have knowledge about what the package // name is for a given aidl file; because the build system doesn't parse the file. The only hint // that user can give to the build system is the import path. In the above case, by specifying // the import path to be `some/dir/`, the build system can know that the package name is what // follows the import path: `package.name`. // This is not used when the user has specified the exact output file path though. if (options.OutputFile().empty()) { std::string_view basedir(filename); basedir.remove_suffix(expected.length()); if (basedir.empty()) { basedir = "./"; } const std::set& i = options.ImportDirs(); if (std::find_if(i.begin(), i.end(), [&basedir](const std::string& i) { return basedir == i; }) == i.end()) { AIDL_ERROR(defined_type) << "directory " << basedir << " is not found in any of the import paths:\n - " << base::Join(options.ImportDirs(), "\n - "); return false; } } // All checks passed return true; } bool write_dep_file(const Options& options, const AidlDefinedType& defined_type, const vector& imports, const IoDelegate& io_delegate, const string& input_file, const string& output_file) { string dep_file_name = options.DependencyFile(); if (dep_file_name.empty() && options.AutoDepFile()) { dep_file_name = output_file + ".d"; } if (dep_file_name.empty()) { return true; // nothing to do } CodeWriterPtr writer = io_delegate.GetCodeWriter(dep_file_name); if (!writer) { AIDL_ERROR(dep_file_name) << "Could not open dependency file."; return false; } vector source_aidl = {input_file}; for (const auto& import : imports) { source_aidl.push_back(import); } // Encode that the output file depends on aidl input files. if (defined_type.AsUnstructuredParcelable() != nullptr && options.TargetLanguage() == Options::Language::JAVA) { // Legacy behavior. For parcelable declarations in Java, don't emit output file as // the dependency target. b/141372861 writer->Write(" : \\\n"); } else { writer->Write("%s : \\\n", output_file.c_str()); } writer->Write(" %s", Join(source_aidl, " \\\n ").c_str()); writer->Write("\n"); if (!options.DependencyFileNinja()) { writer->Write("\n"); // Output ": " so make won't fail if the input .aidl file // has been deleted, moved or renamed in incremental build. for (const auto& src : source_aidl) { writer->Write("%s :\n", src.c_str()); } } if (options.IsCppOutput()) { if (!options.DependencyFileNinja()) { using ::android::aidl::cpp::ClassNames; using ::android::aidl::cpp::HeaderFile; vector headers; for (ClassNames c : {ClassNames::CLIENT, ClassNames::SERVER, ClassNames::RAW}) { headers.push_back(options.OutputHeaderDir() + HeaderFile(defined_type, c, false /* use_os_sep */)); } writer->Write("\n"); // Generated headers also depend on the source aidl files. writer->Write("%s : \\\n %s\n", Join(headers, " \\\n ").c_str(), Join(source_aidl, " \\\n ").c_str()); } } return true; } // Returns the path to the destination file of `defined_type`. string GetOutputFilePath(const Options& options, const AidlDefinedType& defined_type) { string result = options.OutputDir(); // add the package string package = defined_type.GetPackage(); if (!package.empty()) { for (auto& c : package) { if (c == '.') { c = OS_PATH_SEPARATOR; } } result += package; result += OS_PATH_SEPARATOR; } // add the filename result += defined_type.GetName(); if (options.TargetLanguage() == Options::Language::JAVA) { result += ".java"; } else if (options.IsCppOutput()) { result += ".cpp"; } else if (options.TargetLanguage() == Options::Language::RUST) { result += ".rs"; } else { AIDL_FATAL("Unknown target language"); return ""; } return result; } bool CheckAndAssignMethodIDs(const std::vector>& items) { // Check whether there are any methods with manually assigned id's and any // that are not. Either all method id's must be manually assigned or all of // them must not. Also, check for uplicates of user set ID's and that the // ID's are within the proper bounds. set usedIds; bool hasUnassignedIds = false; bool hasAssignedIds = false; int newId = kMinUserSetMethodId; for (const auto& item : items) { // However, meta transactions that are added by the AIDL compiler are // exceptions. They have fixed IDs but allowed to be with user-defined // methods having auto-assigned IDs. This is because the Ids of the meta // transactions must be stable during the entire lifetime of an interface. // In other words, their IDs must be the same even when new user-defined // methods are added. if (!item->IsUserDefined()) { continue; } if (item->HasId()) { hasAssignedIds = true; } else { item->SetId(newId++); hasUnassignedIds = true; } if (hasAssignedIds && hasUnassignedIds) { AIDL_ERROR(item) << "You must either assign id's to all methods or to none of them."; return false; } // Ensure that the user set id is not duplicated. if (usedIds.find(item->GetId()) != usedIds.end()) { // We found a duplicate id, so throw an error. AIDL_ERROR(item) << "Found duplicate method id (" << item->GetId() << ") for method " << item->GetName(); return false; } usedIds.insert(item->GetId()); // Ensure that the user set id is within the appropriate limits if (item->GetId() < kMinUserSetMethodId || item->GetId() > kMaxUserSetMethodId) { AIDL_ERROR(item) << "Found out of bounds id (" << item->GetId() << ") for method " << item->GetName() << ". Value for id must be between " << kMinUserSetMethodId << " and " << kMaxUserSetMethodId << " inclusive."; return false; } } return true; } bool ValidateAnnotationContext(const AidlDocument& doc) { struct AnnotationValidator : AidlVisitor { bool success = true; void Check(const AidlAnnotatable& annotatable, AidlAnnotation::TargetContext context) { for (const auto& annot : annotatable.GetAnnotations()) { if (!annot->CheckContext(context)) { success = false; } } } void Visit(const AidlInterface& m) override { Check(m, AidlAnnotation::CONTEXT_TYPE_INTERFACE); } void Visit(const AidlParcelable& m) override { Check(m, AidlAnnotation::CONTEXT_TYPE_UNSTRUCTURED_PARCELABLE); } void Visit(const AidlStructuredParcelable& m) override { Check(m, AidlAnnotation::CONTEXT_TYPE_STRUCTURED_PARCELABLE); } void Visit(const AidlEnumDeclaration& m) override { Check(m, AidlAnnotation::CONTEXT_TYPE_ENUM); } void Visit(const AidlUnionDecl& m) override { Check(m, AidlAnnotation::CONTEXT_TYPE_UNION); } void Visit(const AidlMethod& m) override { Check(m.GetType(), AidlAnnotation::CONTEXT_TYPE_SPECIFIER | AidlAnnotation::CONTEXT_METHOD); for (const auto& arg : m.GetArguments()) { Check(arg->GetType(), AidlAnnotation::CONTEXT_TYPE_SPECIFIER); } } void Visit(const AidlConstantDeclaration& m) override { Check(m.GetType(), AidlAnnotation::CONTEXT_TYPE_SPECIFIER | AidlAnnotation::CONTEXT_CONST); } void Visit(const AidlVariableDeclaration& m) override { Check(m.GetType(), AidlAnnotation::CONTEXT_TYPE_SPECIFIER | AidlAnnotation::CONTEXT_FIELD); } void Visit(const AidlTypeSpecifier& m) override { // nested generic type parameters are checked as well if (m.IsGeneric()) { for (const auto& tp : m.GetTypeParameters()) { Check(*tp, AidlAnnotation::CONTEXT_TYPE_SPECIFIER); } } } }; AnnotationValidator validator; VisitTopDown(validator, doc); return validator.success; } bool ValidateHeaders(Options::Language language, const AidlDocument& doc) { typedef std::string (AidlParcelable::*GetHeader)() const; struct HeaderVisitor : AidlVisitor { bool success = true; const char* str = nullptr; GetHeader getHeader = nullptr; void check(const AidlParcelable& p) { if ((p.*getHeader)().empty()) { AIDL_ERROR(p) << "Unstructured parcelable \"" << p.GetName() << "\" must have " << str << " defined."; success = false; } } void Visit(const AidlParcelable& p) override { check(p); } void Visit(const AidlTypeSpecifier& m) override { auto type = m.GetDefinedType(); if (type) { auto unstructured = type->AsUnstructuredParcelable(); if (unstructured) check(*unstructured); } } }; if (language == Options::Language::CPP) { HeaderVisitor validator; validator.str = "cpp_header"; validator.getHeader = &AidlParcelable::GetCppHeader; VisitTopDown(validator, doc); return validator.success; } else if (language == Options::Language::NDK) { HeaderVisitor validator; validator.str = "ndk_header"; validator.getHeader = &AidlParcelable::GetNdkHeader; VisitTopDown(validator, doc); return validator.success; } else if (language == Options::Language::RUST) { HeaderVisitor validator; validator.str = "rust_type"; validator.getHeader = &AidlParcelable::GetRustType; VisitTopDown(validator, doc); return validator.success; } return true; } } // namespace namespace internals { // WARNING: options are passed here and below, but only the file contents should determine // what is generated for portability. AidlError load_and_validate_aidl(const std::string& input_file_name, const Options& options, const IoDelegate& io_delegate, AidlTypenames* typenames, vector* imported_files) { AidlError err = AidlError::OK; ////////////////////////////////////////////////////////////////////////// // Loading phase ////////////////////////////////////////////////////////////////////////// // Parse the main input file const AidlDocument* document = Parser::Parse(input_file_name, io_delegate, *typenames); if (document == nullptr) { return AidlError::PARSE_ERROR; } int num_top_level_decls = 0; for (const auto& type : document->DefinedTypes()) { if (type->AsUnstructuredParcelable() == nullptr) { num_top_level_decls++; if (num_top_level_decls > 1) { AIDL_ERROR(*type) << "You must declare only one type per file."; return AidlError::BAD_TYPE; } } } // Import the preprocessed file for (const string& filename : options.PreprocessedFiles()) { auto preprocessed = Parser::Parse(filename, io_delegate, *typenames, /*is_preprocessed=*/true); if (!preprocessed) { return AidlError::BAD_PRE_PROCESSED_FILE; } } // Find files to import and parse them vector import_paths; ImportResolver import_resolver{io_delegate, input_file_name, options.ImportDirs()}; for (const auto& import : document->Imports()) { if (typenames->IsIgnorableImport(import)) { // There are places in the Android tree where an import doesn't resolve, // but we'll pick the type up through the preprocessed types. // This seems like an error, but legacy support demands we support it... continue; } string import_path = import_resolver.FindImportFile(import); if (import_path.empty()) { err = AidlError::BAD_IMPORT; continue; } import_paths.emplace_back(import_path); auto imported_doc = Parser::Parse(import_path, io_delegate, *typenames); if (imported_doc == nullptr) { AIDL_ERROR(import_path) << "error while importing " << import_path << " for " << import; err = AidlError::BAD_IMPORT; continue; } } if (err != AidlError::OK) { return err; } TypeResolver resolver = [&](const AidlDefinedType* scope, AidlTypeSpecifier* type) { // resolve with already loaded types if (type->Resolve(*typenames, scope)) { return true; } const string import_path = import_resolver.FindImportFile(scope->ResolveName(type->GetName())); if (import_path.empty()) { return false; } import_paths.push_back(import_path); auto imported_doc = Parser::Parse(import_path, io_delegate, *typenames); if (imported_doc == nullptr) { AIDL_ERROR(import_path) << "error while importing " << import_path << " for " << import_path; return false; } // now, try to resolve it again if (!type->Resolve(*typenames, scope)) { AIDL_ERROR(type) << "Can't resolve " << type->GetName(); return false; } return true; }; // Resolve the unresolved references if (!ResolveReferences(*document, resolver)) { return AidlError::BAD_TYPE; } if (!typenames->Autofill()) { return AidlError::BAD_TYPE; } ////////////////////////////////////////////////////////////////////////// // Validation phase ////////////////////////////////////////////////////////////////////////// const auto& types = document->DefinedTypes(); const int num_defined_types = types.size(); for (const auto& defined_type : types) { AIDL_FATAL_IF(defined_type == nullptr, document); // Ensure type is exactly one of the following: AidlInterface* interface = defined_type->AsInterface(); AidlStructuredParcelable* parcelable = defined_type->AsStructuredParcelable(); AidlParcelable* unstructured_parcelable = defined_type->AsUnstructuredParcelable(); AidlEnumDeclaration* enum_decl = defined_type->AsEnumDeclaration(); AidlUnionDecl* union_decl = defined_type->AsUnionDeclaration(); AIDL_FATAL_IF( !!interface + !!parcelable + !!unstructured_parcelable + !!enum_decl + !!union_decl != 1, defined_type); // Ensure that foo.bar.IFoo is defined in /foo/bar/IFoo.aidl if (num_defined_types == 1 && !check_filename(input_file_name, options, *defined_type)) { return AidlError::BAD_PACKAGE; } { bool valid_type = true; if (!defined_type->CheckValid(*typenames)) { valid_type = false; } if (!defined_type->LanguageSpecificCheckValid(options.TargetLanguage())) { valid_type = false; } if (!valid_type) { return AidlError::BAD_TYPE; } } if (unstructured_parcelable != nullptr) { auto lang = options.TargetLanguage(); bool isStable = unstructured_parcelable->IsStableApiParcelable(lang); if (options.IsStructured() && !isStable) { AIDL_ERROR(unstructured_parcelable) << "Cannot declare unstructured parcelable in a --structured interface. Parcelable " "must be defined in AIDL directly."; return AidlError::NOT_STRUCTURED; } if (options.FailOnParcelable() || lang == Options::Language::NDK || lang == Options::Language::RUST) { AIDL_ERROR(unstructured_parcelable) << "Refusing to generate code with unstructured parcelables. Declared parcelables " "should be in their own file and/or cannot be used with --structured interfaces."; return AidlError::FOUND_PARCELABLE; } } if (defined_type->IsVintfStability()) { bool success = true; if (options.GetStability() != Options::Stability::VINTF) { AIDL_ERROR(defined_type) << "Must compile @VintfStability type w/ aidl_interface 'stability: \"vintf\"'"; success = false; } if (!options.IsStructured()) { AIDL_ERROR(defined_type) << "Must compile @VintfStability type w/ aidl_interface --structured"; success = false; } if (!success) return AidlError::NOT_STRUCTURED; } } // We only want to mutate the types defined in this AIDL file or subtypes. We can't // use IterateTypes, as this will re-mutate types that have already been loaded // when AidlTypenames is re-used (such as in dump API). class MetaMethodVisitor : public AidlVisitor { public: MetaMethodVisitor(const Options* options, const AidlTypenames* typenames) : mOptions(options), mTypenames(typenames) {} virtual void Visit(const AidlInterface& const_interface) { // TODO: we do not have mutable visitor infrastructure. AidlInterface* interface = const_cast(&const_interface); if (mOptions->Version() > 0) { auto ret = mTypenames->MakeResolvedType(AIDL_LOCATION_HERE, "int", false); vector>* args = new vector>(); auto method = std::make_unique(AIDL_LOCATION_HERE, false, ret.release(), "getInterfaceVersion", args, Comments{}, kGetInterfaceVersionId); interface->AddMethod(std::move(method)); } // add the meta-method 'string getInterfaceHash()' if hash is specified. if (!mOptions->Hash().empty()) { auto ret = mTypenames->MakeResolvedType(AIDL_LOCATION_HERE, "String", false); vector>* args = new vector>(); auto method = std::make_unique(AIDL_LOCATION_HERE, false, ret.release(), kGetInterfaceHash, args, Comments{}, kGetInterfaceHashId); interface->AddMethod(std::move(method)); } } private: const Options* mOptions; const AidlTypenames* mTypenames; }; MetaMethodVisitor meta_method_visitor(&options, typenames); for (const auto& defined_type : types) { VisitTopDown(meta_method_visitor, *defined_type); } typenames->IterateTypes([&](const AidlDefinedType& type) { const AidlInterface* interface = type.AsInterface(); if (interface == nullptr) return; if (!CheckAndAssignMethodIDs(interface->GetMethods())) { err = AidlError::BAD_METHOD_ID; } }); if (err != AidlError::OK) { return err; } for (const auto& doc : typenames->AllDocuments()) { VisitTopDown([](const AidlNode& n) { n.MarkVisited(); }, *doc); } if (!CheckValid(*document, options)) { return AidlError::BAD_TYPE; } if (!ValidateAnnotationContext(*document)) { return AidlError::BAD_TYPE; } if (!ValidateHeaders(options.TargetLanguage(), *document)) { return AidlError::BAD_TYPE; } if (!Diagnose(*document, options.GetDiagnosticMapping())) { return AidlError::BAD_TYPE; } typenames->IterateTypes([&](const AidlDefinedType& type) { if (!type.LanguageSpecificCheckValid(options.TargetLanguage())) { err = AidlError::BAD_TYPE; } bool isStable = type.IsStableApiParcelable(options.TargetLanguage()); if (options.IsStructured() && type.AsUnstructuredParcelable() != nullptr && !isStable) { err = AidlError::NOT_STRUCTURED; AIDL_ERROR(type) << type.GetCanonicalName() << " is not structured, but this is a structured interface in " << to_string(options.TargetLanguage()); } if (options.GetStability() == Options::Stability::VINTF && !type.IsVintfStability() && !isStable) { err = AidlError::NOT_STRUCTURED; AIDL_ERROR(type) << type.GetCanonicalName() << " does not have VINTF level stability (marked @VintfStability), but this " "interface requires it in " << to_string(options.TargetLanguage()); } // Ensure that untyped List/Map is not used in a parcelable, a union and a stable interface. std::function check_untyped_container = [&err, &check_untyped_container](const AidlTypeSpecifier& type, const AidlNode* node) { if (type.IsGeneric()) { std::for_each(type.GetTypeParameters().begin(), type.GetTypeParameters().end(), [&node, &check_untyped_container](auto& nested) { check_untyped_container(*nested, node); }); return; } if (type.GetName() == "List" || type.GetName() == "Map") { err = AidlError::BAD_TYPE; AIDL_ERROR(node) << "Encountered an untyped List or Map. The use of untyped List/Map is prohibited " << "because it is not guaranteed that the objects in the list are recognizable in " << "the receiving side. Consider switching to an array or a generic List/Map."; } }; if (type.AsInterface() && options.IsStructured()) { for (const auto& method : type.GetMethods()) { check_untyped_container(method->GetType(), method.get()); for (const auto& arg : method->GetArguments()) { check_untyped_container(arg->GetType(), method.get()); } } } for (const auto& field : type.GetFields()) { check_untyped_container(field->GetType(), field.get()); } }); if (err != AidlError::OK) { return err; } if (imported_files != nullptr) { *imported_files = import_paths; } return AidlError::OK; } void markNewAdditions(AidlTypenames& typenames, const AidlTypenames& previous_typenames) { for (const AidlDefinedType* type : typenames.AllDefinedTypes()) { const AidlDefinedType* previous_type = nullptr; for (const AidlDefinedType* previous : previous_typenames.AllDefinedTypes()) { if (type->GetCanonicalName() == previous->GetCanonicalName()) { previous_type = previous; } } if (previous_type == nullptr) { // This is a new type for this version. continue; } if (type->AsInterface()) { for (const std::unique_ptr& member : type->AsInterface()->GetMethods()) { if (!member->IsUserDefined()) continue; bool found = false; for (const std::unique_ptr& previous_member : previous_type->GetMethods()) { if (previous_member->GetName() == member->GetName()) { found = true; } } if (!found) member->MarkNew(); } } else if (type->AsStructuredParcelable() || type->AsUnionDeclaration()) { for (const std::unique_ptr& member : type->GetFields()) { if (!member->IsUserDefined()) continue; bool found = false; for (const std::unique_ptr& previous_member : previous_type->GetFields()) { if (previous_member->GetName() == member->GetName()) { found = true; } } if (!found) member->MarkNew(); } } else if (type->AsEnumDeclaration() || type->AsUnstructuredParcelable()) { // We have nothing to do for these types } else { AIDL_FATAL(type) << "Unexpected type when looking for new members"; } } } } // namespace internals bool compile_aidl(const Options& options, const IoDelegate& io_delegate) { const Options::Language lang = options.TargetLanguage(); // load the previously frozen version if it exists Result previous_typenames_result; if (options.IsLatestUnfrozenVersion()) { // TODO(b/292005937) Once LoadApiDump can handle the OS_PATH_SEPARATOR at // the end of PreviousApiDir, we can stop passing in a substr without it. AIDL_FATAL_IF(options.PreviousApiDir().back() != OS_PATH_SEPARATOR, "Expecting a separator"); previous_typenames_result = LoadApiDump(options.WithNoWarnings().WithoutVersion().AsPreviousVersion(), io_delegate, options.PreviousApiDir().substr(0, options.PreviousApiDir().size() - 1)); if (!previous_typenames_result.ok()) { AIDL_ERROR(options.PreviousApiDir()) << "Failed to load api dump for '" << options.PreviousApiDir() << "'. Error: " << previous_typenames_result.error().message(); return false; } } for (const string& input_file : options.InputFiles()) { AidlTypenames typenames; vector imported_files; AidlError aidl_err = internals::load_and_validate_aidl(input_file, options, io_delegate, &typenames, &imported_files); if (aidl_err != AidlError::OK) { return false; } if (options.IsLatestUnfrozenVersion()) { internals::markNewAdditions(typenames, previous_typenames_result.value()); } for (const auto& defined_type : typenames.MainDocument().DefinedTypes()) { AIDL_FATAL_IF(defined_type == nullptr, input_file); string output_file_name = options.OutputFile(); // if needed, generate the output file name from the base folder if (output_file_name.empty() && !options.OutputDir().empty()) { output_file_name = GetOutputFilePath(options, *defined_type); if (output_file_name.empty()) { return false; } } if (!write_dep_file(options, *defined_type, imported_files, io_delegate, input_file, output_file_name)) { return false; } bool success = false; if (lang == Options::Language::CPP) { success = cpp::GenerateCpp(output_file_name, options, typenames, *defined_type, io_delegate); } else if (lang == Options::Language::NDK) { ndk::GenerateNdk(output_file_name, options, typenames, *defined_type, io_delegate); success = true; } else if (lang == Options::Language::JAVA) { if (defined_type->AsUnstructuredParcelable() != nullptr) { // Legacy behavior. For parcelable declarations in Java, don't generate code. success = true; // If the output directory is set, we're not going to be dropping a file right // next to the .aidl code, so we shouldn't be clobbering an existing // implementation unless someone has set their output dir to be their source // dir explicitly. // The build system expects us to produce an output file, so produce an empty one. if (!options.OutputDir().empty()) { io_delegate.GetCodeWriter(output_file_name)->Close(); } } else { java::GenerateJava(output_file_name, options, typenames, *defined_type, io_delegate); success = true; } } else if (lang == Options::Language::RUST) { rust::GenerateRust(output_file_name, options, typenames, *defined_type, io_delegate); success = true; } else if (lang == Options::Language::CPP_ANALYZER) { success = cpp::GenerateCppAnalyzer(output_file_name, options, typenames, *defined_type, io_delegate); } else { AIDL_FATAL(input_file) << "Should not reach here."; } if (!success) { return false; } } } return true; } bool dump_mappings(const Options& options, const IoDelegate& io_delegate) { android::aidl::mappings::SignatureMap all_mappings; for (const string& input_file : options.InputFiles()) { AidlTypenames typenames; vector imported_files; AidlError aidl_err = internals::load_and_validate_aidl(input_file, options, io_delegate, &typenames, &imported_files); if (aidl_err != AidlError::OK) { return false; } for (const auto& defined_type : typenames.MainDocument().DefinedTypes()) { auto mappings = mappings::generate_mappings(defined_type.get()); all_mappings.insert(mappings.begin(), mappings.end()); } } std::stringstream mappings_str; for (const auto& mapping : all_mappings) { mappings_str << mapping.first << "\n" << mapping.second << "\n"; } auto code_writer = io_delegate.GetCodeWriter(options.OutputFile()); code_writer->Write("%s", mappings_str.str().c_str()); return true; } int aidl_entry(const Options& options, const IoDelegate& io_delegate) { AidlErrorLog::clearError(); AidlNode::ClearUnvisitedNodes(); bool success = false; if (options.Ok()) { switch (options.GetTask()) { case Options::Task::HELP: success = true; break; case Options::Task::COMPILE: success = android::aidl::compile_aidl(options, io_delegate); break; case Options::Task::PREPROCESS: success = android::aidl::Preprocess(options, io_delegate); break; case Options::Task::DUMP_API: success = android::aidl::dump_api(options, io_delegate); break; case Options::Task::CHECK_API: success = android::aidl::check_api(options, io_delegate); break; case Options::Task::DUMP_MAPPINGS: success = android::aidl::dump_mappings(options, io_delegate); break; default: AIDL_FATAL(AIDL_LOCATION_HERE) << "Unrecognized task: " << static_cast(options.GetTask()); } } else { AIDL_ERROR(options.GetErrorMessage()) << options.GetUsage(); } const bool reportedError = AidlErrorLog::hadError(); AIDL_FATAL_IF(success == reportedError, AIDL_LOCATION_HERE) << "Compiler returned success " << success << " but did" << (reportedError ? "" : " not") << " emit error logs"; if (success) { auto locations = AidlNode::GetLocationsOfUnvisitedNodes(); if (!locations.empty()) { for (const auto& location : locations) { AIDL_ERROR(location) << "AidlNode at location was not visited!"; } AIDL_FATAL(AIDL_LOCATION_HERE) << "The AIDL AST was not processed fully. Please report an issue."; } } return success ? 0 : 1; } } // namespace aidl } // namespace android ./PaxHeaders.X/aidl.h0100644 0000000 0000000 00000000034 15172120304 013356 xustar000000000 0000000 28 mtime=1776853188.2750000 aidl.h0100644 0000000 0000000 00000005565 15172120304 010675 0ustar000000000 0000000 /* * Copyright (C) 2015, 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. */ #pragma once #include #include #include #include #include "aidl_language.h" #include "import_resolver.h" #include "io_delegate.h" #include "options.h" namespace android { namespace aidl { enum class AidlError { UNKOWN = std::numeric_limits::min(), BAD_PRE_PROCESSED_FILE, PARSE_ERROR, FOUND_PARCELABLE, BAD_PACKAGE, BAD_IMPORT, BAD_TYPE, BAD_METHOD_ID, GENERATION_ERROR, BAD_INPUT, NOT_STRUCTURED, OK = 0, }; bool compile_aidl(const Options& options, const IoDelegate& io_delegate); bool dump_mappings(const Options& options, const IoDelegate& io_delegate); // main entry point to AIDL int aidl_entry(const Options& options, const IoDelegate& io_delegate); const char kPreamble[] = R"(/////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL file. Do not edit it manually. There are // two cases: // 1). this is a frozen version file - do not edit this in any case. // 2). this is a 'current' file. If you make a backwards compatible change to // the interface (from the latest frozen version), the build system will // prompt you to update this file with `m -update-api`. // // You must not make a backward incompatible change to any AIDL file built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. )"; const string kGetInterfaceVersion("getInterfaceVersion"); const string kGetInterfaceHash("getInterfaceHash"); namespace internals { AidlError load_and_validate_aidl(const std::string& input_file_name, const Options& options, const IoDelegate& io_delegate, AidlTypenames* typenames, vector* imported_files); } // namespace internals } // namespace aidl } // namespace android ./PaxHeaders.X/aidl_api_0100644 0000000 0000000 00000000034 15172120304 014120 xustar000000000 0000000 28 mtime=1776853188.2750000 aidl_api/0040755 0000000 0000000 00000000000 15172120304 011345 5ustar000000000 0000000 ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_0100644 0000000 0000000 00000000034 15172120304 022020 xustar000000000 0000000 28 mtime=1776853188.2750000 aidl_api/aidl-test-versioned-interface/0040755 0000000 0000000 00000000000 15172120304 017165 5ustar000000000 0000000 ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_1_0100644 0000000 0000000 00000000034 15172120304 022240 xustar000000000 0000000 28 mtime=1776853188.2760000 aidl_api/aidl-test-versioned-interface/1/0040755 0000000 0000000 00000000000 15172120304 017325 5ustar000000000 0000000 ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_1_.hash0100644 0000000 0000000 00000000034 15172120304 023162 xustar000000000 0000000 28 mtime=1776853188.2760000 aidl_api/aidl-test-versioned-interface/1/.hash0100644 0000000 0000000 00000000122 15172120304 020241 0ustar000000000 0000000 f211f7823c8279224434f5b9a0b095c1f5ebfc15 9e7be1859820c59d9d55dd133e71a3687b5d2e5b ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_1_android_0100644 0000000 0000000 00000000034 15172120304 023740 xustar000000000 0000000 28 mtime=1776853188.2760000 aidl_api/aidl-test-versioned-interface/1/android/0040755 0000000 0000000 00000000000 15172120304 020745 5ustar000000000 0000000 ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_1_android_aidl_0100644 0000000 0000000 00000000034 15172120304 024731 xustar000000000 0000000 28 mtime=1776853188.2760000 aidl_api/aidl-test-versioned-interface/1/android/aidl/0040755 0000000 0000000 00000000000 15172120304 021656 5ustar000000000 0000000 ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_1_android_aidl_versioned_0100644 0000000 0000000 00000000034 15172120304 027007 xustar000000000 0000000 28 mtime=1776853188.2760000 aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/0040755 0000000 0000000 00000000000 15172120304 023654 5ustar000000000 0000000 ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_1_android_aidl_versioned_tests_0100644 0000000 0000000 00000000034 15172120304 030231 xustar000000000 0000000 28 mtime=1776853188.2760000 aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/0040755 0000000 0000000 00000000000 15172120304 025016 5ustar000000000 0000000 ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_1_android_aidl_versioned_tests_BazUnion.aidl0100644 0000000 0000000 00000000034 15172120304 032607 xustar000000000 0000000 28 mtime=1776853188.2760000 aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl0100644 0000000 0000000 00000002134 15172120304 027373 0ustar000000000 0000000 /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL interface (or parcelable). Do not try to // edit this file. It looks like you are doing that because you have modified // an AIDL interface in a backward-incompatible way, e.g., deleting a function // from an interface or a field from a parcelable and it broke the build. That // breakage is intended. // // You must not make a backward incompatible changes to the AIDL files built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package android.aidl.versioned.tests; union BazUnion { int intNum; } ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_1_android_aidl_versioned_tests_Foo.aidl0100644 0000000 0000000 00000000034 15172120304 031605 xustar000000000 0000000 28 mtime=1776853188.2760000 aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl0100644 0000000 0000000 00000002116 15172120304 026371 0ustar000000000 0000000 /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL interface (or parcelable). Do not try to // edit this file. It looks like you are doing that because you have modified // an AIDL interface in a backward-incompatible way, e.g., deleting a function // from an interface or a field from a parcelable and it broke the build. That // breakage is intended. // // You must not make a backward incompatible changes to the AIDL files built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package android.aidl.versioned.tests; parcelable Foo { } ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_1_android_aidl_versioned_tests_IFooInterface.0100644 0000000 0000000 00000000034 15172120304 032705 xustar000000000 0000000 28 mtime=1776853188.2760000 aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/IFooInterface.aidl0100644 0000000 0000000 00000002772 15172120304 030333 0ustar000000000 0000000 /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL interface (or parcelable). Do not try to // edit this file. It looks like you are doing that because you have modified // an AIDL interface in a backward-incompatible way, e.g., deleting a function // from an interface or a field from a parcelable and it broke the build. That // breakage is intended. // // You must not make a backward incompatible changes to the AIDL files built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package android.aidl.versioned.tests; interface IFooInterface { void originalApi(); @utf8InCpp String acceptUnionAndReturnString(in android.aidl.versioned.tests.BazUnion u); @SuppressWarnings(value={"inout-parameter"}) int ignoreParcelablesAndRepeatInt(in android.aidl.versioned.tests.Foo inFoo, inout android.aidl.versioned.tests.Foo inoutFoo, out android.aidl.versioned.tests.Foo outFoo, int value); int returnsLengthOfFooArray(in android.aidl.versioned.tests.Foo[] foos); } ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_2_0100644 0000000 0000000 00000000034 15172120304 022241 xustar000000000 0000000 28 mtime=1776853188.2760000 aidl_api/aidl-test-versioned-interface/2/0040755 0000000 0000000 00000000000 15172120304 017326 5ustar000000000 0000000 ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_2_.hash0100644 0000000 0000000 00000000034 15172120304 023163 xustar000000000 0000000 28 mtime=1776853188.2760000 aidl_api/aidl-test-versioned-interface/2/.hash0100644 0000000 0000000 00000000051 15172120304 020243 0ustar000000000 0000000 da8c4bc94ca7feff0e0a65563a466787698b5891 ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_2_android_0100644 0000000 0000000 00000000034 15172120304 023741 xustar000000000 0000000 28 mtime=1776853188.2760000 aidl_api/aidl-test-versioned-interface/2/android/0040755 0000000 0000000 00000000000 15172120304 020746 5ustar000000000 0000000 ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_2_android_aidl_0100644 0000000 0000000 00000000034 15172120304 024732 xustar000000000 0000000 28 mtime=1776853188.2760000 aidl_api/aidl-test-versioned-interface/2/android/aidl/0040755 0000000 0000000 00000000000 15172120304 021657 5ustar000000000 0000000 ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_2_android_aidl_versioned_0100644 0000000 0000000 00000000034 15172120304 027010 xustar000000000 0000000 28 mtime=1776853188.2760000 aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/0040755 0000000 0000000 00000000000 15172120304 023655 5ustar000000000 0000000 ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_2_android_aidl_versioned_tests_0100644 0000000 0000000 00000000034 15172120304 030232 xustar000000000 0000000 28 mtime=1776853188.2760000 aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/0040755 0000000 0000000 00000000000 15172120304 025017 5ustar000000000 0000000 ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_2_android_aidl_versioned_tests_BazUnion.aidl0100644 0000000 0000000 00000000034 15172120304 032610 xustar000000000 0000000 28 mtime=1776853188.2760000 aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl0100644 0000000 0000000 00000002154 15172120304 027376 0ustar000000000 0000000 /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL interface (or parcelable). Do not try to // edit this file. It looks like you are doing that because you have modified // an AIDL interface in a backward-incompatible way, e.g., deleting a function // from an interface or a field from a parcelable and it broke the build. That // breakage is intended. // // You must not make a backward incompatible changes to the AIDL files built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package android.aidl.versioned.tests; union BazUnion { int intNum; long longNum; } ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_2_android_aidl_versioned_tests_Foo.aidl0100644 0000000 0000000 00000000034 15172120304 031606 xustar000000000 0000000 28 mtime=1776853188.2760000 aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl0100644 0000000 0000000 00000002147 15172120304 026376 0ustar000000000 0000000 /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL interface (or parcelable). Do not try to // edit this file. It looks like you are doing that because you have modified // an AIDL interface in a backward-incompatible way, e.g., deleting a function // from an interface or a field from a parcelable and it broke the build. That // breakage is intended. // // You must not make a backward incompatible changes to the AIDL files built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package android.aidl.versioned.tests; parcelable Foo { int intDefault42 = 42; } ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_2_android_aidl_versioned_tests_IFooInterface.0100644 0000000 0000000 00000000034 15172120304 032706 xustar000000000 0000000 28 mtime=1776853188.2760000 aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/IFooInterface.aidl0100644 0000000 0000000 00000003013 15172120304 030321 0ustar000000000 0000000 /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL interface (or parcelable). Do not try to // edit this file. It looks like you are doing that because you have modified // an AIDL interface in a backward-incompatible way, e.g., deleting a function // from an interface or a field from a parcelable and it broke the build. That // breakage is intended. // // You must not make a backward incompatible changes to the AIDL files built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package android.aidl.versioned.tests; interface IFooInterface { void originalApi(); @utf8InCpp String acceptUnionAndReturnString(in android.aidl.versioned.tests.BazUnion u); @SuppressWarnings(value={"inout-parameter"}) int ignoreParcelablesAndRepeatInt(in android.aidl.versioned.tests.Foo inFoo, inout android.aidl.versioned.tests.Foo inoutFoo, out android.aidl.versioned.tests.Foo outFoo, int value); int returnsLengthOfFooArray(in android.aidl.versioned.tests.Foo[] foos); void newApi(); } ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_3_0100644 0000000 0000000 00000000034 15172120304 022242 xustar000000000 0000000 28 mtime=1776853188.2760000 aidl_api/aidl-test-versioned-interface/3/0040755 0000000 0000000 00000000000 15172120304 017327 5ustar000000000 0000000 ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_3_.hash0100644 0000000 0000000 00000000034 15172120304 023164 xustar000000000 0000000 28 mtime=1776853188.2760000 aidl_api/aidl-test-versioned-interface/3/.hash0100644 0000000 0000000 00000000051 15172120304 020244 0ustar000000000 0000000 70d76c61eb0c82288e924862c10b910d1b7d8cf8 ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_3_android_0100644 0000000 0000000 00000000034 15172120304 023742 xustar000000000 0000000 28 mtime=1776853188.2760000 aidl_api/aidl-test-versioned-interface/3/android/0040755 0000000 0000000 00000000000 15172120304 020747 5ustar000000000 0000000 ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_3_android_aidl_0100644 0000000 0000000 00000000034 15172120304 024733 xustar000000000 0000000 28 mtime=1776853188.2760000 aidl_api/aidl-test-versioned-interface/3/android/aidl/0040755 0000000 0000000 00000000000 15172120304 021660 5ustar000000000 0000000 ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_3_android_aidl_versioned_0100644 0000000 0000000 00000000034 15172120304 027011 xustar000000000 0000000 28 mtime=1776853188.2760000 aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/0040755 0000000 0000000 00000000000 15172120304 023656 5ustar000000000 0000000 ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_3_android_aidl_versioned_tests_0100644 0000000 0000000 00000000034 15172120304 030233 xustar000000000 0000000 28 mtime=1776853188.2760000 aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/0040755 0000000 0000000 00000000000 15172120304 025020 5ustar000000000 0000000 ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_3_android_aidl_versioned_tests_BazUnion.aidl0100644 0000000 0000000 00000000034 15172120304 032611 xustar000000000 0000000 28 mtime=1776853188.2760000 aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl0100644 0000000 0000000 00000002225 15172120304 027376 0ustar000000000 0000000 /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL file. Do not edit it manually. There are // two cases: // 1). this is a frozen version file - do not edit this in any case. // 2). this is a 'current' file. If you make a backwards compatible change to // the interface (from the latest frozen version), the build system will // prompt you to update this file with `m -update-api`. // // You must not make a backward incompatible change to any AIDL file built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package android.aidl.versioned.tests; union BazUnion { int intNum; long longNum; } ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_3_android_aidl_versioned_tests_Foo.aidl0100644 0000000 0000000 00000000034 15172120304 031607 xustar000000000 0000000 28 mtime=1776853188.2760000 aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl0100644 0000000 0000000 00000002264 15172120304 026377 0ustar000000000 0000000 /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL file. Do not edit it manually. There are // two cases: // 1). this is a frozen version file - do not edit this in any case. // 2). this is a 'current' file. If you make a backwards compatible change to // the interface (from the latest frozen version), the build system will // prompt you to update this file with `m -update-api`. // // You must not make a backward incompatible change to any AIDL file built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package android.aidl.versioned.tests; @JavaSuppressLint(value={"NewApi"}) parcelable Foo { int intDefault42 = 42; } ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_3_android_aidl_versioned_tests_IFooInterface.0100644 0000000 0000000 00000000034 15172120304 032707 xustar000000000 0000000 28 mtime=1776853188.2760000 aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/IFooInterface.aidl0100644 0000000 0000000 00000003103 15172120304 030322 0ustar000000000 0000000 /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL file. Do not edit it manually. There are // two cases: // 1). this is a frozen version file - do not edit this in any case. // 2). this is a 'current' file. If you make a backwards compatible change to // the interface (from the latest frozen version), the build system will // prompt you to update this file with `m -update-api`. // // You must not make a backward incompatible change to any AIDL file built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package android.aidl.versioned.tests; @JavaDelegator interface IFooInterface { void originalApi(); @utf8InCpp String acceptUnionAndReturnString(in android.aidl.versioned.tests.BazUnion u); @SuppressWarnings(value={"inout-parameter"}) int ignoreParcelablesAndRepeatInt(in android.aidl.versioned.tests.Foo inFoo, inout android.aidl.versioned.tests.Foo inoutFoo, out android.aidl.versioned.tests.Foo outFoo, int value); int returnsLengthOfFooArray(in android.aidl.versioned.tests.Foo[] foos); void newApi(); } ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_current_0100644 0000000 0000000 00000000034 15172120304 023562 xustar000000000 0000000 28 mtime=1776853188.2760000 aidl_api/aidl-test-versioned-interface/current/0040755 0000000 0000000 00000000000 15172120304 020647 5ustar000000000 0000000 ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_current_android_0100644 0000000 0000000 00000000034 15172120304 025262 xustar000000000 0000000 28 mtime=1776853188.2770000 aidl_api/aidl-test-versioned-interface/current/android/0040755 0000000 0000000 00000000000 15172120304 022267 5ustar000000000 0000000 ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_current_android_aidl_0100644 0000000 0000000 00000000034 15172120304 026253 xustar000000000 0000000 28 mtime=1776853188.2770000 aidl_api/aidl-test-versioned-interface/current/android/aidl/0040755 0000000 0000000 00000000000 15172120304 023200 5ustar000000000 0000000 ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_current_android_aidl_versioned_0100644 0000000 0000000 00000000034 15172120304 030331 xustar000000000 0000000 28 mtime=1776853188.2770000 aidl_api/aidl-test-versioned-interface/current/android/aidl/versioned/0040755 0000000 0000000 00000000000 15172120304 025176 5ustar000000000 0000000 ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_current_android_aidl_versioned_tests_0100644 0000000 0000000 00000000034 15172120304 031553 xustar000000000 0000000 28 mtime=1776853188.2770000 aidl_api/aidl-test-versioned-interface/current/android/aidl/versioned/tests/0040755 0000000 0000000 00000000000 15172120304 026340 5ustar000000000 0000000 ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_current_android_aidl_versioned_tests_BazUnion0100644 0000000 0000000 00000000034 15172120304 033221 xustar000000000 0000000 28 mtime=1776853188.2770000 aidl_api/aidl-test-versioned-interface/current/android/aidl/versioned/tests/BazUnion.aidl0100644 0000000 0000000 00000002225 15172120304 030716 0ustar000000000 0000000 /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL file. Do not edit it manually. There are // two cases: // 1). this is a frozen version file - do not edit this in any case. // 2). this is a 'current' file. If you make a backwards compatible change to // the interface (from the latest frozen version), the build system will // prompt you to update this file with `m -update-api`. // // You must not make a backward incompatible change to any AIDL file built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package android.aidl.versioned.tests; union BazUnion { int intNum; long longNum; } ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_current_android_aidl_versioned_tests_Foo.aidl0100644 0000000 0000000 00000000034 15172120304 033127 xustar000000000 0000000 28 mtime=1776853188.2770000 aidl_api/aidl-test-versioned-interface/current/android/aidl/versioned/tests/Foo.aidl0100644 0000000 0000000 00000002266 15172120304 027721 0ustar000000000 0000000 /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL file. Do not edit it manually. There are // two cases: // 1). this is a frozen version file - do not edit this in any case. // 2). this is a 'current' file. If you make a backwards compatible change to // the interface (from the latest frozen version), the build system will // prompt you to update this file with `m -update-api`. // // You must not make a backward incompatible change to any AIDL file built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package android.aidl.versioned.tests; @JavaSuppressLint(value={"NewApi"}) parcelable Foo { int intDefault42 = 42; } ./PaxHeaders.X/aidl_api_aidl-test-versioned-interface_current_android_aidl_versioned_tests_IFooInte0100644 0000000 0000000 00000000034 15172120304 033150 xustar000000000 0000000 28 mtime=1776853188.2770000 aidl_api/aidl-test-versioned-interface/current/android/aidl/versioned/tests/IFooInterface.aidl0100644 0000000 0000000 00000003166 15172120304 031653 0ustar000000000 0000000 /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL file. Do not edit it manually. There are // two cases: // 1). this is a frozen version file - do not edit this in any case. // 2). this is a 'current' file. If you make a backwards compatible change to // the interface (from the latest frozen version), the build system will // prompt you to update this file with `m -update-api`. // // You must not make a backward incompatible change to any AIDL file built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package android.aidl.versioned.tests; @JavaDelegator interface IFooInterface { void originalApi(); @utf8InCpp String acceptUnionAndReturnString( in android.aidl.versioned.tests.BazUnion u); @SuppressWarnings(value={"inout-parameter"}) int ignoreParcelablesAndRepeatInt(in android.aidl.versioned.tests.Foo inFoo, inout android.aidl.versioned.tests.Foo inoutFoo, out android.aidl.versioned.tests.Foo outFoo, int value); int returnsLengthOfFooArray(in android.aidl.versioned.tests.Foo[] foos); void newApi(); } ./PaxHeaders.X/aidl_checkapi.cpp0100644 0000000 0000000 00000000034 15172120304 015540 xustar000000000 0000000 28 mtime=1776853188.2770000 aidl_checkapi.cpp0100644 0000000 0000000 00000053515 15172120304 013055 0ustar000000000 0000000 /* * Copyright (C) 2018, The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "aidl.h" #include #include #include #include #include #include #include "aidl_dumpapi.h" #include "aidl_language.h" #include "import_resolver.h" #include "logging.h" #include "options.h" namespace android { namespace aidl { using android::base::Error; using android::base::Result; using android::base::StartsWith; using std::map; using std::set; using std::string; using std::vector; static std::string Dump(const AidlDefinedType& type) { string code; CodeWriterPtr out = CodeWriter::ForString(&code); DumpVisitor visitor(*out, /*inline_constants=*/true); type.DispatchVisit(visitor); out->Close(); return code; } // Uses each type's Dump() and GTest utility(EqHelper). static bool CheckEquality(const AidlDefinedType& older, const AidlDefinedType& newer) { using testing::internal::EqHelper; auto older_file = older.GetLocation().GetFile(); auto newer_file = newer.GetLocation().GetFile(); auto result = EqHelper::Compare(older_file.data(), newer_file.data(), Dump(older), Dump(newer)); if (!result) { AIDL_ERROR(newer) << result.failure_message(); } return result; } static vector get_strict_annotations(const AidlAnnotatable& node) { // This must be symmetrical (if you can add something, you must be able to // remove it). The reason is that we have no way of knowing which interface a // server serves and which interface a client serves (e.g. a callback // interface). Note that this is being overly lenient. It makes sense for // newer code to start accepting nullable things. However, here, we don't know // if the client of an interface or the server of an interface is newer. // // Here are two examples to demonstrate this: // - a new implementation might change so that it no longer returns null // values (remove @nullable) // - a new implementation might start accepting null values (add @nullable) // // AidlAnnotation::Type::SENSITIVE_DATA could be ignored for backwards // compatibility, but is not. It should retroactively be applied to the // older versions of the interface. When doing that, we need // to add the new hash to the older versions after the change using // tools/aidl/build/hash_gen.sh. static const set kIgnoreAnnotations{ AidlAnnotation::Type::NULLABLE, // @JavaDerive doesn't affect read/write AidlAnnotation::Type::JAVA_DERIVE, AidlAnnotation::Type::JAVA_DEFAULT, AidlAnnotation::Type::JAVA_DELEGATOR, AidlAnnotation::Type::JAVA_ONLY_IMMUTABLE, AidlAnnotation::Type::JAVA_PASSTHROUGH, AidlAnnotation::Type::JAVA_SUPPRESS_LINT, // @RustDerive doesn't affect read/write AidlAnnotation::Type::RUST_DERIVE, AidlAnnotation::Type::SUPPRESS_WARNINGS, }; vector annotations; for (const auto& annotation : node.GetAnnotations()) { if (kIgnoreAnnotations.find(annotation->GetType()) != kIgnoreAnnotations.end()) { continue; } auto annotation_string = annotation->ToString(); // adding @Deprecated (with optional args) is okay if (StartsWith(annotation_string, "@JavaPassthrough(annotation=\"@Deprecated")) { continue; } annotations.push_back(annotation_string); } return annotations; } static bool have_compatible_annotations(const AidlAnnotatable& older, const AidlAnnotatable& newer) { vector olderAnnotations = get_strict_annotations(older); vector newerAnnotations = get_strict_annotations(newer); sort(olderAnnotations.begin(), olderAnnotations.end()); sort(newerAnnotations.begin(), newerAnnotations.end()); if (olderAnnotations != newerAnnotations) { const string from = older.ToString().empty() ? "(empty)" : older.ToString(); const string to = newer.ToString().empty() ? "(empty)" : newer.ToString(); AIDL_ERROR(newer) << "Changed annotations: " << from << " to " << to; return false; } return true; } static bool are_compatible_types(const AidlTypeSpecifier& older, const AidlTypeSpecifier& newer) { bool compatible = true; if (older.Signature() != newer.Signature()) { AIDL_ERROR(newer) << "Type changed: " << older.Signature() << " to " << newer.Signature() << "."; compatible = false; } compatible &= have_compatible_annotations(older, newer); return compatible; } static bool are_compatible_constants(const AidlDefinedType& older, const AidlDefinedType& newer) { bool compatible = true; map new_constdecls; for (const auto& c : newer.GetConstantDeclarations()) { new_constdecls[c->GetName()] = &*c; } for (const auto& old_c : older.GetConstantDeclarations()) { const auto found = new_constdecls.find(old_c->GetName()); if (found == new_constdecls.end()) { AIDL_ERROR(old_c) << "Removed constant declaration: " << older.GetCanonicalName() << "." << old_c->GetName(); compatible = false; continue; } const auto new_c = found->second; compatible &= are_compatible_types(old_c->GetType(), new_c->GetType()); const string old_value = old_c->ValueString(AidlConstantValueDecorator); const string new_value = new_c->ValueString(AidlConstantValueDecorator); if (old_value != new_value) { AIDL_ERROR(newer) << "Changed constant value: " << older.GetCanonicalName() << "." << old_c->GetName() << " from " << old_value << " to " << new_value << "."; compatible = false; } } return compatible; } static bool are_compatible_interfaces(const AidlInterface& older, const AidlInterface& newer) { bool compatible = true; map new_methods; for (const auto& m : newer.AsInterface()->GetMethods()) { new_methods.emplace(m->Signature(), m.get()); } for (const auto& old_m : older.AsInterface()->GetMethods()) { const auto found = new_methods.find(old_m->Signature()); if (found == new_methods.end()) { AIDL_ERROR(old_m) << "Removed or changed method: " << older.GetCanonicalName() << "." << old_m->Signature(); compatible = false; continue; } // Compare IDs to detect method reordering. IDs are assigned by their // textual order, so if there is an ID mismatch, that means reordering // has happened. const auto new_m = found->second; if (old_m->IsOneway() != new_m->IsOneway()) { AIDL_ERROR(new_m) << "Oneway attribute " << (old_m->IsOneway() ? "removed" : "added") << ": " << older.GetCanonicalName() << "." << old_m->Signature(); compatible = false; } if (old_m->GetId() != new_m->GetId()) { AIDL_ERROR(new_m) << "Transaction ID changed: " << older.GetCanonicalName() << "." << old_m->Signature() << " is changed from " << old_m->GetId() << " to " << new_m->GetId() << "."; compatible = false; } compatible &= are_compatible_types(old_m->GetType(), new_m->GetType()); const auto& old_args = old_m->GetArguments(); const auto& new_args = new_m->GetArguments(); // this is guaranteed because arguments are part of AidlMethod::Signature() AIDL_FATAL_IF(old_args.size() != new_args.size(), old_m); for (size_t i = 0; i < old_args.size(); i++) { const AidlArgument& old_a = *(old_args.at(i)); const AidlArgument& new_a = *(new_args.at(i)); compatible &= are_compatible_types(old_a.GetType(), new_a.GetType()); if (old_a.GetDirection() != new_a.GetDirection()) { AIDL_ERROR(new_m) << "Direction changed: " << old_a.GetDirectionSpecifier() << " to " << new_a.GetDirectionSpecifier() << "."; compatible = false; } } } compatible = are_compatible_constants(older, newer) && compatible; return compatible; } static bool HasZeroEnumerator(const AidlEnumDeclaration& enum_decl) { return std::any_of(enum_decl.GetEnumerators().begin(), enum_decl.GetEnumerators().end(), [&](const unique_ptr& enumerator) { return enumerator->GetValue()->ValueString( enum_decl.GetBackingType(), AidlConstantValueDecorator) == "0"; }); } static bool EvaluatesToZero(const AidlEnumDeclaration& enum_decl, const AidlConstantValue* value) { if (value == nullptr) return true; return value->ValueString(enum_decl.GetBackingType(), AidlConstantValueDecorator) == "0"; } static bool are_compatible_parcelables(const AidlDefinedType& older, const AidlTypenames&, const AidlDefinedType& newer, const AidlTypenames& new_types) { const auto& old_fields = older.GetFields(); const auto& new_fields = newer.GetFields(); if (old_fields.size() > new_fields.size()) { // you can add new fields only at the end AIDL_ERROR(newer) << "Number of fields in " << older.GetCanonicalName() << " is reduced from " << old_fields.size() << " to " << new_fields.size() << "."; return false; } if (newer.IsFixedSize() && old_fields.size() != new_fields.size()) { AIDL_ERROR(newer) << "Number of fields in " << older.GetCanonicalName() << " is changed from " << old_fields.size() << " to " << new_fields.size() << ". This is an incompatible change for FixedSize types."; return false; } // android.net.UidRangeParcel should be frozen to prevent breakage in legacy (b/186720556) if (older.GetCanonicalName() == "android.net.UidRangeParcel" && old_fields.size() != new_fields.size()) { AIDL_ERROR(newer) << "Number of fields in " << older.GetCanonicalName() << " is changed from " << old_fields.size() << " to " << new_fields.size() << ". But it is forbidden because of legacy support."; return false; } bool compatible = true; for (size_t i = 0; i < old_fields.size(); i++) { const auto& old_field = old_fields.at(i); const auto& new_field = new_fields.at(i); compatible &= are_compatible_types(old_field->GetType(), new_field->GetType()); const string old_value = old_field->ValueString(AidlConstantValueDecorator); const string new_value = new_field->ValueString(AidlConstantValueDecorator); if (old_value == new_value) { continue; } // For enum type fields, we accept setting explicit default value which is "zero" auto enum_decl = new_types.GetEnumDeclaration(new_field->GetType()); if (old_value == "" && enum_decl && EvaluatesToZero(*enum_decl, new_field->GetDefaultValue())) { continue; } AIDL_ERROR(new_field) << "Changed default value: " << old_value << " to " << new_value << "."; compatible = false; } // Reordering of fields is an incompatible change. for (size_t i = 0; i < new_fields.size(); i++) { const auto& new_field = new_fields.at(i); auto found = std::find_if(old_fields.begin(), old_fields.end(), [&new_field](const auto& f) { return new_field->GetName() == f->GetName(); }); if (found != old_fields.end()) { size_t old_index = std::distance(old_fields.begin(), found); if (old_index != i) { AIDL_ERROR(new_field) << "Reordered " << new_field->GetName() << " from " << old_index << " to " << i << "."; compatible = false; } } } // New fields must have default values. if (older.AsUnionDeclaration() == nullptr) { for (size_t i = old_fields.size(); i < new_fields.size(); i++) { const auto& new_field = new_fields.at(i); if (new_field->HasUsefulDefaultValue()) { continue; } // enum can't be nullable, but it's okay if it has 0 as a valid enumerator. if (const auto& enum_decl = new_types.GetEnumDeclaration(new_field->GetType()); enum_decl != nullptr) { if (HasZeroEnumerator(*enum_decl)) { continue; } // TODO(b/142893595): Rephrase the message: "provide a default value or make sure ..." AIDL_ERROR(new_field) << "Field '" << new_field->GetName() << "' of enum '" << enum_decl->GetName() << "' can't be initialized as '0'. Please make sure '" << enum_decl->GetName() << "' has '0' as a valid value."; compatible = false; continue; } // Old API versions may suffer from the issue presented here. There is // only a finite number in Android, which we must allow indefinitely. struct HistoricalException { std::string canonical; std::string field; }; static std::vector exceptions = { {"android.net.DhcpResultsParcelable", "serverHostName"}, {"android.net.ResolverParamsParcel", "resolverOptions"}, }; bool excepted = false; for (const HistoricalException& exception : exceptions) { if (older.GetCanonicalName() == exception.canonical && new_field->GetName() == exception.field) { excepted = true; break; } } if (excepted) continue; AIDL_ERROR(new_field) << "Field '" << new_field->GetName() << "' does not have a useful default in some backends. Please either provide a default " "value for this field or mark the field as @nullable. This value or a null value will " "be used automatically when an old version of this parcelable is sent to a process " "which understands a new version of this parcelable. In order to make sure your code " "continues to be backwards compatible, make sure the default or null value does not " "cause a semantic change to this parcelable."; compatible = false; } } compatible = are_compatible_constants(older, newer) && compatible; return compatible; } static bool are_compatible_enums(const AidlEnumDeclaration& older, const AidlEnumDeclaration& newer) { std::map old_enum_map; for (const auto& enumerator : older.GetEnumerators()) { old_enum_map[enumerator->GetName()] = enumerator->GetValue(); } std::map new_enum_map; for (const auto& enumerator : newer.GetEnumerators()) { new_enum_map[enumerator->GetName()] = enumerator->GetValue(); } bool compatible = true; for (const auto& [name, value] : old_enum_map) { if (new_enum_map.find(name) == new_enum_map.end()) { AIDL_ERROR(newer) << "Removed enumerator from " << older.GetCanonicalName() << ": " << name; compatible = false; continue; } const string old_value = old_enum_map[name]->ValueString(older.GetBackingType(), AidlConstantValueDecorator); const string new_value = new_enum_map[name]->ValueString(newer.GetBackingType(), AidlConstantValueDecorator); if (old_value != new_value) { AIDL_ERROR(newer) << "Changed enumerator value: " << older.GetCanonicalName() << "::" << name << " from " << old_value << " to " << new_value << "."; compatible = false; } } return compatible; } Result LoadApiDump(const Options& options, const IoDelegate& io_delegate, const std::string& dir) { Result> dir_files = io_delegate.ListFiles(dir); if (!dir_files.ok()) { AIDL_ERROR(dir) << dir_files.error(); return Error(); } AidlTypenames typenames; for (const auto& file : *dir_files) { if (!android::base::EndsWith(file, ".aidl")) continue; // current "dir" is added to "imports" so that referenced.aidl files in the current // module are available when resolving references. if (internals::load_and_validate_aidl(file, options.PlusImportDir(dir), io_delegate, &typenames, nullptr /* imported_files */) != AidlError::OK) { AIDL_ERROR(file) << "Failed to read."; return Error(); } } return typenames; } bool check_api(const Options& options, const IoDelegate& io_delegate) { AIDL_FATAL_IF(!options.IsStructured(), AIDL_LOCATION_HERE); AIDL_FATAL_IF(options.InputFiles().size() != 2, AIDL_LOCATION_HERE) << "--checkapi requires two inputs " << "but got " << options.InputFiles().size(); auto old_tns = LoadApiDump(options, io_delegate, options.InputFiles().at(0)); if (!old_tns.ok()) { return false; } auto new_tns = LoadApiDump(options, io_delegate, options.InputFiles().at(1)); if (!new_tns.ok()) { return false; } const Options::CheckApiLevel level = options.GetCheckApiLevel(); // We don't check impoted types. auto get_types_in = [](const AidlTypenames& tns, const std::string& location) { std::vector types; for (const auto& type : tns.AllDefinedTypes()) { if (StartsWith(type->GetLocation().GetFile(), location)) { types.push_back(type); } } return types; }; std::vector old_types = get_types_in(*old_tns, options.InputFiles().at(0)); std::vector new_types = get_types_in(*new_tns, options.InputFiles().at(1)); bool compatible = true; if (level == Options::CheckApiLevel::EQUAL) { std::set old_type_names; for (const auto t : old_types) { old_type_names.insert(t->GetCanonicalName()); } for (const auto new_type : new_types) { const auto found = old_type_names.find(new_type->GetCanonicalName()); if (found == old_type_names.end()) { AIDL_ERROR(new_type) << "Added type: " << new_type->GetCanonicalName(); compatible = false; continue; } } } map new_map; for (const auto t : new_types) { new_map.emplace(t->GetCanonicalName(), t); } for (const auto old_type : old_types) { const auto found = new_map.find(old_type->GetCanonicalName()); if (found == new_map.end()) { AIDL_ERROR(old_type) << "Removed type: " << old_type->GetCanonicalName(); compatible = false; continue; } const auto new_type = found->second; if (level == Options::CheckApiLevel::EQUAL) { if (!CheckEquality(*old_type, *new_type)) { compatible = false; } continue; } if (!have_compatible_annotations(*old_type, *new_type)) { compatible = false; } if (old_type->AsInterface() != nullptr) { if (new_type->AsInterface() == nullptr) { AIDL_ERROR(new_type) << "Type mismatch: " << old_type->GetCanonicalName() << " is changed from " << old_type->GetPreprocessDeclarationName() << " to " << new_type->GetPreprocessDeclarationName(); compatible = false; continue; } compatible &= are_compatible_interfaces(*(old_type->AsInterface()), *(new_type->AsInterface())); } else if (old_type->AsStructuredParcelable() != nullptr) { if (new_type->AsStructuredParcelable() == nullptr) { AIDL_ERROR(new_type) << "Parcelable" << new_type->GetCanonicalName() << " is not structured. "; compatible = false; continue; } compatible &= are_compatible_parcelables(*(old_type->AsStructuredParcelable()), *old_tns, *(new_type->AsStructuredParcelable()), *new_tns); } else if (old_type->AsUnstructuredParcelable() != nullptr) { // We could compare annotations or cpp_header/ndk_header here, but all these changes // can be safe, and it's really up to the person making these changes to make sure // they are safe. This is originally added for Android Studio. In the platform build // system, this can never be reached because we build with '-b' // ignore, do nothing } else if (old_type->AsUnionDeclaration() != nullptr) { if (new_type->AsUnionDeclaration() == nullptr) { AIDL_ERROR(new_type) << "Type mismatch: " << old_type->GetCanonicalName() << " is changed from " << old_type->GetPreprocessDeclarationName() << " to " << new_type->GetPreprocessDeclarationName(); compatible = false; continue; } compatible &= are_compatible_parcelables(*(old_type->AsUnionDeclaration()), *old_tns, *(new_type->AsUnionDeclaration()), *new_tns); } else if (old_type->AsEnumDeclaration() != nullptr) { if (new_type->AsEnumDeclaration() == nullptr) { AIDL_ERROR(new_type) << "Type mismatch: " << old_type->GetCanonicalName() << " is changed from " << old_type->GetPreprocessDeclarationName() << " to " << new_type->GetPreprocessDeclarationName(); compatible = false; continue; } compatible &= are_compatible_enums(*(old_type->AsEnumDeclaration()), *(new_type->AsEnumDeclaration())); } else { AIDL_ERROR(old_type) << "Unsupported declaration type " << old_type->GetPreprocessDeclarationName() << " for " << old_type->GetCanonicalName() << " API dump comparison"; compatible = false; } } return compatible; } } // namespace aidl } // namespace android ./PaxHeaders.X/aidl_checkapi.h0100644 0000000 0000000 00000000034 15172120304 015205 xustar000000000 0000000 28 mtime=1776853188.2780000 aidl_checkapi.h0100644 0000000 0000000 00000002307 15172120304 012513 0ustar000000000 0000000 /* * Copyright (C) 2018, The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #pragma once #include "android-base/result.h" #include "io_delegate.h" #include "options.h" namespace android { namespace aidl { // Compare the two API dumps, which are given as input files, and test whether // the second API dump is backwards compatible with the first API dump. bool check_api(const Options& options, const IoDelegate& io_delegate); // load and validate an entire versioned aidl_api dump Result LoadApiDump(const Options& options, const IoDelegate& io_delegate, const std::string& dir); } // namespace aidl } // namespace android ./PaxHeaders.X/aidl_const_expressions.cpp0100644 0000000 0000000 00000000034 15172120304 017561 xustar000000000 0000000 28 mtime=1776853188.2780000 aidl_const_expressions.cpp0100644 0000000 0000000 00000116762 15172120304 015102 0ustar000000000 0000000 /* * Copyright (C) 2019, 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_language.h" #include "aidl_typenames.h" #include "logging.h" #include #include #include #include #include #include #include #include using android::base::ConsumeSuffix; using android::base::EndsWith; using android::base::Join; using android::base::Split; using android::base::StartsWith; using std::string; using std::unique_ptr; using std::vector; template constexpr int CLZ(T x) { // __builtin_clz(0) is undefined if (x == 0) return sizeof(T) * 8; return (sizeof(T) == sizeof(uint64_t)) ? __builtin_clzl(x) : __builtin_clz(x); } template class OverflowGuard { public: OverflowGuard(T value) : mValue(value) {} bool Overflowed() const { return mOverflowed; } T operator+() { return +mValue; } T operator-() { if (isMin()) { mOverflowed = true; return 0; } return -mValue; } T operator!() { return !mValue; } T operator~() { return ~mValue; } T operator+(T o) { T out; mOverflowed = __builtin_add_overflow(mValue, o, &out); return out; } T operator-(T o) { T out; mOverflowed = __builtin_sub_overflow(mValue, o, &out); return out; } T operator*(T o) { T out; #ifdef _WIN32 // ___mulodi4 not on windows https://bugs.llvm.org/show_bug.cgi?id=46669 // we should still get an error here from ubsan, but the nice error // is needed on linux for aidl_parser_fuzzer, where we are more // concerned about overflows elsewhere in the compiler in addition to // those in interfaces. out = mValue * o; #else mOverflowed = __builtin_mul_overflow(mValue, o, &out); #endif return out; } T operator/(T o) { if (o == 0 || (isMin() && o == -1)) { mOverflowed = true; return 0; } return static_cast(mValue / o); } T operator%(T o) { if (o == 0 || (isMin() && o == -1)) { mOverflowed = true; return 0; } return static_cast(mValue % o); } T operator|(T o) { return mValue | o; } T operator^(T o) { return mValue ^ o; } T operator&(T o) { return mValue & o; } T operator<(T o) { return mValue < o; } T operator>(T o) { return mValue > o; } T operator<=(T o) { return mValue <= o; } T operator>=(T o) { return mValue >= o; } T operator==(T o) { return mValue == o; } T operator!=(T o) { return mValue != o; } T operator>>(T o) { if (o < 0 || o >= static_cast(sizeof(T) * 8) || mValue < 0) { mOverflowed = true; return 0; } return static_cast(mValue >> o); } T operator<<(T o) { if (o < 0 || mValue < 0 || o > CLZ(mValue) || o >= static_cast(sizeof(T) * 8)) { mOverflowed = true; return 0; } return static_cast(mValue << o); } T operator||(T o) { return mValue || o; } T operator&&(T o) { return mValue && o; } private: bool isMin() { return mValue == std::numeric_limits::min(); } T mValue; bool mOverflowed = false; }; // some compilers don't provide __builtin_add_overflow for bool // see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=71479 template <> bool OverflowGuard::operator+(bool o) { if (mValue && o) { mOverflowed = true; return false; } return mValue || o; } template <> bool OverflowGuard::operator-(bool o) { if (!mValue && o) { mOverflowed = true; return true; } return mValue && !o; } template <> bool OverflowGuard::operator*(bool o) { return mValue && o; } template bool processGuard(const OverflowGuard& guard, const AidlConstantValue& context) { if (guard.Overflowed()) { AIDL_ERROR(context) << "Constant expression computation overflows."; return false; } return true; } // TODO: factor out all these macros #define SHOULD_NOT_REACH() AIDL_FATAL(AIDL_LOCATION_HERE) << "Should not reach." #define OPEQ(__y__) (string(op_) == string(__y__)) #define COMPUTE_UNARY(T, __op__) \ if (op == string(#__op__)) { \ OverflowGuard guard(val); \ *out = __op__ guard; \ return processGuard(guard, context); \ } #define COMPUTE_BINARY(T, __op__) \ if (op == string(#__op__)) { \ OverflowGuard guard(lval); \ *out = guard __op__ rval; \ return processGuard(guard, context); \ } #define OP_IS_BIN_ARITHMETIC (OPEQ("+") || OPEQ("-") || OPEQ("*") || OPEQ("/") || OPEQ("%")) #define OP_IS_BIN_BITFLIP (OPEQ("|") || OPEQ("^") || OPEQ("&")) #define OP_IS_BIN_COMP \ (OPEQ("<") || OPEQ(">") || OPEQ("<=") || OPEQ(">=") || OPEQ("==") || OPEQ("!=")) #define OP_IS_BIN_SHIFT (OPEQ(">>") || OPEQ("<<")) #define OP_IS_BIN_LOGICAL (OPEQ("||") || OPEQ("&&")) // NOLINT to suppress missing parentheses warnings about __def__. #define SWITCH_KIND(__cond__, __action__, __def__) \ switch (__cond__) { \ case Type::BOOLEAN: \ __action__(bool); \ case Type::INT8: \ __action__(int8_t); \ case Type::INT32: \ __action__(int32_t); \ case Type::INT64: \ __action__(int64_t); \ default: \ __def__; /* NOLINT */ \ } template bool handleUnary(const AidlConstantValue& context, const string& op, T val, int64_t* out) { COMPUTE_UNARY(T, +) COMPUTE_UNARY(T, -) COMPUTE_UNARY(T, !) COMPUTE_UNARY(T, ~) AIDL_FATAL(context) << "Could not handleUnary for " << op << " " << val; return false; } template <> bool handleUnary(const AidlConstantValue& context, const string& op, bool val, int64_t* out) { COMPUTE_UNARY(bool, +) COMPUTE_UNARY(bool, -) COMPUTE_UNARY(bool, !) if (op == "~") { AIDL_ERROR(context) << "Bitwise negation of a boolean expression is always true."; return false; } AIDL_FATAL(context) << "Could not handleUnary for " << op << " " << val; return false; } template bool handleBinaryCommon(const AidlConstantValue& context, T lval, const string& op, T rval, int64_t* out) { COMPUTE_BINARY(T, +) COMPUTE_BINARY(T, -) COMPUTE_BINARY(T, *) COMPUTE_BINARY(T, /) COMPUTE_BINARY(T, %) COMPUTE_BINARY(T, |) COMPUTE_BINARY(T, ^) COMPUTE_BINARY(T, &) // comparison operators: return 0 or 1 by nature. COMPUTE_BINARY(T, ==) COMPUTE_BINARY(T, !=) COMPUTE_BINARY(T, <) COMPUTE_BINARY(T, >) COMPUTE_BINARY(T, <=) COMPUTE_BINARY(T, >=) AIDL_FATAL(context) << "Could not handleBinaryCommon for " << lval << " " << op << " " << rval; return false; } template bool handleShift(const AidlConstantValue& context, T lval, const string& op, T rval, int64_t* out) { // just cast rval to int64_t and it should fit. COMPUTE_BINARY(T, >>) COMPUTE_BINARY(T, <<) AIDL_FATAL(context) << "Could not handleShift for " << lval << " " << op << " " << rval; return false; } bool handleLogical(const AidlConstantValue& context, bool lval, const string& op, bool rval, int64_t* out) { COMPUTE_BINARY(bool, ||); COMPUTE_BINARY(bool, &&); AIDL_FATAL(context) << "Could not handleLogical for " << lval << " " << op << " " << rval; return false; } static bool isValidLiteralChar(char c) { return !(c <= 0x1f || // control characters are < 0x20 c >= 0x7f || // DEL is 0x7f c == '\\'); // Disallow backslashes for future proofing. } static std::string PrintCharLiteral(char c) { std::ostringstream os; switch (c) { case '\0': os << "\\0"; break; case '\'': os << "\\'"; break; case '\\': os << "\\\\"; break; case '\a': os << "\\a"; break; case '\b': os << "\\b"; break; case '\f': os << "\\f"; break; case '\n': os << "\\n"; break; case '\r': os << "\\r"; break; case '\t': os << "\\t"; break; case '\v': os << "\\v"; break; default: if (std::isprint(static_cast(c))) { os << c; } else { os << "\\x" << std::hex << std::uppercase << static_cast(c); } } return os.str(); } bool ParseFloating(std::string_view sv, double* parsed) { // float literal should be parsed successfully. android::base::ConsumeSuffix(&sv, "f"); return android::base::ParseDouble(std::string(sv).data(), parsed); } bool ParseFloating(std::string_view sv, float* parsed) { // we only care about float literal (with suffix "f"). if (!android::base::ConsumeSuffix(&sv, "f")) { return false; } return android::base::ParseFloat(std::string(sv).data(), parsed); } bool AidlUnaryConstExpression::IsCompatibleType(Type type, const string& op) { // Verify the unary type here switch (type) { case Type::BOOLEAN: // fall-through case Type::INT8: // fall-through case Type::INT32: // fall-through case Type::INT64: return true; case Type::FLOATING: return (op == "+" || op == "-"); default: return false; } } bool AidlBinaryConstExpression::AreCompatibleOperandTypes(Type t1, Type t2) { switch (t1) { case Type::ARRAY: if (t2 == Type::ARRAY) { return true; } break; case Type::STRING: if (t2 == Type::STRING) { return true; } break; case Type::FLOATING: // TODO: b/313951203, check op for supported floating operands (+ - * / < > <= >= == !=) return false; case Type::BOOLEAN: // fall-through case Type::INT8: // fall-through case Type::INT32: // fall-through case Type::INT64: switch (t2) { case Type::BOOLEAN: // fall-through case Type::INT8: // fall-through case Type::INT32: // fall-through case Type::INT64: return true; break; default: break; } break; default: break; } return false; } bool AidlBinaryConstExpression::AreCompatibleArrayTypes(Type t1, Type t2) { // treat floating type differently here, because float array is supported but not operand if (t1 == Type::FLOATING && t2 == Type::FLOATING) return true; return AreCompatibleOperandTypes(t1, t2); } // Returns the promoted kind for both operands AidlConstantValue::Type AidlBinaryConstExpression::UsualArithmeticConversion(Type left, Type right) { // These are handled as special cases // TODO: b/313951203, remove this after support string and floating operands AIDL_FATAL_IF(left == Type::STRING || right == Type::STRING, AIDL_LOCATION_HERE); AIDL_FATAL_IF(left == Type::FLOATING || right == Type::FLOATING, AIDL_LOCATION_HERE); // Kinds in concern: bool, (u)int[8|32|64] if (left == right) return left; // easy case if (left == Type::BOOLEAN) return right; if (right == Type::BOOLEAN) return left; return left < right ? right : left; } // Returns the promoted integral type where INT32 is the smallest type AidlConstantValue::Type AidlBinaryConstExpression::IntegralPromotion(Type in) { return (Type::INT32 < in) ? in : Type::INT32; } AidlConstantValue* AidlConstantValue::Default(const AidlTypeSpecifier& specifier) { AidlLocation location = specifier.GetLocation(); // allocation of int[0] is a bit wasteful in Java if (specifier.IsArray()) { return nullptr; } const std::string name = specifier.GetName(); if (name == "boolean") { return Boolean(location, false); } if (name == "char") { return Character(location, "'\\0'"); // literal to be used in backends } if (name == "byte" || name == "int" || name == "long") { return Integral(location, "0"); } if (name == "float") { return Floating(location, "0.0f"); } if (name == "double") { return Floating(location, "0.0"); } return nullptr; } AidlConstantValue* AidlConstantValue::Boolean(const AidlLocation& location, bool value) { return new AidlConstantValue(location, Type::BOOLEAN, value ? "true" : "false"); } AidlConstantValue* AidlConstantValue::Character(const AidlLocation& location, const std::string& value) { static const char* kZeroString = "'\\0'"; // We should have better supports for escapes in the future, but for now // allow only what is needed for defaults. if (value != kZeroString) { AIDL_FATAL_IF(value.size() != 3 || value[0] != '\'' || value[2] != '\'', location) << value; if (!isValidLiteralChar(value[1])) { AIDL_ERROR(location) << "Invalid character literal " << PrintCharLiteral(value[1]); return new AidlConstantValue(location, Type::ERROR, value); } } return new AidlConstantValue(location, Type::CHARACTER, value); } AidlConstantValue* AidlConstantValue::Floating(const AidlLocation& location, const std::string& value) { return new AidlConstantValue(location, Type::FLOATING, value); } bool AidlConstantValue::IsHex(const string& value) { return StartsWith(value, "0x") || StartsWith(value, "0X"); } bool AidlConstantValue::ParseIntegral(const string& value, int64_t* parsed_value, Type* parsed_type) { if (parsed_value == nullptr || parsed_type == nullptr) { return false; } std::string_view value_view = value; const bool is_byte = ConsumeSuffix(&value_view, "u8"); const bool is_unsigned_int = ConsumeSuffix(&value_view, "u32"); const bool is_long = ConsumeSuffix(&value_view, "l") || ConsumeSuffix(&value_view, "L"); const bool is_unsigned_long = ConsumeSuffix(&value_view, "u64"); if (is_byte + is_long + is_unsigned_int + is_unsigned_long > 1) return false; const std::string value_substr = ({ std::string raw_value_substr = std::string(value_view); // remove "_" in integral constant const std::vector value_pieces = Split(raw_value_substr, "_"); if (std::any_of(value_pieces.begin(), value_pieces.end(), [](const auto& s) { return s.empty(); })) { return false; } Join(value_pieces, ""); }); *parsed_value = 0; *parsed_type = Type::ERROR; if (IsHex(value)) { // AIDL considers 'const int foo = 0xffffffff' as -1, but if we want to // handle that when computing constant expressions, then we need to // represent 0xffffffff as a uint32_t. However, AIDL only has signed types; // so we parse as an unsigned int when possible and then cast to a signed // int. One example of this is in ICameraService.aidl where a constant int // is used for bit manipulations which ideally should be handled with an // unsigned int. // // Note, for historical consistency, we need to consider small hex values // as an integral type. Recognizing them as INT8 could break some files, // even though it would simplify this code. if (is_byte) { uint8_t raw_value8; if (!android::base::ParseUint(value_substr, &raw_value8)) { return false; } *parsed_value = static_cast(raw_value8); *parsed_type = Type::INT8; } else if (uint32_t raw_value32; (!is_long || is_unsigned_int) && android::base::ParseUint(value_substr, &raw_value32)) { *parsed_value = static_cast(raw_value32); *parsed_type = Type::INT32; } else if (uint64_t raw_value64; android::base::ParseUint(value_substr, &raw_value64)) { *parsed_value = static_cast(raw_value64); *parsed_type = Type::INT64; } else { return false; } return true; } if (is_unsigned_long) { if (uint64_t raw_value64; android::base::ParseUint(value_substr, &raw_value64)) { *parsed_value = static_cast(raw_value64); *parsed_type = Type::INT64; return true; } else { return false; } } if (!android::base::ParseInt(value_substr, parsed_value)) { return false; } if (is_byte) { if (*parsed_value > UINT8_MAX || *parsed_value < 0) { return false; } *parsed_value = static_cast(*parsed_value); *parsed_type = Type::INT8; } else if (is_unsigned_int) { if (*parsed_value > UINT32_MAX || *parsed_value < 0) { return false; } *parsed_value = static_cast(*parsed_value); *parsed_type = Type::INT32; } else if (is_long) { *parsed_type = Type::INT64; } else { // guess literal type. if (*parsed_value <= INT8_MAX && *parsed_value >= INT8_MIN) { *parsed_type = Type::INT8; } else if (*parsed_value <= INT32_MAX && *parsed_value >= INT32_MIN) { *parsed_type = Type::INT32; } else { *parsed_type = Type::INT64; } } return true; } AidlConstantValue* AidlConstantValue::Integral(const AidlLocation& location, const string& value) { AIDL_FATAL_IF(value.empty(), location); Type parsed_type; int64_t parsed_value = 0; bool success = ParseIntegral(value, &parsed_value, &parsed_type); if (!success) { return nullptr; } return new AidlConstantValue(location, parsed_type, parsed_value, value); } AidlConstantValue* AidlConstantValue::Array( const AidlLocation& location, std::unique_ptr>> values) { AIDL_FATAL_IF(values == nullptr, location); // Reconstruct literal value std::vector str_values; for (const auto& v : *values) { str_values.push_back(v->value_); } return new AidlConstantValue(location, Type::ARRAY, std::move(values), "{" + Join(str_values, ", ") + "}"); } AidlConstantValue* AidlConstantValue::String(const AidlLocation& location, const string& value) { AIDL_FATAL_IF(value.size() == 0, "If this is unquoted, we need to update the index log"); AIDL_FATAL_IF(value[0] != '\"', "If this is unquoted, we need to update the index log"); for (size_t i = 0; i < value.length(); ++i) { if (!isValidLiteralChar(value[i])) { AIDL_ERROR(location) << "Found invalid character '" << value[i] << "' at index " << i - 1 << " in string constant '" << value << "'"; return new AidlConstantValue(location, Type::ERROR, value); } } return new AidlConstantValue(location, Type::STRING, value); } string AidlConstantValue::ValueString(const AidlTypeSpecifier& type, const ConstantValueDecorator& decorator) const { if (type.IsGeneric()) { AIDL_ERROR(type) << "Generic type cannot be specified with a constant literal."; return ""; } if (!is_evaluated_) { // TODO(b/142722772) CheckValid() should be called before ValueString() bool success = CheckValid(); success &= evaluate(); if (!success) { // the detailed error message shall be printed in evaluate return ""; } } if (!is_valid_) { AIDL_ERROR(this) << "Invalid constant value: " + value_; return ""; } std::vector alternatives; const AidlDefinedType* defined_type = type.GetDefinedType(); if (defined_type && final_type_ != Type::ARRAY) { const AidlEnumDeclaration* enum_type = defined_type->AsEnumDeclaration(); if (!enum_type) { AIDL_ERROR(this) << "Invalid type (" << defined_type->GetCanonicalName() << ") for a const value (" << value_ << ")"; return ""; } if (type_ != Type::REF) { AIDL_ERROR(this) << "Invalid value (" << value_ << ") for enum " << enum_type->GetCanonicalName(); return ""; } return decorator(type, value_); } const string& type_string = type.Signature(); int err = 0; switch (final_type_) { case Type::CHARACTER: if (type_string == "char") { return decorator(type, final_string_value_); } err = -1; break; case Type::STRING: if (type_string == "String") { return decorator(type, final_string_value_); } err = -1; break; case Type::BOOLEAN: // fall-through case Type::INT8: // fall-through case Type::INT32: // fall-through case Type::INT64: if (type_string == "byte") { if (final_value_ > INT8_MAX || final_value_ < INT8_MIN) { err = -1; if (final_value_ >= 0 && final_value_ <= UINT8_MAX && IsLiteral()) { alternatives.push_back(value_ + "u8"); } break; } return decorator(type, std::to_string(static_cast(final_value_))); } else if (type_string == "int") { if (final_value_ > INT32_MAX || final_value_ < INT32_MIN) { err = -1; if (final_value_ >= 0 && final_value_ <= UINT32_MAX && IsLiteral()) { alternatives.push_back(value_ + "u32"); } break; } return decorator(type, std::to_string(static_cast(final_value_))); } else if (type_string == "long") { return decorator(type, std::to_string(final_value_)); } else if (type_string == "boolean") { return decorator(type, final_value_ ? "true" : "false"); } err = -1; break; case Type::ARRAY: { if (!type.IsArray()) { err = -1; break; } vector value_strings; value_strings.reserve(values_.size()); bool success = true; for (const auto& value : values_) { string value_string; type.ViewAsArrayBase([&](const auto& base_type) { value_string = value->ValueString(base_type, decorator); }); if (value_string.empty()) { success = false; break; } value_strings.push_back(value_string); } if (!success) { err = -1; break; } if (type.IsFixedSizeArray()) { auto size = std::get(type.GetArray()).dimensions.front()->EvaluatedValue(); if (values_.size() != static_cast(size)) { AIDL_ERROR(this) << "Expected an array of " << size << " elements, but found one with " << values_.size() << " elements"; err = -1; break; } } return decorator(type, value_strings); } case Type::FLOATING: { if (type_string == "double") { double parsed_value; if (!ParseFloating(value_, &parsed_value)) { AIDL_ERROR(this) << "Could not parse " << value_; err = -1; break; } return decorator(type, std::to_string(parsed_value)); } if (type_string == "float") { float parsed_value; if (!ParseFloating(value_, &parsed_value)) { AIDL_ERROR(this) << "Could not parse " << value_; err = -1; break; } return decorator(type, std::to_string(parsed_value) + "f"); } err = -1; break; } default: err = -1; break; } std::string alternative_help; if (!alternatives.empty()) { alternative_help = " Did you mean: " + Join(alternatives, ", ") + "?"; } AIDL_FATAL_IF(err == 0, this); AIDL_ERROR(this) << "Invalid type specifier for " << ToString(final_type_) << ": " << type_string << " (" << value_ << ")." << alternative_help; return ""; } bool AidlConstantValue::CheckValid() const { // Nothing needs to be checked here. The constant value will be validated in // the constructor or in the evaluate() function. if (is_evaluated_) return is_valid_; switch (type_) { case Type::BOOLEAN: // fall-through case Type::INT8: // fall-through case Type::INT32: // fall-through case Type::INT64: // fall-through case Type::CHARACTER: // fall-through case Type::STRING: // fall-through case Type::REF: // fall-through case Type::FLOATING: // fall-through case Type::UNARY: // fall-through case Type::BINARY: is_valid_ = true; break; case Type::ARRAY: is_valid_ = true; for (const auto& v : values_) is_valid_ &= v->CheckValid(); break; case Type::ERROR: return false; default: AIDL_FATAL(this) << "Unrecognized constant value type: " << ToString(type_); return false; } return true; } bool AidlConstantValue::Evaluate() const { if (CheckValid()) { return evaluate(); } else { return false; } } bool AidlConstantValue::evaluate() const { if (is_evaluated_) { return is_valid_; } int err = 0; is_evaluated_ = true; switch (type_) { case Type::ARRAY: { Type array_type = Type::ERROR; bool success = true; for (const auto& value : values_) { success = value->CheckValid(); if (success) { success = value->evaluate(); if (!success) { AIDL_ERROR(this) << "Invalid array element: " << value->value_; break; } if (array_type == Type::ERROR) { array_type = value->final_type_; } else if (!AidlBinaryConstExpression::AreCompatibleArrayTypes(array_type, value->final_type_)) { AIDL_ERROR(this) << "Incompatible array element type: " << ToString(value->final_type_) << ". Expecting type compatible with " << ToString(array_type); success = false; break; } } else { break; } } if (!success) { err = -1; break; } final_type_ = type_; break; } case Type::BOOLEAN: if ((value_ != "true") && (value_ != "false")) { AIDL_ERROR(this) << "Invalid constant boolean value: " << value_; err = -1; break; } final_value_ = (value_ == "true") ? 1 : 0; final_type_ = type_; break; case Type::INT8: // fall-through case Type::INT32: // fall-through case Type::INT64: // Parsing happens in the constructor final_type_ = type_; break; case Type::CHARACTER: // fall-through case Type::STRING: final_string_value_ = value_; final_type_ = type_; break; case Type::FLOATING: // Just parse on the fly in ValueString final_type_ = type_; break; default: AIDL_FATAL(this) << "Unrecognized constant value type: " << ToString(type_); err = -1; } return (err == 0) ? true : false; } bool AidlConstantValue::IsLiteral() const { return !AidlCast(*this) && !AidlCast(*this) && !AidlCast(*this); } string AidlConstantValue::ToString(Type type) { switch (type) { case Type::BOOLEAN: return "a literal boolean"; case Type::INT8: return "an int8 literal"; case Type::INT32: return "an int32 literal"; case Type::INT64: return "an int64 literal"; case Type::ARRAY: return "a literal array"; case Type::CHARACTER: return "a literal char"; case Type::STRING: return "a literal string"; case Type::REF: return "a reference"; case Type::FLOATING: return "a literal float"; case Type::UNARY: return "a unary expression"; case Type::BINARY: return "a binary expression"; case Type::ERROR: AIDL_FATAL(AIDL_LOCATION_HERE) << "aidl internal error: error type failed to halt program"; return ""; default: AIDL_FATAL(AIDL_LOCATION_HERE) << "aidl internal error: unknown constant type: " << static_cast(type); return ""; // not reached } } AidlConstantReference::AidlConstantReference(const AidlLocation& location, const std::string& value) : AidlConstantValue(location, Type::REF, value) { const auto pos = value.find_last_of('.'); if (pos == string::npos) { field_name_ = value; } else { ref_type_ = std::make_unique(location, value.substr(0, pos), /*array=*/std::nullopt, /*type_params=*/nullptr, Comments{}); field_name_ = value.substr(pos + 1); } } const AidlConstantValue* AidlConstantReference::Resolve(const AidlDefinedType* scope) const { if (resolved_) return resolved_; const AidlDefinedType* defined_type; if (ref_type_) { defined_type = ref_type_->GetDefinedType(); } else { defined_type = scope; } if (!defined_type) { // This can happen when "const reference" is used in an unsupported way, // but missed in checks there. It works as a safety net. AIDL_ERROR(*this) << "Can't resolve the reference (" << value_ << ")"; return nullptr; } if (auto enum_decl = defined_type->AsEnumDeclaration(); enum_decl) { for (const auto& e : enum_decl->GetEnumerators()) { if (e->GetName() == field_name_) { return resolved_ = e->GetValue(); } } } else { for (const auto& c : defined_type->GetConstantDeclarations()) { if (c->GetName() == field_name_) { return resolved_ = &c->GetValue(); } } } AIDL_ERROR(*this) << "Can't find " << field_name_ << " in " << defined_type->GetName(); return nullptr; } bool AidlConstantReference::CheckValid() const { if (is_evaluated_) return is_valid_; AIDL_FATAL_IF(!resolved_, this) << "Should be resolved first: " << value_; is_valid_ = resolved_->CheckValid(); return is_valid_; } bool AidlConstantReference::evaluate() const { if (is_evaluated_) return is_valid_; AIDL_FATAL_IF(!resolved_, this) << "Should be resolved first: " << value_; is_evaluated_ = true; resolved_->evaluate(); is_valid_ = resolved_->is_valid_; final_type_ = resolved_->final_type_; if (is_valid_) { if (final_type_ == Type::STRING) { final_string_value_ = resolved_->final_string_value_; } else { final_value_ = resolved_->final_value_; } } return is_valid_; } bool AidlUnaryConstExpression::CheckValid() const { if (is_evaluated_) return is_valid_; AIDL_FATAL_IF(unary_ == nullptr, this); is_valid_ = unary_->CheckValid(); if (!is_valid_) { final_type_ = Type::ERROR; return false; } return AidlConstantValue::CheckValid(); } bool AidlUnaryConstExpression::evaluate() const { if (is_evaluated_) { return is_valid_; } is_evaluated_ = true; // Recursively evaluate the expression tree if (!unary_->is_evaluated_) { // TODO(b/142722772) CheckValid() should be called before ValueString() bool success = CheckValid(); success &= unary_->evaluate(); if (!success) { is_valid_ = false; return false; } } if (!IsCompatibleType(unary_->final_type_, op_)) { AIDL_ERROR(unary_) << "'" << op_ << "'" << " is not compatible with " << ToString(unary_->final_type_) << ": " + value_; is_valid_ = false; return false; } if (!unary_->is_valid_) { AIDL_ERROR(unary_) << "Invalid constant unary expression: " + value_; is_valid_ = false; return false; } final_type_ = unary_->final_type_; if (final_type_ == Type::FLOATING) { // don't do anything here. ValueString() will handle everything. is_valid_ = true; return true; } #define CASE_UNARY(__type__) \ return is_valid_ = \ handleUnary(*this, op_, static_cast<__type__>(unary_->final_value_), &final_value_); SWITCH_KIND(final_type_, CASE_UNARY, SHOULD_NOT_REACH(); final_type_ = Type::ERROR; is_valid_ = false; return false;) } bool AidlBinaryConstExpression::CheckValid() const { bool success = false; if (is_evaluated_) return is_valid_; AIDL_FATAL_IF(left_val_ == nullptr, this); AIDL_FATAL_IF(right_val_ == nullptr, this); success = left_val_->CheckValid(); if (!success) { final_type_ = Type::ERROR; AIDL_ERROR(this) << "Invalid left operand in binary expression: " + value_; } success = right_val_->CheckValid(); if (!success) { AIDL_ERROR(this) << "Invalid right operand in binary expression: " + value_; final_type_ = Type::ERROR; } if (final_type_ == Type::ERROR) { is_valid_ = false; return false; } is_valid_ = true; return AidlConstantValue::CheckValid(); } bool AidlBinaryConstExpression::evaluate() const { if (is_evaluated_) { return is_valid_; } is_evaluated_ = true; AIDL_FATAL_IF(left_val_ == nullptr, this); AIDL_FATAL_IF(right_val_ == nullptr, this); // Recursively evaluate the binary expression tree if (!left_val_->is_evaluated_ || !right_val_->is_evaluated_) { // TODO(b/142722772) CheckValid() should be called before ValueString() bool success = CheckValid(); success &= left_val_->evaluate(); success &= right_val_->evaluate(); if (!success) { is_valid_ = false; return false; } } if (!left_val_->is_valid_ || !right_val_->is_valid_) { is_valid_ = false; return false; } is_valid_ = AreCompatibleOperandTypes(left_val_->final_type_, right_val_->final_type_); if (!is_valid_) { AIDL_ERROR(this) << "Cannot perform operation '" << op_ << "' on " << ToString(right_val_->GetType()) << " and " << ToString(left_val_->GetType()) << "."; return false; } bool isArithmeticOrBitflip = OP_IS_BIN_ARITHMETIC || OP_IS_BIN_BITFLIP; // Handle String case first if (left_val_->final_type_ == Type::STRING) { AIDL_FATAL_IF(right_val_->final_type_ != Type::STRING, this); if (!OPEQ("+")) { AIDL_ERROR(this) << "Only '+' is supported for strings, not '" << op_ << "'."; final_type_ = Type::ERROR; is_valid_ = false; return false; } // Remove trailing " from lhs const string& lhs = left_val_->final_string_value_; if (lhs.back() != '"') { AIDL_ERROR(this) << "'" << lhs << "' is missing a trailing quote."; final_type_ = Type::ERROR; is_valid_ = false; return false; } const string& rhs = right_val_->final_string_value_; // Remove starting " from rhs if (rhs.front() != '"') { AIDL_ERROR(this) << "'" << rhs << "' is missing a leading quote."; final_type_ = Type::ERROR; is_valid_ = false; return false; } final_string_value_ = string(lhs.begin(), lhs.end() - 1).append(rhs.begin() + 1, rhs.end()); final_type_ = Type::STRING; return true; } // CASE: + - * / % | ^ & < > <= >= == != if (isArithmeticOrBitflip || OP_IS_BIN_COMP) { // promoted kind for both operands. Type promoted = UsualArithmeticConversion(IntegralPromotion(left_val_->final_type_), IntegralPromotion(right_val_->final_type_)); // result kind. final_type_ = isArithmeticOrBitflip ? promoted // arithmetic or bitflip operators generates promoted type : Type::BOOLEAN; // comparison operators generates bool #define CASE_BINARY_COMMON(__type__) \ return is_valid_ = \ handleBinaryCommon(*this, static_cast<__type__>(left_val_->final_value_), op_, \ static_cast<__type__>(right_val_->final_value_), &final_value_); SWITCH_KIND(promoted, CASE_BINARY_COMMON, SHOULD_NOT_REACH(); final_type_ = Type::ERROR; is_valid_ = false; return false;) } // CASE: << >> string newOp = op_; if (OP_IS_BIN_SHIFT) { // promoted kind for both operands. final_type_ = UsualArithmeticConversion(IntegralPromotion(left_val_->final_type_), IntegralPromotion(right_val_->final_type_)); auto numBits = right_val_->final_value_; if (numBits < 0) { // shifting with negative number of bits is undefined in C. In AIDL it // is defined as shifting into the other direction. newOp = OPEQ("<<") ? ">>" : "<<"; numBits = -numBits; } #define CASE_SHIFT(__type__) \ return is_valid_ = handleShift(*this, static_cast<__type__>(left_val_->final_value_), newOp, \ static_cast<__type__>(numBits), &final_value_); SWITCH_KIND(final_type_, CASE_SHIFT, SHOULD_NOT_REACH(); final_type_ = Type::ERROR; is_valid_ = false; return false;) } // CASE: && || if (OP_IS_BIN_LOGICAL) { final_type_ = Type::BOOLEAN; // easy; everything is bool. return handleLogical(*this, left_val_->final_value_, op_, right_val_->final_value_, &final_value_); } SHOULD_NOT_REACH(); is_valid_ = false; return false; } // Constructor for integer(byte, int, long) // Keep parsed integer & literal AidlConstantValue::AidlConstantValue(const AidlLocation& location, Type parsed_type, int64_t parsed_value, const string& checked_value) : AidlNode(location), type_(parsed_type), value_(checked_value), final_type_(parsed_type), final_value_(parsed_value) { AIDL_FATAL_IF(value_.empty() && type_ != Type::ERROR, location); AIDL_FATAL_IF(type_ != Type::INT8 && type_ != Type::INT32 && type_ != Type::INT64, location); } // Constructor for non-integer(String, char, boolean, float, double) // Keep literal as it is. (e.g. String literal has double quotes at both ends) AidlConstantValue::AidlConstantValue(const AidlLocation& location, Type type, const string& checked_value) : AidlNode(location), type_(type), value_(checked_value), final_type_(type) { AIDL_FATAL_IF(value_.empty() && type_ != Type::ERROR, location); switch (type_) { case Type::INT8: case Type::INT32: case Type::INT64: case Type::ARRAY: AIDL_FATAL(this) << "Invalid type: " << ToString(type_); break; default: break; } } // Constructor for array AidlConstantValue::AidlConstantValue(const AidlLocation& location, Type type, std::unique_ptr>> values, const std::string& value) : AidlNode(location), type_(type), values_(std::move(*values)), value_(value), is_valid_(false), is_evaluated_(false), final_type_(type) { AIDL_FATAL_IF(type_ != Type::ARRAY, location); } AidlUnaryConstExpression::AidlUnaryConstExpression(const AidlLocation& location, const string& op, std::unique_ptr rval) : AidlConstantValue(location, Type::UNARY, op + rval->value_), unary_(std::move(rval)), op_(op) { final_type_ = Type::UNARY; } AidlBinaryConstExpression::AidlBinaryConstExpression(const AidlLocation& location, std::unique_ptr lval, const string& op, std::unique_ptr rval) : AidlConstantValue(location, Type::BINARY, lval->value_ + op + rval->value_), left_val_(std::move(lval)), right_val_(std::move(rval)), op_(op) { final_type_ = Type::BINARY; } ./PaxHeaders.X/aidl_dumpapi.cpp0100644 0000000 0000000 00000000034 15172120304 015430 xustar000000000 0000000 28 mtime=1776853188.2800000 aidl_dumpapi.cpp0100644 0000000 0000000 00000020351 15172120304 012735 0ustar000000000 0000000 /* * Copyright (C) 2021, 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_dumpapi.h" #include #include "aidl.h" #include "logging.h" #include "os.h" using android::base::EndsWith; using android::base::Join; using android::base::Split; using std::string; using std::unique_ptr; namespace android { namespace aidl { static bool NeedsFinalValue(const AidlTypeSpecifier& type, const AidlConstantValue& c) { // For enum types, use enumerator if (auto defined_type = type.GetDefinedType(); defined_type && defined_type->AsEnumDeclaration()) { return false; } // We need final value for constant expression which is not a single constant expression. struct Visitor : AidlVisitor { bool trivial = true; void Visit(const AidlConstantReference&) override { trivial = false; } void Visit(const AidlUnaryConstExpression&) override { trivial = false; } void Visit(const AidlBinaryConstExpression&) override { trivial = false; } } v; c.DispatchVisit(v); return !v.trivial; } void DumpVisitor::DumpType(const AidlDefinedType& dt, const string& type) { if (!dt.IsUserDefined()) { return; } DumpComments(dt); DumpAnnotations(dt); out << type << " " << dt.GetName(); if (auto generic_type = dt.AsParameterizable(); generic_type && generic_type->IsGeneric()) { out << "<" << Join(generic_type->GetTypeParameters(), ", ") << ">"; } if (dt.AsUnstructuredParcelable()) { out << ";\n"; return; } out << " {\n"; out.Indent(); DumpMembers(dt); out.Dedent(); out << "}\n"; } void DumpVisitor::DumpMembers(const AidlDefinedType& dt) { for (const auto& method : dt.GetMethods()) { method->DispatchVisit(*this); } for (const auto& field : dt.GetFields()) { field->DispatchVisit(*this); } for (const auto& constdecl : dt.GetConstantDeclarations()) { constdecl->DispatchVisit(*this); } for (const auto& nested : dt.GetNestedTypes()) { nested->DispatchVisit(*this); } } // Dumps comment only if its has meaningful tags. void DumpVisitor::DumpComments(const AidlCommentable& c) { const auto hidden = c.IsHidden(); const auto deprecated = FindDeprecated(c.GetComments()); if (hidden && !deprecated) { // to pass --checkapi between the current and the tot in the mainline-prod branch // emit @hide in a legacy dump style out << "/* @hide */\n"; } else if (hidden || deprecated) { out << "/**\n"; if (hidden) { out << " * @hide\n"; } if (deprecated) { out << " * @deprecated " << deprecated->note << "\n"; } out << " */\n"; } } void DumpVisitor::DumpAnnotations(const AidlAnnotatable& a) { auto annotations = a.ToString(); if (!annotations.empty()) { out << annotations << "\n"; } } void DumpVisitor::DumpConstantValue(const AidlTypeSpecifier& type, const AidlConstantValue& c) { if (inline_constants) { out << c.ValueString(type, AidlConstantValueDecorator); return; } if (c.GetType() == AidlConstantValue::Type::ARRAY) { type.ViewAsArrayBase([&](const auto& base_type) { out << "{"; for (size_t i = 0; i < c.Size(); i++) { if (i > 0) { out << ", "; } DumpConstantValue(base_type, c.ValueAt(i)); } out << "}"; }); } else { c.DispatchVisit(*this); // print final value as comment if (NeedsFinalValue(type, c)) { out << " /* " << c.ValueString(type, AidlConstantValueDecorator) << " */"; } } } void DumpVisitor::Visit(const AidlInterface& t) { DumpType(t, "interface"); } void DumpVisitor::Visit(const AidlParcelable& t) { DumpType(t, "parcelable"); } void DumpVisitor::Visit(const AidlStructuredParcelable& t) { DumpType(t, "parcelable"); } void DumpVisitor::Visit(const AidlUnionDecl& t) { DumpType(t, "union"); } void DumpVisitor::Visit(const AidlEnumDeclaration& t) { if (!t.IsUserDefined()) { return; } DumpComments(t); DumpAnnotations(t); out << "enum " << t.GetName() << " {\n"; out.Indent(); for (const auto& e : t.GetEnumerators()) { DumpComments(*e); out << e->GetName(); if (e->IsValueUserSpecified() || inline_constants) { out << " = "; DumpConstantValue(t.GetBackingType(), *e->GetValue()); } out << ",\n"; } out.Dedent(); out << "}\n"; } void DumpVisitor::Visit(const AidlMethod& m) { if (!m.IsUserDefined()) { return; } DumpComments(m); out << m.ToString() << ";\n"; } void DumpVisitor::Visit(const AidlVariableDeclaration& v) { if (!v.IsUserDefined()) { return; } DumpComments(v); Visit(v.GetType()); if (v.IsDefaultUserSpecified()) { out << " " << v.GetName() << " = "; DumpConstantValue(v.GetType(), *v.GetDefaultValue()); out << ";\n"; } else { out << " " << v.GetName() << ";\n"; } } void DumpVisitor::Visit(const AidlConstantDeclaration& c) { if (!c.IsUserDefined()) { return; } DumpComments(c); out << "const "; Visit(c.GetType()); out << " " << c.GetName() << " = "; DumpConstantValue(c.GetType(), c.GetValue()); out << ";\n"; } void DumpVisitor::Visit(const AidlTypeSpecifier& t) { out << t.ToString(); } // These Visit() methods are not invoked when inline_constants = true void DumpVisitor::Visit(const AidlConstantValue& c) { AIDL_FATAL_IF(inline_constants, AIDL_LOCATION_HERE); out << c.Literal(); } void DumpVisitor::Visit(const AidlConstantReference& r) { AIDL_FATAL_IF(inline_constants, AIDL_LOCATION_HERE); if (auto& ref = r.GetRefType(); ref) { ref->DispatchVisit(*this); out << "."; } out << r.GetFieldName(); } void DumpVisitor::Visit(const AidlBinaryConstExpression& b) { AIDL_FATAL_IF(inline_constants, AIDL_LOCATION_HERE); // TODO(b/262594867) put parentheses only when necessary out << "("; b.Left()->DispatchVisit(*this); out << " " << b.Op() << " "; b.Right()->DispatchVisit(*this); out << ")"; } void DumpVisitor::Visit(const AidlUnaryConstExpression& u) { AIDL_FATAL_IF(inline_constants, AIDL_LOCATION_HERE); // TODO(b/262594867) put parentheses only when necessary out << "("; out << u.Op(); u.Val()->DispatchVisit(*this); out << ")"; } static string GetApiDumpPathFor(const AidlDefinedType& defined_type, const Options& options) { string package_as_path = Join(Split(defined_type.GetPackage(), "."), OS_PATH_SEPARATOR); AIDL_FATAL_IF(options.OutputDir().empty() || options.OutputDir().back() != OS_PATH_SEPARATOR, defined_type); return options.OutputDir() + package_as_path + OS_PATH_SEPARATOR + defined_type.GetName() + ".aidl"; } static void DumpComments(CodeWriter& out, const Comments& comments) { bool needs_newline = false; for (const auto& c : comments) { out << c.body; needs_newline = !EndsWith(c.body, "\n"); } if (needs_newline) { out << "\n"; } } bool dump_api(const Options& options, const IoDelegate& io_delegate) { for (const auto& file : options.InputFiles()) { AidlTypenames typenames; if (internals::load_and_validate_aidl(file, options, io_delegate, &typenames, nullptr) == AidlError::OK) { const auto& doc = typenames.MainDocument(); for (const auto& type : doc.DefinedTypes()) { unique_ptr writer = io_delegate.GetCodeWriter(GetApiDumpPathFor(*type, options)); if (!options.DumpNoLicense()) { // dump doc comments (license) as well for each type DumpComments(*writer, doc.GetComments()); } (*writer) << kPreamble; if (!type->GetPackage().empty()) { (*writer) << "package " << type->GetPackage() << ";\n"; } DumpVisitor visitor(*writer, /*inline_constants=*/false); type->DispatchVisit(visitor); } } else { return false; } } return true; } } // namespace aidl } // namespace android ./PaxHeaders.X/aidl_dumpapi.h0100644 0000000 0000000 00000000034 15172120304 015075 xustar000000000 0000000 28 mtime=1776853188.2800000 aidl_dumpapi.h0100644 0000000 0000000 00000003735 15172120304 012411 0ustar000000000 0000000 /* * Copyright (C) 2021, 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. */ #pragma once #include "aidl_language.h" #include "code_writer.h" namespace android { namespace aidl { struct DumpVisitor : AidlVisitor { CodeWriter& out; bool inline_constants; DumpVisitor(CodeWriter& out, bool inline_constants) : out(out), inline_constants(inline_constants) {} void DumpType(const AidlDefinedType& dt, const string& type); void DumpMembers(const AidlDefinedType& dt); void DumpComments(const AidlCommentable& c); void DumpAnnotations(const AidlAnnotatable& a); void DumpConstantValue(const AidlTypeSpecifier& type, const AidlConstantValue& c); void Visit(const AidlInterface& t) override; void Visit(const AidlParcelable& t) override; void Visit(const AidlStructuredParcelable& t) override; void Visit(const AidlUnionDecl& t) override; void Visit(const AidlEnumDeclaration& t) override; void Visit(const AidlMethod& m) override; void Visit(const AidlVariableDeclaration& v) override; void Visit(const AidlConstantDeclaration& c) override; void Visit(const AidlTypeSpecifier& t) override; void Visit(const AidlConstantValue& c) override; void Visit(const AidlConstantReference& r) override; void Visit(const AidlBinaryConstExpression& b) override; void Visit(const AidlUnaryConstExpression& u) override; }; bool dump_api(const Options& options, const IoDelegate& io_delegate); } // namespace aidl } // namespace android ./PaxHeaders.X/aidl_language.cpp0100644 0000000 0000000 00000000034 15172120304 015554 xustar000000000 0000000 28 mtime=1776853188.2830000 aidl_language.cpp0100644 0000000 0000000 00000177213 15172120304 013073 0ustar000000000 0000000 /* * Copyright (C) 2015, 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_language.h" #include "aidl_typenames.h" #include "parser.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include "aidl.h" #include "aidl_language_y.h" #include "comments.h" #include "logging.h" #include "permission.h" #ifdef _WIN32 int isatty(int fd) { return (fd == 0); } #endif using android::aidl::IoDelegate; using android::base::Error; using android::base::Join; using android::base::Result; using android::base::Split; using std::cerr; using std::pair; using std::set; using std::string; using std::unique_ptr; using std::vector; namespace { bool IsJavaKeyword(const char* str) { static const std::vector kJavaKeywords{ "abstract", "assert", "boolean", "break", "byte", "case", "catch", "char", "class", "const", "continue", "default", "do", "double", "else", "enum", "extends", "final", "finally", "float", "for", "goto", "if", "implements", "import", "instanceof", "int", "interface", "long", "native", "new", "package", "private", "protected", "public", "return", "short", "static", "strictfp", "super", "switch", "synchronized", "this", "throw", "throws", "transient", "try", "void", "volatile", "while", "true", "false", "null", }; return std::find(kJavaKeywords.begin(), kJavaKeywords.end(), str) != kJavaKeywords.end(); } } // namespace AidlNode::~AidlNode() { if (!visited_) { unvisited_locations_.push_back(location_); } } void AidlNode::ClearUnvisitedNodes() { unvisited_locations_.clear(); } const std::vector& AidlNode::GetLocationsOfUnvisitedNodes() { return unvisited_locations_; } void AidlNode::MarkVisited() const { visited_ = true; } AidlNode::AidlNode(const AidlLocation& location, const Comments& comments) : location_(location), comments_(comments) {} std::string AidlNode::PrintLine() const { std::stringstream ss; ss << location_.file_ << ":" << location_.begin_.line; return ss.str(); } std::string AidlNode::PrintLocation() const { std::stringstream ss; ss << location_.file_ << ":" << location_.begin_.line << ":" << location_.begin_.column << ":" << location_.end_.line << ":" << location_.end_.column; return ss.str(); } std::vector AidlNode::unvisited_locations_; static const AidlTypeSpecifier kStringType{AIDL_LOCATION_HERE, "String", /*array=*/std::nullopt, nullptr, Comments{}}; static const AidlTypeSpecifier kStringArrayType{AIDL_LOCATION_HERE, "String", DynamicArray{}, nullptr, Comments{}}; static const AidlTypeSpecifier kIntType{AIDL_LOCATION_HERE, "int", /*array=*/std::nullopt, nullptr, Comments{}}; static const AidlTypeSpecifier kLongType{AIDL_LOCATION_HERE, "long", /*array=*/std::nullopt, nullptr, Comments{}}; static const AidlTypeSpecifier kBooleanType{AIDL_LOCATION_HERE, "boolean", /*array=*/std::nullopt, nullptr, Comments{}}; const std::vector& AidlAnnotation::AllSchemas() { static const std::vector kSchemas{ {AidlAnnotation::Type::NULLABLE, "nullable", CONTEXT_TYPE_SPECIFIER, {{"heap", kBooleanType}}}, {AidlAnnotation::Type::UTF8_IN_CPP, "utf8InCpp", CONTEXT_TYPE_SPECIFIER, {}}, {AidlAnnotation::Type::SENSITIVE_DATA, "SensitiveData", CONTEXT_TYPE_INTERFACE, {}}, {AidlAnnotation::Type::VINTF_STABILITY, "VintfStability", CONTEXT_TYPE, {}}, {AidlAnnotation::Type::UNSUPPORTED_APP_USAGE, "UnsupportedAppUsage", CONTEXT_TYPE | CONTEXT_MEMBER, {{"expectedSignature", kStringType}, {"implicitMember", kStringType}, {"maxTargetSdk", kIntType}, {"publicAlternatives", kStringType}, {"trackingBug", kLongType}}}, {AidlAnnotation::Type::JAVA_STABLE_PARCELABLE, "JavaOnlyStableParcelable", CONTEXT_TYPE_UNSTRUCTURED_PARCELABLE, {}}, {AidlAnnotation::Type::NDK_STABLE_PARCELABLE, "NdkOnlyStableParcelable", CONTEXT_TYPE_UNSTRUCTURED_PARCELABLE, {}}, {AidlAnnotation::Type::RUST_STABLE_PARCELABLE, "RustOnlyStableParcelable", CONTEXT_TYPE_UNSTRUCTURED_PARCELABLE, {}}, {AidlAnnotation::Type::BACKING, "Backing", CONTEXT_TYPE_ENUM, {{"type", kStringType, /* required= */ true}}}, {AidlAnnotation::Type::JAVA_PASSTHROUGH, "JavaPassthrough", CONTEXT_ALL, {{"annotation", kStringType, /* required= */ true}}, /* repeatable= */ true}, {AidlAnnotation::Type::JAVA_DERIVE, "JavaDerive", CONTEXT_TYPE_STRUCTURED_PARCELABLE | CONTEXT_TYPE_UNION | CONTEXT_TYPE_ENUM, {{"toString", kBooleanType}, {"equals", kBooleanType}}}, {AidlAnnotation::Type::JAVA_DEFAULT, "JavaDefault", CONTEXT_TYPE_INTERFACE, {}}, {AidlAnnotation::Type::JAVA_DELEGATOR, "JavaDelegator", CONTEXT_TYPE_INTERFACE, {}}, {AidlAnnotation::Type::JAVA_ONLY_IMMUTABLE, "JavaOnlyImmutable", CONTEXT_TYPE_STRUCTURED_PARCELABLE | CONTEXT_TYPE_UNION | CONTEXT_TYPE_UNSTRUCTURED_PARCELABLE, {}}, {AidlAnnotation::Type::JAVA_SUPPRESS_LINT, "JavaSuppressLint", CONTEXT_ALL, {{"value", kStringArrayType, /* required= */ true}}}, {AidlAnnotation::Type::FIXED_SIZE, "FixedSize", CONTEXT_TYPE_STRUCTURED_PARCELABLE | CONTEXT_TYPE_UNION, {}}, {AidlAnnotation::Type::DESCRIPTOR, "Descriptor", CONTEXT_TYPE_INTERFACE, {{"value", kStringType, /* required= */ true}}}, {AidlAnnotation::Type::RUST_DERIVE, "RustDerive", CONTEXT_TYPE_STRUCTURED_PARCELABLE | CONTEXT_TYPE_UNION, {{"Copy", kBooleanType}, {"Clone", kBooleanType}, {"PartialOrd", kBooleanType}, {"Ord", kBooleanType}, {"PartialEq", kBooleanType}, {"Eq", kBooleanType}, {"Hash", kBooleanType}}}, {AidlAnnotation::Type::SUPPRESS_WARNINGS, "SuppressWarnings", CONTEXT_TYPE | CONTEXT_MEMBER, {{"value", kStringArrayType, /* required= */ true}}}, {AidlAnnotation::Type::PERMISSION_ENFORCE, "EnforcePermission", CONTEXT_TYPE_INTERFACE | CONTEXT_METHOD, {{"value", kStringType}, {"anyOf", kStringArrayType}, {"allOf", kStringArrayType}}}, {AidlAnnotation::Type::PERMISSION_MANUAL, "PermissionManuallyEnforced", CONTEXT_TYPE_INTERFACE | CONTEXT_METHOD, {}}, {AidlAnnotation::Type::PERMISSION_NONE, "RequiresNoPermission", CONTEXT_TYPE_INTERFACE | CONTEXT_METHOD, {}}, {AidlAnnotation::Type::PROPAGATE_ALLOW_BLOCKING, "PropagateAllowBlocking", CONTEXT_METHOD, {}}, }; return kSchemas; } std::string AidlAnnotation::TypeToString(Type type) { for (const Schema& schema : AllSchemas()) { if (type == schema.type) return schema.name; } AIDL_FATAL(AIDL_LOCATION_HERE) << "Unrecognized type: " << static_cast(type); __builtin_unreachable(); } std::unique_ptr AidlAnnotation::Parse( const AidlLocation& location, const string& name, std::map> parameter_list, const Comments& comments) { const Schema* schema = nullptr; for (const Schema& a_schema : AllSchemas()) { if (a_schema.name == name) { schema = &a_schema; } } if (schema == nullptr) { std::ostringstream stream; stream << "'" << name << "' is not a recognized annotation. "; stream << "It must be one of:"; for (const Schema& s : AllSchemas()) { stream << " " << s.name; } stream << "."; AIDL_ERROR(location) << stream.str(); return {}; } return std::unique_ptr( new AidlAnnotation(location, *schema, std::move(parameter_list), comments)); } AidlAnnotation::AidlAnnotation(const AidlLocation& location, const Schema& schema, std::map> parameters, const Comments& comments) : AidlNode(location, comments), schema_(schema), parameters_(std::move(parameters)) {} struct ConstReferenceFinder : AidlVisitor { const AidlConstantReference* found = nullptr; void Visit(const AidlConstantReference& ref) override { if (!found) found = &ref; } static const AidlConstantReference* Find(const AidlConstantValue& c) { ConstReferenceFinder finder; VisitTopDown(finder, c); return finder.found; } }; // Checks if annotation complies with the schema // - every parameter is known and has well-typed value. // - every required parameter is present. bool AidlAnnotation::CheckValid() const { for (const auto& name_and_param : parameters_) { const std::string& param_name = name_and_param.first; const std::shared_ptr& param = name_and_param.second; const auto param_type = schema_.ParamType(param_name); if (!param_type) { std::ostringstream stream; stream << "Parameter " << param_name << " not supported "; stream << "for annotation " << GetName() << ". "; stream << "It must be one of:"; for (const auto& param : schema_.parameters) { stream << " " << param.name; } AIDL_ERROR(this) << stream.str(); return false; } const auto& found = ConstReferenceFinder::Find(*param); if (found) { AIDL_ERROR(found) << "Value must be a constant expression but contains reference to " << found->GetFieldName() << "."; return false; } if (!param->CheckValid()) { AIDL_ERROR(this) << "Invalid value for parameter " << param_name << " on annotation " << GetName() << "."; return false; } const std::string param_value = param->ValueString(param_type->type, AidlConstantValueDecorator); // Assume error on empty string. if (param_value == "") { AIDL_ERROR(this) << "Invalid value for parameter " << param_name << " on annotation " << GetName() << "."; return false; } } bool success = true; for (const auto& param : schema_.parameters) { if (param.required && parameters_.count(param.name) == 0) { AIDL_ERROR(this) << "Missing '" << param.name << "' on @" << GetName() << "."; success = false; } } if (!success) { return false; } // For @Enforce annotations, validates the expression. if (schema_.type == AidlAnnotation::Type::PERMISSION_ENFORCE) { auto expr = EnforceExpression(); if (!expr.ok()) { AIDL_ERROR(this) << "Unable to parse @EnforcePermission annotation: " << expr.error(); return false; } } return true; } Result> AidlAnnotation::EnforceExpression() const { auto single = ParamValue("value"); auto anyOf = ParamValue>("anyOf"); auto allOf = ParamValue>("allOf"); if (single.has_value()) { return std::make_unique(single.value()); } else if (anyOf.has_value()) { auto v = android::aidl::perm::AnyOf{anyOf.value()}; return std::make_unique(v); } else if (allOf.has_value()) { auto v = android::aidl::perm::AllOf{allOf.value()}; return std::make_unique(v); } return Error() << "No parameter for @EnforcePermission"; } // Checks if the annotation is applicable to the current context. // For example, annotations like @VintfStability, @FixedSize is not applicable to AidlTypeSpecifier // nodes. bool AidlAnnotation::CheckContext(TargetContext context) const { if (schema_.target_context & static_cast(context)) { return true; } const static map context_name_map{ {CONTEXT_TYPE_INTERFACE, "interface"}, {CONTEXT_TYPE_ENUM, "enum"}, {CONTEXT_TYPE_STRUCTURED_PARCELABLE, "parcelable definition"}, {CONTEXT_TYPE_UNION, "union"}, {CONTEXT_TYPE_UNSTRUCTURED_PARCELABLE, "parcelable declaration"}, {CONTEXT_CONST, "constant"}, {CONTEXT_FIELD, "field"}, {CONTEXT_METHOD, "method"}, {CONTEXT_TYPE_SPECIFIER, "type"}, }; vector available; for (const auto& [context, name] : context_name_map) { if (schema_.target_context & context) { available.push_back(name); } } AIDL_ERROR(this) << "@" << GetName() << " is not available. It can only annotate: " << Join(available, ", ") << "."; return false; } std::map AidlAnnotation::AnnotationParams( const ConstantValueDecorator& decorator) const { std::map raw_params; for (const auto& name_and_param : parameters_) { const std::string& param_name = name_and_param.first; const std::shared_ptr& param = name_and_param.second; const auto param_type = schema_.ParamType(param_name); AIDL_FATAL_IF(!param_type, this); raw_params.emplace(param_name, param->ValueString(param_type->type, decorator)); } return raw_params; } std::string AidlAnnotation::ToString() const { if (parameters_.empty()) { return "@" + GetName(); } else { vector param_strings; for (const auto& [name, value] : AnnotationParams(AidlConstantValueDecorator)) { param_strings.emplace_back(name + "=" + value); } return "@" + GetName() + "(" + Join(param_strings, ", ") + ")"; } } void AidlAnnotation::TraverseChildren(std::function traverse) const { for (const auto& [name, value] : parameters_) { (void)name; traverse(*value); } } static const AidlAnnotation* GetAnnotation( const vector>& annotations, AidlAnnotation::Type type) { for (const auto& a : annotations) { if (a->GetType() == type) { AIDL_FATAL_IF(a->Repeatable(), a) << "Trying to get a single annotation when it is repeatable."; return a.get(); } } return nullptr; } static const AidlAnnotation* GetScopedAnnotation(const AidlDefinedType& defined_type, AidlAnnotation::Type type) { const AidlAnnotation* annotation = GetAnnotation(defined_type.GetAnnotations(), type); if (annotation) { return annotation; } const AidlDefinedType* enclosing_type = defined_type.GetParentType(); if (enclosing_type) { return GetScopedAnnotation(*enclosing_type, type); } return nullptr; } AidlAnnotatable::AidlAnnotatable(const AidlLocation& location, const Comments& comments) : AidlCommentable(location, comments) {} bool AidlAnnotatable::IsNullable() const { return GetAnnotation(annotations_, AidlAnnotation::Type::NULLABLE); } bool AidlAnnotatable::IsHeapNullable() const { auto annot = GetAnnotation(annotations_, AidlAnnotation::Type::NULLABLE); if (annot) { return annot->ParamValue("heap").value_or(false); } return false; } bool AidlAnnotatable::IsUtf8InCpp() const { return GetAnnotation(annotations_, AidlAnnotation::Type::UTF8_IN_CPP); } bool AidlAnnotatable::IsSensitiveData() const { return GetAnnotation(annotations_, AidlAnnotation::Type::SENSITIVE_DATA); } bool AidlAnnotatable::IsVintfStability() const { auto defined_type = AidlCast(*this); AIDL_FATAL_IF(!defined_type, *this) << "@VintfStability is not attached to a type"; return GetScopedAnnotation(*defined_type, AidlAnnotation::Type::VINTF_STABILITY); } bool AidlAnnotatable::IsJavaOnlyImmutable() const { return GetAnnotation(annotations_, AidlAnnotation::Type::JAVA_ONLY_IMMUTABLE); } bool AidlAnnotatable::IsFixedSize() const { return GetAnnotation(annotations_, AidlAnnotation::Type::FIXED_SIZE); } const AidlAnnotation* AidlAnnotatable::UnsupportedAppUsage() const { return GetAnnotation(annotations_, AidlAnnotation::Type::UNSUPPORTED_APP_USAGE); } std::vector AidlAnnotatable::RustDerive() const { std::vector ret; if (const auto* ann = GetAnnotation(annotations_, AidlAnnotation::Type::RUST_DERIVE)) { for (const auto& name_and_param : ann->AnnotationParams(AidlConstantValueDecorator)) { if (name_and_param.second == "true") { ret.push_back(name_and_param.first); } } } return ret; } const AidlAnnotation* AidlAnnotatable::BackingType() const { return GetAnnotation(annotations_, AidlAnnotation::Type::BACKING); } std::vector AidlAnnotatable::SuppressWarnings() const { auto annot = GetAnnotation(annotations_, AidlAnnotation::Type::SUPPRESS_WARNINGS); if (annot) { auto names = annot->ParamValue>("value"); AIDL_FATAL_IF(!names.has_value(), this); return std::move(names.value()); } return {}; } // Parses the @Enforce annotation expression. std::unique_ptr AidlAnnotatable::EnforceExpression() const { auto annot = GetAnnotation(annotations_, AidlAnnotation::Type::PERMISSION_ENFORCE); if (annot) { auto perm_expr = annot->EnforceExpression(); if (!perm_expr.ok()) { // This should have been caught during validation. AIDL_FATAL(this) << "Unable to parse @EnforcePermission annotation: " << perm_expr.error(); } return std::move(perm_expr.value()); } return {}; } bool AidlAnnotatable::IsPermissionManual() const { return GetAnnotation(annotations_, AidlAnnotation::Type::PERMISSION_MANUAL); } bool AidlAnnotatable::IsPermissionNone() const { return GetAnnotation(annotations_, AidlAnnotation::Type::PERMISSION_NONE); } bool AidlAnnotatable::IsPermissionAnnotated() const { return IsPermissionNone() || IsPermissionManual() || EnforceExpression(); } bool AidlAnnotatable::IsPropagateAllowBlocking() const { return GetAnnotation(annotations_, AidlAnnotation::Type::PROPAGATE_ALLOW_BLOCKING); } bool AidlAnnotatable::IsStableApiParcelable(Options::Language lang) const { if (lang == Options::Language::JAVA) return GetAnnotation(annotations_, AidlAnnotation::Type::JAVA_STABLE_PARCELABLE); if (lang == Options::Language::NDK) return GetAnnotation(annotations_, AidlAnnotation::Type::NDK_STABLE_PARCELABLE); if (lang == Options::Language::RUST) return GetAnnotation(annotations_, AidlAnnotation::Type::RUST_STABLE_PARCELABLE); return false; } bool AidlAnnotatable::JavaDerive(const std::string& method) const { auto annotation = GetAnnotation(annotations_, AidlAnnotation::Type::JAVA_DERIVE); if (annotation != nullptr) { return annotation->ParamValue(method).value_or(false); } return false; } bool AidlAnnotatable::IsJavaDefault() const { return GetAnnotation(annotations_, AidlAnnotation::Type::JAVA_DEFAULT); } bool AidlAnnotatable::IsJavaDelegator() const { return GetAnnotation(annotations_, AidlAnnotation::Type::JAVA_DELEGATOR); } std::string AidlAnnotatable::GetDescriptor() const { auto annotation = GetAnnotation(annotations_, AidlAnnotation::Type::DESCRIPTOR); if (annotation != nullptr) { return annotation->ParamValue("value").value(); } return ""; } bool AidlAnnotatable::CheckValid(const AidlTypenames&) const { for (const auto& annotation : GetAnnotations()) { if (!annotation->CheckValid()) { return false; } } std::map declared; for (const auto& annotation : GetAnnotations()) { const auto& [iter, inserted] = declared.emplace(annotation->GetType(), annotation->GetLocation()); if (!inserted && !annotation->Repeatable()) { AIDL_ERROR(this) << "'" << annotation->GetName() << "' is repeated, but not allowed. Previous location: " << iter->second; return false; } } return true; } string AidlAnnotatable::ToString() const { vector ret; for (const auto& a : annotations_) { ret.emplace_back(a->ToString()); } std::sort(ret.begin(), ret.end()); return Join(ret, " "); } AidlTypeSpecifier::AidlTypeSpecifier(const AidlLocation& location, const string& unresolved_name, std::optional array, vector>* type_params, const Comments& comments) : AidlAnnotatable(location, comments), AidlParameterizable>(type_params), unresolved_name_(unresolved_name), array_(std::move(array)), split_name_(Split(unresolved_name, ".")) {} void AidlTypeSpecifier::ViewAsArrayBase(std::function func) const { AIDL_FATAL_IF(!array_.has_value(), this); // Declaring array of generic type cannot happen, it is grammar error. AIDL_FATAL_IF(IsGeneric(), this); bool is_mutated = mutated_; mutated_ = true; // mutate the array type to its base by removing a single dimension // e.g.) T[] => T, T[N][M] => T[M] (note that, M is removed) if (IsFixedSizeArray() && std::get(*array_).dimensions.size() > 1) { auto& dimensions = std::get(*array_).dimensions; auto dim = std::move(dimensions.front()); dimensions.erase(dimensions.begin()); func(*this); dimensions.insert(dimensions.begin(), std::move(dim)); } else { ArrayType array_type = std::move(array_.value()); array_ = std::nullopt; func(*this); array_ = std::move(array_type); } mutated_ = is_mutated; } bool AidlTypeSpecifier::MakeArray(ArrayType array_type) { // T becomes T[] or T[N] if (!IsArray()) { array_ = std::move(array_type); return true; } // T[N] becomes T[N][M] if (auto fixed_size_array = std::get_if(&array_type); fixed_size_array != nullptr && IsFixedSizeArray()) { // concat dimensions for (auto& dim : fixed_size_array->dimensions) { std::get(*array_).dimensions.push_back(std::move(dim)); } return true; } return false; } std::vector FixedSizeArray::GetDimensionInts() const { std::vector ints; for (const auto& dim : dimensions) { ints.push_back(dim->EvaluatedValue()); } return ints; } std::vector AidlTypeSpecifier::GetFixedSizeArrayDimensions() const { AIDL_FATAL_IF(!IsFixedSizeArray(), "not a fixed-size array"); return std::get(GetArray()).GetDimensionInts(); } string AidlTypeSpecifier::Signature() const { string ret = GetName(); if (IsGeneric()) { vector arg_names; for (const auto& ta : GetTypeParameters()) { arg_names.emplace_back(ta->Signature()); } ret += "<" + Join(arg_names, ",") + ">"; } if (IsArray()) { if (IsFixedSizeArray()) { for (const auto& dim : GetFixedSizeArrayDimensions()) { ret += "[" + std::to_string(dim) + "]"; } } else { ret += "[]"; } } return ret; } string AidlTypeSpecifier::ToString() const { string ret = Signature(); string annotations = AidlAnnotatable::ToString(); if (annotations != "") { ret = annotations + " " + ret; } return ret; } // When `scope` is specified, name is resolved first based on it. // `scope` can be null for built-in types and fully-qualified types. bool AidlTypeSpecifier::Resolve(const AidlTypenames& typenames, const AidlScope* scope) { AIDL_FATAL_IF(IsResolved(), this); std::string name = unresolved_name_; if (scope) { name = scope->ResolveName(name); } AidlTypenames::ResolvedTypename result = typenames.ResolveTypename(name); if (result.is_resolved) { fully_qualified_name_ = result.canonical_name; split_name_ = Split(fully_qualified_name_, "."); defined_type_ = result.defined_type; } return result.is_resolved; } const AidlDefinedType* AidlTypeSpecifier::GetDefinedType() const { return defined_type_; } bool AidlTypeSpecifier::CheckValid(const AidlTypenames& typenames) const { if (!AidlAnnotatable::CheckValid(typenames)) { return false; } if (IsGeneric()) { const auto& types = GetTypeParameters(); for (const auto& arg : types) { if (!arg->CheckValid(typenames)) { return false; } } const string& type_name = GetName(); // TODO(b/136048684) Disallow to use primitive types only if it is List or Map. if (type_name == "List" || type_name == "Map") { if (std::any_of(types.begin(), types.end(), [&](auto& type_ptr) { return !type_ptr->IsArray() && (typenames.GetEnumDeclaration(*type_ptr) || AidlTypenames::IsPrimitiveTypename(type_ptr->GetName())); })) { AIDL_ERROR(this) << "A generic type cannot have any primitive type parameters."; return false; } } const auto defined_type = typenames.TryGetDefinedType(type_name); const auto parameterizable = defined_type != nullptr ? defined_type->AsParameterizable() : nullptr; const bool is_user_defined_generic_type = parameterizable != nullptr && parameterizable->IsGeneric(); const size_t num_params = GetTypeParameters().size(); if (type_name == "List") { if (num_params > 1) { AIDL_ERROR(this) << "List can only have one type parameter, but got: '" << Signature() << "'"; return false; } static const char* kListUsage = "List supports interface/parcelable/union, String, IBinder, and ParcelFileDescriptor."; const AidlTypeSpecifier& contained_type = *GetTypeParameters()[0]; if (contained_type.IsArray()) { AIDL_ERROR(this) << "List of arrays is not supported. " << kListUsage; return false; } const string& contained_type_name = contained_type.GetName(); if (AidlTypenames::IsBuiltinTypename(contained_type_name)) { if (contained_type_name != "String" && contained_type_name != "IBinder" && contained_type_name != "ParcelFileDescriptor") { AIDL_ERROR(this) << "List<" << contained_type_name << "> is not supported. " << kListUsage; return false; } } } else if (type_name == "Map") { if (num_params != 0 && num_params != 2) { AIDL_ERROR(this) << "Map must have 0 or 2 type parameters, but got " << "'" << Signature() << "'"; return false; } if (num_params == 2) { const string& key_type = GetTypeParameters()[0]->Signature(); if (key_type != "String") { AIDL_ERROR(this) << "The type of key in map must be String, but it is " << "'" << key_type << "'"; return false; } } } else if (is_user_defined_generic_type) { const size_t allowed = parameterizable->GetTypeParameters().size(); if (num_params != allowed) { AIDL_ERROR(this) << type_name << " must have " << allowed << " type parameters, but got " << num_params; return false; } } else { AIDL_ERROR(this) << type_name << " is not a generic type."; return false; } } const bool is_generic_string_list = GetName() == "List" && IsGeneric() && GetTypeParameters().size() == 1 && GetTypeParameters()[0]->GetName() == "String"; if (IsUtf8InCpp() && (GetName() != "String" && !is_generic_string_list)) { AIDL_ERROR(this) << "@utf8InCpp can only be used on String, String[], and List."; return false; } if (GetName() == "void") { if (IsArray() || IsNullable() || IsUtf8InCpp()) { AIDL_ERROR(this) << "void type cannot be an array or nullable or utf8 string"; return false; } } if (IsArray()) { if (GetName() == "ParcelableHolder" || GetName() == "List" || GetName() == "Map" || GetName() == "CharSequence") { AIDL_ERROR(this) << "Arrays of " << GetName() << " are not supported."; return false; } } if (IsNullable()) { if (AidlTypenames::IsPrimitiveTypename(GetName()) && !IsArray()) { AIDL_ERROR(this) << "Primitive type cannot get nullable annotation"; return false; } const auto defined_type = typenames.TryGetDefinedType(GetName()); if (defined_type != nullptr && defined_type->AsEnumDeclaration() != nullptr && !IsArray()) { AIDL_ERROR(this) << "Enum type cannot get nullable annotation"; return false; } if (GetName() == "ParcelableHolder") { AIDL_ERROR(this) << "ParcelableHolder cannot be nullable."; return false; } if (IsHeapNullable()) { if (!defined_type || IsArray() || !defined_type->AsParcelable()) { AIDL_ERROR(this) << "@nullable(heap=true) is available to parcelables."; return false; } } } if (IsFixedSizeArray()) { for (const auto& dim : std::get(GetArray()).dimensions) { if (!dim->Evaluate()) { return false; } if (dim->GetType() > AidlConstantValue::Type::INT32) { AIDL_ERROR(this) << "Array size must be a positive number: " << dim->Literal(); return false; } auto value = dim->EvaluatedValue(); if (value < 0) { AIDL_ERROR(this) << "Array size must be a positive number: " << value; return false; } } } return true; } void AidlTypeSpecifier::TraverseChildren(std::function traverse) const { AidlAnnotatable::TraverseChildren(traverse); if (IsGeneric()) { for (const auto& tp : GetTypeParameters()) { traverse(*tp); } } if (IsFixedSizeArray()) { for (const auto& dim : std::get(GetArray()).dimensions) { traverse(*dim); } } } std::string AidlConstantValueDecorator( const AidlTypeSpecifier& type, const std::variant>& raw_value) { if (type.IsArray()) { const auto& values = std::get>(raw_value); return "{" + Join(values, ", ") + "}"; } const std::string& value = std::get(raw_value); if (auto defined_type = type.GetDefinedType(); defined_type) { auto enum_type = defined_type->AsEnumDeclaration(); AIDL_FATAL_IF(!enum_type, type) << "Invalid type for \"" << value << "\""; return type.GetName() + "." + value.substr(value.find_last_of('.') + 1); } return value; } AidlVariableDeclaration::AidlVariableDeclaration(const AidlLocation& location, AidlTypeSpecifier* type, const std::string& name) : AidlVariableDeclaration(location, type, name, AidlConstantValue::Default(*type)) { default_user_specified_ = false; } AidlVariableDeclaration::AidlVariableDeclaration(const AidlLocation& location, AidlTypeSpecifier* type, const std::string& name, AidlConstantValue* default_value) : AidlMember(location, type->GetComments()), type_(type), name_(name), default_user_specified_(true), default_value_(default_value) {} bool AidlVariableDeclaration::HasUsefulDefaultValue() const { if (GetDefaultValue()) { return true; } // null is accepted as a valid default value in all backends if (GetType().IsNullable()) { return true; } return false; } bool AidlVariableDeclaration::CheckValid(const AidlTypenames& typenames) const { bool valid = true; valid &= type_->CheckValid(typenames); if (type_->GetName() == "void") { AIDL_ERROR(this) << "Declaration " << name_ << " is void, but declarations cannot be of void type."; valid = false; } if (default_value_ == nullptr) return valid; valid &= default_value_->CheckValid(); if (!valid) return false; return !ValueString(AidlConstantValueDecorator).empty(); } string AidlVariableDeclaration::GetCapitalizedName() const { AIDL_FATAL_IF(name_.size() <= 0, *this) << "Name can't be empty."; string str = name_; str[0] = static_cast(toupper(str[0])); return str; } string AidlVariableDeclaration::ToString() const { string ret = type_->ToString() + " " + name_; if (default_value_ != nullptr && default_user_specified_) { ret += " = " + ValueString(AidlConstantValueDecorator); } return ret; } string AidlVariableDeclaration::Signature() const { return type_->Signature() + " " + name_; } std::string AidlVariableDeclaration::ValueString(const ConstantValueDecorator& decorator) const { if (default_value_ != nullptr) { return default_value_->ValueString(GetType(), decorator); } else { return ""; } } void AidlVariableDeclaration::TraverseChildren( std::function traverse) const { traverse(GetType()); if (auto default_value = GetDefaultValue(); default_value) { traverse(*default_value); } } AidlArgument::AidlArgument(const AidlLocation& location, AidlArgument::Direction direction, AidlTypeSpecifier* type, const std::string& name) : AidlVariableDeclaration(location, type, name), direction_(direction), direction_specified_(true) {} AidlArgument::AidlArgument(const AidlLocation& location, AidlTypeSpecifier* type, const std::string& name) : AidlVariableDeclaration(location, type, name), direction_(AidlArgument::IN_DIR), direction_specified_(false) {} static std::string to_string(AidlArgument::Direction direction) { switch (direction) { case AidlArgument::IN_DIR: return "in"; case AidlArgument::OUT_DIR: return "out"; case AidlArgument::INOUT_DIR: return "inout"; } } string AidlArgument::GetDirectionSpecifier() const { string ret; if (direction_specified_) { ret = to_string(direction_); } return ret; } string AidlArgument::ToString() const { if (direction_specified_) { return GetDirectionSpecifier() + " " + AidlVariableDeclaration::ToString(); } else { return AidlVariableDeclaration::ToString(); } } static std::string FormatDirections(const std::set& directions) { std::vector out; for (const auto& d : directions) { out.push_back(to_string(d)); } if (out.size() <= 1) { // [] => "" or [A] => "A" return Join(out, ""); } else if (out.size() == 2) { // [A,B] => "A or B" return Join(out, " or "); } else { // [A,B,C] => "A, B, or C" out.back() = "or " + out.back(); return Join(out, ", "); } } bool AidlArgument::CheckValid(const AidlTypenames& typenames) const { if (!GetType().CheckValid(typenames)) { return false; } const auto& aspect = typenames.GetArgumentAspect(GetType()); if (aspect.possible_directions.size() == 0) { AIDL_ERROR(this) << aspect.name << " cannot be an argument type"; return false; } // when direction is not specified, "in" is assumed and should be the only possible direction if (!DirectionWasSpecified() && aspect.possible_directions != std::set{AidlArgument::IN_DIR}) { AIDL_ERROR(this) << "The direction of '" << GetName() << "' is not specified. " << aspect.name << " can be an " << FormatDirections(aspect.possible_directions) << " parameter."; return false; } if (aspect.possible_directions.count(GetDirection()) == 0) { AIDL_ERROR(this) << "'" << GetName() << "' can't be an " << GetDirectionSpecifier() << " parameter because " << aspect.name << " can only be an " << FormatDirections(aspect.possible_directions) << " parameter."; return false; } return true; } bool AidlCommentable::IsHidden() const { return android::aidl::HasHideInComments(GetComments()); } bool AidlCommentable::IsDeprecated() const { return android::aidl::FindDeprecated(GetComments()).has_value(); } AidlMember::AidlMember(const AidlLocation& location, const Comments& comments) : AidlAnnotatable(location, comments) {} AidlConstantDeclaration::AidlConstantDeclaration(const AidlLocation& location, AidlTypeSpecifier* type, const std::string& name, AidlConstantValue* value) : AidlMember(location, type->GetComments()), type_(type), name_(name), value_(value) {} bool AidlConstantDeclaration::CheckValid(const AidlTypenames& typenames) const { bool valid = true; valid &= type_->CheckValid(typenames); valid &= value_->CheckValid(); valid = valid && !ValueString(AidlConstantValueDecorator).empty(); if (!valid) return false; const static set kSupportedConstTypes = {"String", "byte", "int", "long", "float", "double"}; if (kSupportedConstTypes.find(type_->Signature()) == kSupportedConstTypes.end()) { AIDL_ERROR(this) << "Constant of type " << type_->Signature() << " is not supported."; return false; } return true; } string AidlConstantDeclaration::ToString() const { return "const " + type_->ToString() + " " + name_ + " = " + ValueString(AidlConstantValueDecorator); } string AidlConstantDeclaration::Signature() const { return type_->Signature() + " " + name_; } AidlMethod::AidlMethod(const AidlLocation& location, bool oneway, AidlTypeSpecifier* type, const std::string& name, std::vector>* args, const Comments& comments) : AidlMethod(location, oneway, type, name, args, comments, 0) { has_id_ = false; } AidlMethod::AidlMethod(const AidlLocation& location, bool oneway, AidlTypeSpecifier* type, const std::string& name, std::vector>* args, const Comments& comments, int id) : AidlMember(location, comments), oneway_(oneway), oneway_annotation_(oneway), type_(type), name_(name), arguments_(std::move(*args)), id_(id) { has_id_ = true; delete args; for (const unique_ptr& a : arguments_) { if (a->IsIn()) { in_arguments_.push_back(a.get()); } if (a->IsOut()) { out_arguments_.push_back(a.get()); } } } string AidlMethod::Signature() const { vector arg_signatures; for (const auto& arg : GetArguments()) { arg_signatures.emplace_back(arg->GetType().Signature()); } return GetName() + "(" + Join(arg_signatures, ", ") + ")"; } string AidlMethod::ToString() const { vector arg_strings; for (const auto& arg : GetArguments()) { arg_strings.emplace_back(arg->ToString()); } string ret = (IsOneway() ? "oneway " : "") + GetType().ToString() + " " + GetName() + "(" + Join(arg_strings, ", ") + ")"; if (HasId()) { ret += " = " + std::to_string(GetId()); } return ret; } bool AidlMethod::CheckValid(const AidlTypenames& typenames) const { if (!GetType().CheckValid(typenames)) { return false; } // TODO(b/156872582): Support it when ParcelableHolder supports every backend. if (GetType().GetName() == "ParcelableHolder") { AIDL_ERROR(this) << "ParcelableHolder cannot be a return type"; return false; } if (IsOneway() && GetType().GetName() != "void") { AIDL_ERROR(this) << "oneway method '" << GetName() << "' cannot return a value"; return false; } set argument_names; for (const auto& arg : GetArguments()) { auto it = argument_names.find(arg->GetName()); if (it != argument_names.end()) { AIDL_ERROR(this) << "method '" << GetName() << "' has duplicate argument name '" << arg->GetName() << "'"; return false; } argument_names.insert(arg->GetName()); if (!arg->CheckValid(typenames)) { return false; } if (IsOneway() && arg->IsOut()) { AIDL_ERROR(this) << "oneway method '" << this->GetName() << "' cannot have out parameters"; return false; } // check that the name doesn't match a keyword if (IsJavaKeyword(arg->GetName().c_str())) { AIDL_ERROR(arg) << "Argument name is a Java or aidl keyword"; return false; } // Reserve a namespace for internal use if (android::base::StartsWith(arg->GetName(), "_aidl")) { AIDL_ERROR(arg) << "Argument name cannot begin with '_aidl'"; return false; } if (arg->GetType().GetName() == "void") { AIDL_ERROR(arg->GetType()) << "'void' is an invalid type for the parameter '" << arg->GetName() << "'"; return false; } } return true; } AidlDefinedType::AidlDefinedType(const AidlLocation& location, const std::string& name, const Comments& comments, const std::string& package, std::vector>* members) : AidlMember(location, comments), AidlScope(this), name_(name), package_(package) { // adjust name/package when name is fully qualified (for preprocessed files) if (package_.empty() && name_.find('.') != std::string::npos) { // Note that this logic is absolutely wrong. Given a parcelable // org.some.Foo.Bar, the class name is Foo.Bar, but this code will claim that // the class is just Bar. However, this was the way it was done in the past. // // See b/17415692 auto pos = name.rfind('.'); // name is the last part. name_ = name.substr(pos + 1); // package is the initial parts (except the last). package_ = name.substr(0, pos); } if (members) { for (auto& m : *members) { if (auto constant = AidlCast(*m); constant) { constants_.emplace_back(constant); } else if (auto variable = AidlCast(*m); variable) { variables_.emplace_back(variable); } else if (auto method = AidlCast(*m); method) { methods_.emplace_back(method); } else if (auto type = AidlCast(*m); type) { type->SetEnclosingScope(this); types_.emplace_back(type); } else { AIDL_FATAL(*m) << "Unknown member type."; } members_.push_back(m.release()); } delete members; } } bool AidlDefinedType::CheckValid(const AidlTypenames& typenames) const { if (!AidlAnnotatable::CheckValid(typenames)) { return false; } if (!CheckValidWithMembers(typenames)) { return false; } return true; } std::string AidlDefinedType::GetCanonicalName() const { if (auto parent = GetParentType(); parent) { return parent->GetCanonicalName() + "." + GetName(); } if (package_.empty()) { return GetName(); } return GetPackage() + "." + GetName(); } bool AidlDefinedType::CheckValidWithMembers(const AidlTypenames& typenames) const { bool success = true; for (const auto& t : GetNestedTypes()) { success = success && t->CheckValid(typenames); } if (auto parameterizable = AsParameterizable(); parameterizable && parameterizable->IsGeneric() && !GetNestedTypes().empty()) { AIDL_ERROR(this) << "Generic types can't have nested types."; return false; } std::set nested_type_names; for (const auto& t : GetNestedTypes()) { bool duplicated = !nested_type_names.emplace(t->GetName()).second; if (duplicated) { AIDL_ERROR(t) << "Redefinition of '" << t->GetName() << "'."; success = false; } // nested type can't have a parent name if (t->GetName() == GetName()) { AIDL_ERROR(t) << "Nested type '" << GetName() << "' has the same name as its parent."; success = false; } // Having unstructured parcelables as nested types doesn't make sense because they are defined // somewhere else in native languages (e.g. C++, Java...). if (AidlCast(*t)) { AIDL_ERROR(t) << "'" << t->GetName() << "' is nested. Unstructured parcelables should be at the root scope."; return false; } } if (!TopologicalVisit(GetNestedTypes(), [](auto&) {})) { AIDL_ERROR(this) << GetName() << " has nested types with cyclic references. C++ and NDK backends don't " "support cyclic references."; return false; } for (const auto& v : GetFields()) { const bool field_valid = v->CheckValid(typenames); success = success && field_valid; } // field names should be unique std::set fieldnames; for (const auto& v : GetFields()) { bool duplicated = !fieldnames.emplace(v->GetName()).second; if (duplicated) { AIDL_ERROR(v) << "'" << GetName() << "' has duplicate field name '" << v->GetName() << "'"; success = false; } } // immutable parcelables should have immutable fields. if (IsJavaOnlyImmutable()) { for (const auto& v : GetFields()) { if (!typenames.CanBeJavaOnlyImmutable(v->GetType())) { AIDL_ERROR(v) << "The @JavaOnlyImmutable '" << GetName() << "' has a " << "non-immutable field named '" << v->GetName() << "'."; success = false; } } } // Rust derive fields must be transitive const std::vector rust_derives = RustDerive(); for (const auto& v : GetFields()) { const AidlDefinedType* field = typenames.TryGetDefinedType(v->GetType().GetName()); if (!field) continue; // could get this from CONTEXT_*, but we don't currently save this info when we validated // contexts if (!field->AsStructuredParcelable() && !field->AsUnionDeclaration()) continue; auto subs = field->RustDerive(); for (const std::string& derive : rust_derives) { if (std::find(subs.begin(), subs.end(), derive) == subs.end()) { AIDL_ERROR(v) << "Field " << v->GetName() << " of type with @RustDerive " << derive << " also needs to derive this"; success = false; } } } set constant_names; for (const auto& constant : GetConstantDeclarations()) { if (constant_names.count(constant->GetName()) > 0) { AIDL_ERROR(constant) << "Found duplicate constant name '" << constant->GetName() << "'"; success = false; } constant_names.insert(constant->GetName()); success = success && constant->CheckValid(typenames); } return success; } bool AidlDefinedType::CheckValidForGetterNames() const { bool success = true; std::set getters; for (const auto& v : GetFields()) { bool duplicated = !getters.emplace(v->GetCapitalizedName()).second; if (duplicated) { AIDL_ERROR(v) << "'" << GetName() << "' has duplicate field name '" << v->GetName() << "' after capitalizing the first letter"; success = false; } } return success; } const AidlDefinedType* AidlDefinedType::GetParentType() const { AIDL_FATAL_IF(GetEnclosingScope() == nullptr, this) << "Scope is not set."; return AidlCast(GetEnclosingScope()->GetNode()); } const AidlDefinedType* AidlDefinedType::GetRootType() const { const AidlDefinedType* root = this; for (auto parent = root->GetParentType(); parent; parent = parent->GetParentType()) { root = parent; } return root; } // Resolve `name` in the current scope. If not found, delegate to the parent std::string AidlDefinedType::ResolveName(const std::string& name) const { // For example, in the following, t1's type Baz means x.Foo.Bar.Baz // while t2's type is y.Baz. // package x; // import y.Baz; // parcelable Foo { // parcelable Bar { // enum Baz { ... } // Baz t1; // -> should be x.Foo.Bar.Baz // } // Baz t2; // -> should be y.Baz // Bar.Baz t3; // -> should be x.Foo.Bar.Baz // } AIDL_FATAL_IF(!GetEnclosingScope(), this) << "Type should have an enclosing scope.(e.g. AidlDocument)"; if (AidlTypenames::IsBuiltinTypename(name)) { return name; } const auto first_dot = name.find_first_of('.'); // For "Outer.Inner", we look up "Outer" in the import list. const std::string class_name = (first_dot == std::string::npos) ? name : name.substr(0, first_dot); // Keep ".Inner", to make a fully-qualified name const std::string nested_type = (first_dot == std::string::npos) ? "" : name.substr(first_dot); // check if it is a nested type for (const auto& type : GetNestedTypes()) { if (type->GetName() == class_name) { return type->GetCanonicalName() + nested_type; } } return GetEnclosingScope()->ResolveName(name); } template <> const AidlDefinedType* AidlCast(const AidlNode& node) { struct Visitor : AidlVisitor { const AidlDefinedType* defined_type = nullptr; void Visit(const AidlInterface& t) override { defined_type = &t; } void Visit(const AidlEnumDeclaration& t) override { defined_type = &t; } void Visit(const AidlStructuredParcelable& t) override { defined_type = &t; } void Visit(const AidlUnionDecl& t) override { defined_type = &t; } void Visit(const AidlParcelable& t) override { defined_type = &t; } } v; node.DispatchVisit(v); return v.defined_type; } const AidlDocument& AidlDefinedType::GetDocument() const { const AidlDefinedType* root = GetRootType(); auto scope = root->GetEnclosingScope(); AIDL_FATAL_IF(!scope, this) << "no scope defined."; auto doc = AidlCast(scope->GetNode()); AIDL_FATAL_IF(!doc, this) << "root scope is not a document."; return *doc; } AidlParcelable::AidlParcelable(const AidlLocation& location, const std::string& name, const std::string& package, const Comments& comments, const AidlUnstructuredHeaders& headers, std::vector* type_params, std::vector>* members) : AidlDefinedType(location, name, comments, package, members), AidlParameterizable(type_params), headers_(headers) { // Strip off quotation marks if we actually have headers. if (headers_.cpp.length() >= 2) { headers_.cpp = headers_.cpp.substr(1, headers_.cpp.length() - 2); } if (headers_.ndk.length() >= 2) { headers_.ndk = headers_.ndk.substr(1, headers_.ndk.length() - 2); } if (headers_.rust_type.length() >= 2) { headers_.rust_type = headers_.rust_type.substr(1, headers_.rust_type.length() - 2); } } template bool AidlParameterizable::CheckValid() const { return true; }; template <> bool AidlParameterizable::CheckValid() const { if (!IsGeneric()) { return true; } std::unordered_set set(GetTypeParameters().begin(), GetTypeParameters().end()); if (set.size() != GetTypeParameters().size()) { AIDL_ERROR(this->AsAidlNode()) << "Every type parameter should be unique."; return false; } return true; } bool AidlParcelable::CheckValid(const AidlTypenames& typenames) const { if (!AidlDefinedType::CheckValid(typenames)) { return false; } if (!AidlParameterizable::CheckValid()) { return false; } bool success = true; if (IsFixedSize()) { for (const auto& v : GetFields()) { if (!typenames.CanBeFixedSize(v->GetType())) { AIDL_ERROR(v) << "The @FixedSize parcelable '" << this->GetName() << "' has a " << "non-fixed size field named " << v->GetName() << "."; success = false; } } } return success; } AidlStructuredParcelable::AidlStructuredParcelable( const AidlLocation& location, const std::string& name, const std::string& package, const Comments& comments, std::vector* type_params, std::vector>* members) : AidlParcelable(location, name, package, comments, {} /*headers*/, type_params, members) {} bool AidlStructuredParcelable::CheckValid(const AidlTypenames& typenames) const { if (!AidlParcelable::CheckValid(typenames)) { return false; } bool success = true; if (IsJavaOnlyImmutable()) { // Immutable parcelables provide getters if (!CheckValidForGetterNames()) { success = false; } } return success; } // TODO: we should treat every backend all the same in future. bool AidlTypeSpecifier::LanguageSpecificCheckValid(Options::Language lang) const { if (this->GetName() == "FileDescriptor" && (lang == Options::Language::NDK || lang == Options::Language::RUST)) { AIDL_ERROR(this) << "FileDescriptor isn't supported by the " << to_string(lang) << " backend."; return false; } if (lang != Options::Language::JAVA) { if (this->GetName() == "List" && !this->IsGeneric()) { AIDL_ERROR(this) << "Currently, only the Java backend supports non-generic List."; return false; } if (this->GetName() == "Map" || this->GetName() == "CharSequence") { AIDL_ERROR(this) << "Currently, only Java backend supports " << this->GetName() << "."; return false; } } return true; } // TODO: we should treat every backend all the same in future. bool AidlDefinedType::LanguageSpecificCheckValid(Options::Language lang) const { struct Visitor : AidlVisitor { Visitor(Options::Language lang) : lang(lang) {} void Visit(const AidlTypeSpecifier& type) override { success = success && type.LanguageSpecificCheckValid(lang); } Options::Language lang; bool success = true; } v(lang); VisitTopDown(v, *this); return v.success; } AidlEnumerator::AidlEnumerator(const AidlLocation& location, const std::string& name, AidlConstantValue* value, const Comments& comments) : AidlCommentable(location, comments), name_(name), value_(value), value_user_specified_(value != nullptr) {} bool AidlEnumerator::CheckValid(const AidlTypeSpecifier& enum_backing_type) const { if (GetValue() == nullptr) { return false; } if (!GetValue()->CheckValid()) { return false; } if (GetValue()->ValueString(enum_backing_type, AidlConstantValueDecorator).empty()) { AIDL_ERROR(this) << "Enumerator type differs from enum backing type."; return false; } return true; } string AidlEnumerator::ValueString(const AidlTypeSpecifier& backing_type, const ConstantValueDecorator& decorator) const { return GetValue()->ValueString(backing_type, decorator); } AidlEnumDeclaration::AidlEnumDeclaration(const AidlLocation& location, const std::string& name, std::vector>* enumerators, const std::string& package, const Comments& comments) : AidlDefinedType(location, name, comments, package, nullptr), enumerators_(std::move(*enumerators)) { // Fill missing enumerator values with // This can't be done in Autofill() because type/ref resolution depends on this. // For example, with enum E { A, B = A }, B's value 'A' is a reference which can't be // resolved if A has no value set. const AidlEnumerator* previous = nullptr; for (const auto& enumerator : enumerators_) { if (enumerator->GetValue() == nullptr) { auto loc = enumerator->GetLocation(); if (previous == nullptr) { enumerator->SetValue( std::unique_ptr(AidlConstantValue::Integral(loc, "0"))); } else { auto prev_value = std::make_unique(loc, previous->GetName()); enumerator->SetValue(std::make_unique( loc, std::move(prev_value), "+", std::unique_ptr(AidlConstantValue::Integral(loc, "1")))); } } previous = enumerator.get(); } } bool AidlEnumDeclaration::Autofill(const AidlTypenames& typenames) { if (auto annot = BackingType(); annot != nullptr) { // Autofill() is called before the grand CheckValid(). But AidlAnnotation::ParamValue() // calls AidlConstantValue::evaluate() which requires CheckValid() to be called before. So we // need to call CheckValid(). if (!annot->CheckValid()) { return false; } auto type = annot->ParamValue("type").value(); backing_type_ = typenames.MakeResolvedType(annot->GetLocation(), type, false); } else { // Default to byte type for enums. backing_type_ = typenames.MakeResolvedType(GetLocation(), "byte", false); } // we only support/test a few backing types, so make sure this is a supported // one (otherwise boolean might work, which isn't supported/tested in all // backends) static std::set kBackingTypes = {"byte", "int", "long"}; if (kBackingTypes.find(backing_type_->GetName()) == kBackingTypes.end()) { AIDL_ERROR(this) << "Invalid backing type: " << backing_type_->GetName() << ". Backing type must be one of: " << Join(kBackingTypes, ", "); return false; } return true; } bool AidlEnumDeclaration::CheckValid(const AidlTypenames& typenames) const { if (!AidlDefinedType::CheckValid(typenames)) { return false; } if (!GetMembers().empty()) { AIDL_ERROR(this) << "Enum doesn't support fields/constants/methods."; return false; } if (backing_type_ == nullptr) { AIDL_ERROR(this) << "Enum declaration missing backing type."; return false; } bool success = true; for (const auto& enumerator : enumerators_) { success = success && enumerator->CheckValid(GetBackingType()); } return success; } AidlUnionDecl::AidlUnionDecl(const AidlLocation& location, const std::string& name, const std::string& package, const Comments& comments, std::vector* type_params, std::vector>* members) : AidlParcelable(location, name, package, comments, {} /*headers*/, type_params, members) {} bool AidlUnionDecl::CheckValid(const AidlTypenames& typenames) const { // visit parents if (!AidlParcelable::CheckValid(typenames)) { return false; } // unions provide getters always if (!CheckValidForGetterNames()) { return false; } // now, visit self! bool success = true; // TODO(b/170807936) do we need to allow ParcelableHolder in union? for (const auto& v : GetFields()) { if (v->GetType().GetName() == "ParcelableHolder") { AIDL_ERROR(*v) << "A union can't have a member of ParcelableHolder '" << v->GetName() << "'"; success = false; } } if (GetFields().empty()) { AIDL_ERROR(*this) << "The union '" << this->GetName() << "' has no fields."; return false; } // first member should have useful default value (implicit or explicit) const auto& first = GetFields()[0]; if (!first->HasUsefulDefaultValue()) { // Most types can be initialized without a default value. For example, // interface types are inherently nullable. But, enum types should have // an explicit default value. if (!first->GetType().IsArray() && typenames.GetEnumDeclaration(first->GetType())) { AIDL_ERROR(first) << "The union's first member should have a useful default value. Enum types can be " "initialized with a reference. (e.g. ... = MyEnum.FOO;)"; return false; } // In Java, array types are initialized as null without a default value. To be sure that default // initialized unions are accepted by other backends we require arrays also have a default // value. if (first->GetType().IsArray()) { AIDL_ERROR(first) << "The union's first member should have a useful default value. Arrays can be " "initialized with values(e.g. ... = { values... };) or marked as @nullable."; return false; } } return success; } AidlInterface::AidlInterface(const AidlLocation& location, const std::string& name, const Comments& comments, bool oneway, const std::string& package, std::vector>* members) : AidlDefinedType(location, name, comments, package, members), oneway_annotation_(oneway) { for (auto& m : GetMethods()) { m.get()->ApplyInterfaceOneway(oneway); } } bool AidlInterface::CheckValid(const AidlTypenames& typenames) const { if (!AidlDefinedType::CheckValid(typenames)) { return false; } // Has to be a pointer due to deleting copy constructor. No idea why. map method_names; for (const auto& m : GetMethods()) { if (!m->CheckValid(typenames)) { return false; } auto it = method_names.find(m->GetName()); // prevent duplicate methods if (it == method_names.end()) { method_names[m->GetName()] = m.get(); } else { AIDL_ERROR(m) << "attempt to redefine method " << m->GetName() << ":"; AIDL_ERROR(it->second) << "previously defined here."; return false; } static set reserved_methods{"asBinder()", "getInterfaceHash()", "getInterfaceVersion()", "getTransactionName(int)"}; if (reserved_methods.find(m->Signature()) != reserved_methods.end()) { AIDL_ERROR(m) << " method " << m->Signature() << " is reserved for internal use."; return false; } if (!CheckValidPermissionAnnotations(*m.get())) { return false; } } return true; } bool AidlInterface::CheckValidPermissionAnnotations(const AidlMethod& m) const { if (IsPermissionAnnotated() && m.GetType().IsPermissionAnnotated()) { AIDL_ERROR(m) << "The interface " << GetName() << " uses a permission annotation but the method " << m.GetName() << " is also annotated.\n" << "Consider distributing the annotation to each method."; return false; } return true; } bool AidlInterface::UsesPermissions() const { if (EnforceExpression()) { return true; } for (auto& m : GetMethods()) { if (m->GetType().EnforceExpression()) { return true; } } return false; } std::string AidlInterface::GetDescriptor() const { std::string annotatedDescriptor = AidlAnnotatable::GetDescriptor(); if (annotatedDescriptor != "") { return annotatedDescriptor; } return GetCanonicalName(); } AidlDocument::AidlDocument(const AidlLocation& location, const Comments& comments, std::vector imports, std::vector> defined_types, bool is_preprocessed) : AidlCommentable(location, comments), AidlScope(this), imports_(std::move(imports)), defined_types_(std::move(defined_types)), is_preprocessed_(is_preprocessed) { for (const auto& t : defined_types_) { t->SetEnclosingScope(this); } } // Resolves type name in the current document. // - built-in types // - imported types // - top-level type std::string AidlDocument::ResolveName(const std::string& name) const { if (AidlTypenames::IsBuiltinTypename(name)) { return name; } const auto first_dot = name.find_first_of('.'); // For "Outer.Inner", we look up "Outer" in the import list. const std::string class_name = (first_dot == std::string::npos) ? name : name.substr(0, first_dot); // Keep ".Inner", to make a fully-qualified name const std::string nested_type = (first_dot == std::string::npos) ? "" : name.substr(first_dot); for (const auto& import : Imports()) { if (SimpleName(import) == class_name) { return import + nested_type; } } // check if it is a top-level type. for (const auto& type : DefinedTypes()) { if (type->GetName() == class_name) { return type->GetCanonicalName() + nested_type; } } // name itself might be fully-qualified name. return name; } ./PaxHeaders.X/aidl_language.h0100644 0000000 0000000 00000000034 15172120304 015221 xustar000000000 0000000 28 mtime=1776853188.2860000 aidl_language.h0100644 0000000 0000000 00000146306 15172120304 012537 0ustar000000000 0000000 /* * Copyright (C) 2019, 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. */ #pragma once #include #include #include #include #include #include #include #include #include "aidl_typenames.h" #include "code_writer.h" #include "comments.h" #include "diagnostics.h" #include "io_delegate.h" #include "location.h" #include "logging.h" #include "options.h" #include "permission.h" using android::aidl::AidlTypenames; using android::aidl::CodeWriter; using android::aidl::Comments; using android::aidl::Options; using android::base::Result; using std::shared_ptr; using std::string; using std::unique_ptr; using std::vector; class AidlNode; // helper to see if T is the same to one of Args types. template struct is_one_of : std::false_type {}; template struct is_one_of { enum { value = std::is_same_v || is_one_of::value }; }; // helper to see if T is std::vector of something. template struct is_vector : std::false_type {}; template struct is_vector> : std::true_type {}; // helper for static_assert(false) template struct unsupported_type : std::false_type {}; namespace android { namespace aidl { namespace mappings { std::string dump_location(const AidlNode& method); } // namespace mappings namespace java { std::string dump_location(const AidlNode& method); } // namespace java } // namespace aidl } // namespace android bool ParseFloating(std::string_view sv, double* parsed); bool ParseFloating(std::string_view sv, float* parsed); class AidlDocument; class AidlInterface; class AidlParcelable; class AidlStructuredParcelable; class AidlEnumDeclaration; class AidlUnionDecl; class AidlVariableDeclaration; class AidlConstantDeclaration; class AidlEnumerator; class AidlMethod; class AidlArgument; class AidlConstantValue; class AidlConstantReference; class AidlUnaryConstExpression; class AidlBinaryConstExpression; class AidlAnnotation; // Interface for visitors that can traverse AidlTraversable nodes. class AidlVisitor { public: virtual ~AidlVisitor() = default; virtual void Visit(const AidlDocument&) {} virtual void Visit(const AidlInterface&) {} virtual void Visit(const AidlParcelable&) {} virtual void Visit(const AidlStructuredParcelable&) {} virtual void Visit(const AidlUnionDecl&) {} virtual void Visit(const AidlEnumDeclaration&) {} virtual void Visit(const AidlEnumerator&) {} virtual void Visit(const AidlMethod&) {} virtual void Visit(const AidlVariableDeclaration&) {} virtual void Visit(const AidlConstantDeclaration&) {} virtual void Visit(const AidlArgument&) {} virtual void Visit(const AidlTypeSpecifier&) {} virtual void Visit(const AidlConstantValue&) {} virtual void Visit(const AidlConstantReference&) {} virtual void Visit(const AidlUnaryConstExpression&) {} virtual void Visit(const AidlBinaryConstExpression&) {} virtual void Visit(const AidlAnnotation&) {} }; class AidlScope { public: AidlScope(const AidlNode* self) : self_(self) {} virtual ~AidlScope() = default; virtual std::string ResolveName(const std::string& name) const = 0; void SetEnclosingScope(const AidlScope* enclosing) { AIDL_FATAL_IF(enclosing_, AIDL_LOCATION_HERE) << "SetEnclosingScope can be set only once."; enclosing_ = enclosing; } const AidlScope* GetEnclosingScope() const { return enclosing_; } const AidlNode& GetNode() const { return *self_; } private: const AidlNode* self_; const AidlScope* enclosing_ = nullptr; }; // Anything that is locatable in a .aidl file. class AidlNode { public: AidlNode(const AidlLocation& location, const Comments& comments = {}); virtual ~AidlNode(); AidlNode(AidlNode&) = delete; AidlNode& operator=(AidlNode&) = delete; AidlNode(AidlNode&&) = delete; AidlNode& operator=(AidlNode&&) = delete; // To be able to print AidlLocation friend class AidlErrorLog; friend std::string android::aidl::mappings::dump_location(const AidlNode&); friend std::string android::aidl::java::dump_location(const AidlNode&); const AidlLocation& GetLocation() const { return location_; } virtual void TraverseChildren(std::function traverse) const = 0; virtual void DispatchVisit(AidlVisitor&) const = 0; const Comments& GetComments() const { return comments_; } void PrependComments(const Comments& comments) { comments_.insert(comments_.begin(), comments.begin(), comments.end()); } static void ClearUnvisitedNodes(); static const std::vector& GetLocationsOfUnvisitedNodes(); void MarkVisited() const; bool IsUserDefined() const { return !GetLocation().IsInternal(); } private: std::string PrintLine() const; std::string PrintLocation() const; const AidlLocation location_; Comments comments_; // make sure we are able to abort if types are not visited mutable bool visited_ = false; static std::vector unvisited_locations_; }; // unique_ptr for type arugment, // std::string for type parameter(T, U, and so on). template class AidlParameterizable { public: AidlParameterizable(std::vector* type_params) : type_params_(type_params) {} virtual ~AidlParameterizable() = default; bool IsGeneric() const { return type_params_ != nullptr; } const std::vector& GetTypeParameters() const { return *type_params_; } bool CheckValid() const; __attribute__((warn_unused_result)) bool SetTypeParameters(std::vector* type_params) { if (type_params_) return false; type_params_.reset(type_params); return true; } virtual const AidlNode& AsAidlNode() const = 0; private: unique_ptr> type_params_; static_assert(std::is_same>::value || std::is_same::value); }; template <> bool AidlParameterizable::CheckValid() const; class AidlCommentable : public AidlNode { public: AidlCommentable(const AidlLocation& location, const Comments& comments) : AidlNode(location, comments) {} virtual ~AidlCommentable() = default; bool IsHidden() const; bool IsDeprecated() const; }; // Transforms a value string into a language specific form. Raw value as produced by // AidlConstantValue. using ConstantValueDecorator = std::function>& raw_value)>; class AidlAnnotation : public AidlNode { public: enum class Type { BACKING = 1, JAVA_STABLE_PARCELABLE, NDK_STABLE_PARCELABLE, RUST_STABLE_PARCELABLE, UNSUPPORTED_APP_USAGE, VINTF_STABILITY, NULLABLE, UTF8_IN_CPP, SENSITIVE_DATA, JAVA_PASSTHROUGH, JAVA_DERIVE, JAVA_DEFAULT, JAVA_DELEGATOR, JAVA_ONLY_IMMUTABLE, JAVA_SUPPRESS_LINT, FIXED_SIZE, DESCRIPTOR, RUST_DERIVE, SUPPRESS_WARNINGS, PERMISSION_ENFORCE, PERMISSION_NONE, PERMISSION_MANUAL, PROPAGATE_ALLOW_BLOCKING, }; using TargetContext = uint16_t; static constexpr TargetContext CONTEXT_TYPE_INTERFACE = 0x1 << 0; static constexpr TargetContext CONTEXT_TYPE_ENUM = 0x1 << 1; static constexpr TargetContext CONTEXT_TYPE_STRUCTURED_PARCELABLE = 0x1 << 2; static constexpr TargetContext CONTEXT_TYPE_UNION = 0x1 << 3; static constexpr TargetContext CONTEXT_TYPE_UNSTRUCTURED_PARCELABLE = 0x1 << 4; static constexpr TargetContext CONTEXT_TYPE = CONTEXT_TYPE_INTERFACE | CONTEXT_TYPE_ENUM | CONTEXT_TYPE_STRUCTURED_PARCELABLE | CONTEXT_TYPE_UNION | CONTEXT_TYPE_UNSTRUCTURED_PARCELABLE; static constexpr TargetContext CONTEXT_CONST = 0x1 << 5; static constexpr TargetContext CONTEXT_FIELD = 0x1 << 6; static constexpr TargetContext CONTEXT_METHOD = 0x1 << 7; static constexpr TargetContext CONTEXT_MEMBER = CONTEXT_CONST | CONTEXT_FIELD | CONTEXT_METHOD; static constexpr TargetContext CONTEXT_TYPE_SPECIFIER = 0x1 << 8; static constexpr TargetContext CONTEXT_ALL = CONTEXT_TYPE | CONTEXT_MEMBER | CONTEXT_TYPE_SPECIFIER; static std::string TypeToString(Type type); static std::unique_ptr Parse( const AidlLocation& location, const string& name, std::map> parameter_list, const Comments& comments); virtual ~AidlAnnotation() = default; bool CheckValid() const; bool CheckContext(TargetContext context) const; const string& GetName() const { return schema_.name; } const Type& GetType() const { return schema_.type; } bool Repeatable() const { return schema_.repeatable; } // ToString is for dumping AIDL. // Returns string representation of this annotation. // e.g) "@RustDerive(Clone=true, Copy=true)" string ToString() const; template std::optional ParamValue(const std::string& param_name) const; std::map AnnotationParams( const ConstantValueDecorator& decorator) const; void TraverseChildren(std::function traverse) const override; void DispatchVisit(AidlVisitor& v) const override { v.Visit(*this); } Result> EnforceExpression() const; private: struct ParamTypeDetails { std::string name; const AidlTypeSpecifier& type; bool required = false; }; struct Schema { AidlAnnotation::Type type; std::string name; TargetContext target_context; std::vector parameters; bool repeatable = false; const ParamTypeDetails* ParamType(const std::string& name) const { for (const auto& param : parameters) { if (param.name == name) { return ¶m; } } return nullptr; } }; static const std::vector& AllSchemas(); AidlAnnotation(const AidlLocation& location, const Schema& schema, std::map> parameters, const Comments& comments); const Schema& schema_; std::map> parameters_; }; static inline bool operator<(const AidlAnnotation& lhs, const AidlAnnotation& rhs) { return lhs.GetName() < rhs.GetName(); } static inline bool operator==(const AidlAnnotation& lhs, const AidlAnnotation& rhs) { return lhs.GetName() == rhs.GetName(); } class AidlAnnotatable : public AidlCommentable { public: AidlAnnotatable(const AidlLocation& location, const Comments& comments); virtual ~AidlAnnotatable() = default; void Annotate(vector>&& annotations) { for (auto i = annotations.rbegin(); i != annotations.rend(); ++i) { // TODO: we may want to mark all comments as "unoutputed" // in the lexer phase, and then verify after successful backend // output that every comment is "emitted". If we do this, we would // need to move rather than copy the comments here. PrependComments((*i)->GetComments()); } for (auto& annotation : annotations) { annotations_.emplace_back(std::move(annotation)); } } bool IsNullable() const; bool IsHeapNullable() const; bool IsUtf8InCpp() const; bool IsSensitiveData() const; bool IsVintfStability() const; bool IsJavaOnlyImmutable() const; bool IsFixedSize() const; bool IsStableApiParcelable(Options::Language lang) const; bool JavaDerive(const std::string& method) const; bool IsJavaDefault() const; bool IsJavaDelegator() const; std::string GetDescriptor() const; const AidlAnnotation* UnsupportedAppUsage() const; std::vector RustDerive() const; const AidlAnnotation* BackingType() const; std::vector SuppressWarnings() const; std::unique_ptr EnforceExpression() const; bool IsPermissionManual() const; bool IsPermissionNone() const; bool IsPermissionAnnotated() const; bool IsPropagateAllowBlocking() const; // ToString is for dumping AIDL. // Returns string representation of annotations. // e.g) "@JavaDerive(toString=true) @RustDerive(Clone=true, Copy=true)" std::string ToString() const; const vector>& GetAnnotations() const { return annotations_; } bool CheckValid(const AidlTypenames&) const; void TraverseChildren(std::function traverse) const override { for (const auto& annot : GetAnnotations()) { traverse(*annot); } } private: vector> annotations_; }; // Represents `[]` struct DynamicArray {}; // Represents `[N][M]..` struct FixedSizeArray { FixedSizeArray(std::unique_ptr dim) { dimensions.push_back(std::move(dim)); } std::vector> dimensions; std::vector GetDimensionInts() const; }; // Represents `[]` or `[N]` part of type specifier using ArrayType = std::variant; // AidlTypeSpecifier represents a reference to either a built-in type, // a defined type, or a variant (e.g., array of generic) of a type. class AidlTypeSpecifier final : public AidlAnnotatable, public AidlParameterizable> { public: AidlTypeSpecifier(const AidlLocation& location, const string& unresolved_name, std::optional array, vector>* type_params, const Comments& comments); virtual ~AidlTypeSpecifier() = default; // View of this type which has one-less dimension(s). // e.g.) T[] => T, T[N][M] => T[M] void ViewAsArrayBase(std::function func) const; // ViewAsArrayBase passes "mutated" type to its callback. bool IsMutated() const { return mutated_; } // Returns the full-qualified name of the base type. // int -> int // int[] -> int // List -> List // IFoo -> foo.bar.IFoo (if IFoo is in package foo.bar) const string& GetName() const { if (IsResolved()) { return fully_qualified_name_; } else { return GetUnresolvedName(); } } // ToString is for dumping AIDL. // Returns string representation of this type specifier including annotations. // This is "annotations type_name type_params? array_marker?". // e.g) "@utf8InCpp String[]"; std::string ToString() const; // Signature is for comparing AIDL types. // Returns string representation of this type specifier. // This is "type_name type_params? array_marker?". // e.g.) "String[]" (even if it is annotated with @utf8InCpp) std::string Signature() const; const string& GetUnresolvedName() const { return unresolved_name_; } const std::vector GetSplitName() const { return split_name_; } bool IsResolved() const { return fully_qualified_name_ != ""; } bool IsArray() const { return array_.has_value(); } bool IsDynamicArray() const { return array_.has_value() && std::get_if(&*array_) != nullptr; } bool IsFixedSizeArray() const { return array_.has_value() && std::get_if(&*array_) != nullptr; } std::vector GetFixedSizeArrayDimensions() const; const ArrayType& GetArray() const { AIDL_FATAL_IF(!array_.has_value(), this) << "GetArray() for non-array type"; return array_.value(); } // Accept transitions from // T to T[] // or T to T[N] // or T[N] to T[N][M] __attribute__((warn_unused_result)) bool MakeArray(ArrayType array_type); // Resolve the base type name to a fully-qualified name. Return false if the // resolution fails. bool Resolve(const AidlTypenames& typenames, const AidlScope* scope); bool CheckValid(const AidlTypenames& typenames) const; bool LanguageSpecificCheckValid(Options::Language lang) const; const AidlNode& AsAidlNode() const override { return *this; } const AidlDefinedType* GetDefinedType() const; void TraverseChildren(std::function traverse) const override; void DispatchVisit(AidlVisitor& v) const override { v.Visit(*this); } private: const string unresolved_name_; string fully_qualified_name_; mutable std::optional array_; mutable bool mutated_ = false; // ViewAsArrayBase() sets this as true to distinguish mutated one // from the original type vector split_name_; const AidlDefinedType* defined_type_ = nullptr; // set when Resolve() for defined types }; // Returns the universal value unaltered. std::string AidlConstantValueDecorator( const AidlTypeSpecifier& type, const std::variant>& raw_value); class AidlMember : public AidlAnnotatable { public: AidlMember(const AidlLocation& location, const Comments& comments); virtual ~AidlMember() = default; // non-copyable, non-movable AidlMember(const AidlMember&) = delete; AidlMember(AidlMember&&) = delete; AidlMember& operator=(const AidlMember&) = delete; AidlMember& operator=(AidlMember&&) = delete; void MarkNew() { new_ = true; } bool IsNew() const { return new_; } private: bool new_ = false; }; // TODO: This class is used for method arguments and also parcelable fields, // and it should be split up since default values don't apply to method // arguments class AidlVariableDeclaration : public AidlMember { public: AidlVariableDeclaration(const AidlLocation& location, AidlTypeSpecifier* type, const std::string& name); AidlVariableDeclaration(const AidlLocation& location, AidlTypeSpecifier* type, const std::string& name, AidlConstantValue* default_value); virtual ~AidlVariableDeclaration() = default; // non-copyable, non-movable AidlVariableDeclaration(const AidlVariableDeclaration&) = delete; AidlVariableDeclaration(AidlVariableDeclaration&&) = delete; AidlVariableDeclaration& operator=(const AidlVariableDeclaration&) = delete; AidlVariableDeclaration& operator=(AidlVariableDeclaration&&) = delete; std::string GetName() const { return name_; } std::string GetCapitalizedName() const; const AidlTypeSpecifier& GetType() const { return *type_; } // if this was constructed explicitly with a default value bool IsDefaultUserSpecified() const { return default_user_specified_; } // will return the default value this is constructed with or a default value // if one is available const AidlConstantValue* GetDefaultValue() const { return default_value_.get(); } bool HasUsefulDefaultValue() const; AidlTypeSpecifier* GetMutableType() { return type_.get(); } bool CheckValid(const AidlTypenames& typenames) const; // ToString is for dumping AIDL. // Returns string representation of this variable decl including default value. // This is "annotations type name default_value?". // e.g) "@utf8InCpp String[] names = {"hello"}" std::string ToString() const; // Signature is for comparing AIDL types. // Returns string representation of this variable decl. // This is "type name". // e.g) "String[] name" (even if it is annotated with @utf8InCpp and has a default value.) std::string Signature() const; std::string ValueString(const ConstantValueDecorator& decorator) const; void TraverseChildren(std::function traverse) const override; void DispatchVisit(AidlVisitor& v) const override { v.Visit(*this); } private: std::unique_ptr type_; std::string name_; bool default_user_specified_; std::unique_ptr default_value_; }; class AidlArgument : public AidlVariableDeclaration { public: enum Direction { IN_DIR = 1, OUT_DIR = 2, INOUT_DIR = 3 }; AidlArgument(const AidlLocation& location, AidlArgument::Direction direction, AidlTypeSpecifier* type, const std::string& name); AidlArgument(const AidlLocation& location, AidlTypeSpecifier* type, const std::string& name); virtual ~AidlArgument() = default; // non-copyable, non-movable AidlArgument(const AidlArgument&) = delete; AidlArgument(AidlArgument&&) = delete; AidlArgument& operator=(const AidlArgument&) = delete; AidlArgument& operator=(AidlArgument&&) = delete; Direction GetDirection() const { return direction_; } bool IsOut() const { return direction_ & OUT_DIR; } bool IsIn() const { return direction_ & IN_DIR; } bool DirectionWasSpecified() const { return direction_specified_; } string GetDirectionSpecifier() const; bool CheckValid(const AidlTypenames& typenames) const; // ToString is for dumping AIDL. // Returns string representation of this argument including direction // This is "direction annotations type name". // e.g) "in @utf8InCpp String[] names" std::string ToString() const; void DispatchVisit(AidlVisitor& v) const override { v.Visit(*this); } private: Direction direction_; bool direction_specified_; }; struct ArgumentAspect { std::string name; std::set possible_directions; }; class AidlUnaryConstExpression; class AidlBinaryConstExpression; class AidlConstantReference; class AidlConstantValue : public AidlNode { public: enum class Type { // WARNING: Don't change this order! The order is used to determine type // promotion during a binary expression. BOOLEAN, INT8, INT32, INT64, ARRAY, CHARACTER, STRING, REF, FLOATING, UNARY, BINARY, ERROR, }; // Returns the evaluated value. T> should match to the actual type. template T EvaluatedValue() const { is_evaluated_ || (CheckValid() && evaluate()); AIDL_FATAL_IF(!is_valid_, this); if constexpr (is_vector::value) { AIDL_FATAL_IF(final_type_ != Type::ARRAY, this); T result; for (const auto& v : values_) { result.push_back(v->EvaluatedValue()); } return result; } else if constexpr (is_one_of::value) { AIDL_FATAL_IF(final_type_ != Type::FLOATING, this); T result; AIDL_FATAL_IF(!ParseFloating(value_, &result), this); return result; } else if constexpr (std::is_same::value) { AIDL_FATAL_IF(final_type_ != Type::STRING, this); return final_string_value_.substr(1, final_string_value_.size() - 2); // unquote " } else if constexpr (is_one_of::value) { AIDL_FATAL_IF(final_type_ < Type::INT8 && final_type_ > Type::INT64, this); return static_cast(final_value_); } else if constexpr (std::is_same::value) { AIDL_FATAL_IF(final_type_ != Type::CHARACTER, this); return final_string_value_.at(1); // unquote ' } else if constexpr (std::is_same::value) { static_assert(std::is_same::value, ".."); AIDL_FATAL_IF(final_type_ != Type::BOOLEAN, this); return final_value_ != 0; } else { static_assert(unsupported_type::value); } } virtual ~AidlConstantValue() = default; // non-copyable, non-movable AidlConstantValue(const AidlConstantValue&) = delete; AidlConstantValue(AidlConstantValue&&) = delete; AidlConstantValue& operator=(const AidlConstantValue&) = delete; AidlConstantValue& operator=(AidlConstantValue&&) = delete; // creates default value, when one isn't specified // nullptr if no default available static AidlConstantValue* Default(const AidlTypeSpecifier& specifier); static AidlConstantValue* Boolean(const AidlLocation& location, bool value); static AidlConstantValue* Character(const AidlLocation& location, const std::string& value); // example: 123, -5498, maybe any size static AidlConstantValue* Integral(const AidlLocation& location, const std::string& value); static AidlConstantValue* Floating(const AidlLocation& location, const std::string& value); static AidlConstantValue* Array(const AidlLocation& location, std::unique_ptr>> values); // example: "\"asdf\"" static AidlConstantValue* String(const AidlLocation& location, const string& value); Type GetType() const { return final_type_; } const std::string& Literal() const { return value_; } bool Evaluate() const; virtual bool CheckValid() const; // Raw value of type (currently valid in C++ and Java). Empty string on error. string ValueString(const AidlTypeSpecifier& type, const ConstantValueDecorator& decorator) const; void TraverseChildren(std::function traverse) const override { if (type_ == Type::ARRAY) { for (const auto& v : values_) { traverse(*v); } } } void DispatchVisit(AidlVisitor& visitor) const override { visitor.Visit(*this); } size_t Size() const { return values_.size(); } const AidlConstantValue& ValueAt(size_t index) const { return *values_.at(index); } static string ToString(Type type); private: AidlConstantValue(const AidlLocation& location, Type parsed_type, int64_t parsed_value, const string& checked_value); AidlConstantValue(const AidlLocation& location, Type type, const string& checked_value); AidlConstantValue(const AidlLocation& location, Type type, std::unique_ptr>> values, const std::string& value); static bool ParseIntegral(const string& value, int64_t* parsed_value, Type* parsed_type); static bool IsHex(const string& value); virtual bool evaluate() const; bool IsLiteral() const; const Type type_ = Type::ERROR; const vector> values_; // if type_ == ARRAY const string value_; // otherwise // State for tracking evaluation of expressions mutable bool is_valid_ = false; // cache of CheckValid, but may be marked false in evaluate mutable bool is_evaluated_ = false; // whether evaluate has been called mutable Type final_type_; mutable int64_t final_value_; mutable string final_string_value_ = ""; friend AidlUnaryConstExpression; friend AidlBinaryConstExpression; friend AidlConstantReference; }; // Represents "." which resolves to a constant which is one of // - constant declaration // - enumerator // When a is missing, is of the enclosing type. class AidlConstantReference : public AidlConstantValue { public: AidlConstantReference(const AidlLocation& location, const std::string& value); const std::unique_ptr& GetRefType() const { return ref_type_; } const std::string& GetFieldName() const { return field_name_; } bool CheckValid() const override; void TraverseChildren(std::function traverse) const override { if (ref_type_) { traverse(*ref_type_); } } void DispatchVisit(AidlVisitor& v) const override { v.Visit(*this); } const AidlConstantValue* Resolve(const AidlDefinedType* scope) const; private: bool evaluate() const override; std::unique_ptr ref_type_; std::string field_name_; mutable const AidlConstantValue* resolved_ = nullptr; }; class AidlUnaryConstExpression : public AidlConstantValue { public: AidlUnaryConstExpression(const AidlLocation& location, const string& op, std::unique_ptr rval); static bool IsCompatibleType(Type type, const string& op); bool CheckValid() const override; void TraverseChildren(std::function traverse) const override { traverse(*unary_); } void DispatchVisit(AidlVisitor& v) const override { v.Visit(*this); } const std::unique_ptr& Val() const { return unary_; } const std::string& Op() const { return op_; } private: bool evaluate() const override; std::unique_ptr unary_; const string op_; }; class AidlBinaryConstExpression : public AidlConstantValue { public: AidlBinaryConstExpression(const AidlLocation& location, std::unique_ptr lval, const string& op, std::unique_ptr rval); bool CheckValid() const override; static bool AreCompatibleOperandTypes(Type t1, Type t2); static bool AreCompatibleArrayTypes(Type t1, Type t2); // Returns the promoted kind for both operands static Type UsualArithmeticConversion(Type left, Type right); // Returns the promoted integral type where INT32 is the smallest type static Type IntegralPromotion(Type in); void TraverseChildren(std::function traverse) const override { traverse(*left_val_); traverse(*right_val_); } void DispatchVisit(AidlVisitor& v) const override { v.Visit(*this); } const std::unique_ptr& Left() const { return left_val_; } const std::unique_ptr& Right() const { return right_val_; } const std::string& Op() const { return op_; } private: bool evaluate() const override; std::unique_ptr left_val_; std::unique_ptr right_val_; const string op_; }; struct AidlAnnotationParameter { std::string name; std::unique_ptr value; }; class AidlConstantDeclaration : public AidlMember { public: AidlConstantDeclaration(const AidlLocation& location, AidlTypeSpecifier* specifier, const string& name, AidlConstantValue* value); virtual ~AidlConstantDeclaration() = default; // non-copyable, non-movable AidlConstantDeclaration(const AidlConstantDeclaration&) = delete; AidlConstantDeclaration(AidlConstantDeclaration&&) = delete; AidlConstantDeclaration& operator=(const AidlConstantDeclaration&) = delete; AidlConstantDeclaration& operator=(AidlConstantDeclaration&&) = delete; const AidlTypeSpecifier& GetType() const { return *type_; } AidlTypeSpecifier* GetMutableType() { return type_.get(); } const string& GetName() const { return name_; } const AidlConstantValue& GetValue() const { return *value_; } bool CheckValid(const AidlTypenames& typenames) const; // ToString is for dumping AIDL. // Returns string representation of this const decl including a const value. // This is "`const` annotations type name value". // e.g) "const @utf8InCpp String[] names = { "hello" }" string ToString() const; // Signature is for comparing types. // Returns string representation of this const decl. // This is "direction annotations type name". // e.g) "String[] names" string Signature() const; string ValueString(const ConstantValueDecorator& decorator) const { return value_->ValueString(GetType(), decorator); } void TraverseChildren(std::function traverse) const override { traverse(GetType()); traverse(GetValue()); } void DispatchVisit(AidlVisitor& v) const override { v.Visit(*this); } private: const unique_ptr type_; const string name_; unique_ptr value_; }; class AidlMethod : public AidlMember { public: AidlMethod(const AidlLocation& location, bool oneway, AidlTypeSpecifier* type, const string& name, vector>* args, const Comments& comments); AidlMethod(const AidlLocation& location, bool oneway, AidlTypeSpecifier* type, const string& name, vector>* args, const Comments& comments, int id); virtual ~AidlMethod() = default; // non-copyable, non-movable AidlMethod(const AidlMethod&) = delete; AidlMethod(AidlMethod&&) = delete; AidlMethod& operator=(const AidlMethod&) = delete; AidlMethod& operator=(AidlMethod&&) = delete; bool CheckValid(const AidlTypenames&) const; const AidlTypeSpecifier& GetType() const { return *type_; } AidlTypeSpecifier* GetMutableType() { return type_.get(); } // set if this method is part of an interface that is marked oneway void ApplyInterfaceOneway(bool oneway) { oneway_ = oneway_ || oneway; } bool IsOneway() const { return oneway_; } bool HasOnewayAnnotation() const { return oneway_annotation_; } const std::string& GetName() const { return name_; } bool HasId() const { return has_id_; } int GetId() const { return id_; } // TODO: Set is errorprone, what if it was set before? void SetId(unsigned id) { id_ = id; } const std::vector>& GetArguments() const { return arguments_; } // An inout parameter will appear in both GetInArguments() // and GetOutArguments(). AidlMethod retains ownership of the argument // pointers returned in this way. const std::vector& GetInArguments() const { return in_arguments_; } const std::vector& GetOutArguments() const { return out_arguments_; } // ToString is for dumping AIDL. // Returns string representation of this method including everything. // This is "ret_type name ( arg_list ) = id". // e.g) "boolean foo(int, @Nullable String) = 1" std::string ToString() const; // Signature is for comparing AIDL types. // Returns string representation of this method's name & type. // e.g) "foo(int, String)" std::string Signature() const; void TraverseChildren(std::function traverse) const override { traverse(GetType()); for (const auto& a : GetArguments()) { traverse(*a); } } void DispatchVisit(AidlVisitor& v) const override { v.Visit(*this); } private: // oneway_ may be set by the method or the parent interface. If the interface is oneway, // is also oneway. oneway_annotation_ may only be set on creation, and may not be overridden // by the parent interface. It is used to detect redundant oneway annotations. bool oneway_; bool oneway_annotation_; std::unique_ptr type_; std::string name_; const std::vector> arguments_; std::vector in_arguments_; std::vector out_arguments_; bool has_id_; int id_; }; // AidlDefinedType represents either an interface, parcelable, or enum that is // defined in the source file. class AidlDefinedType : public AidlMember, public AidlScope { public: AidlDefinedType(const AidlLocation& location, const std::string& name, const Comments& comments, const std::string& package, std::vector>* members); virtual ~AidlDefinedType() = default; // non-copyable, non-movable AidlDefinedType(const AidlDefinedType&) = delete; AidlDefinedType(AidlDefinedType&&) = delete; AidlDefinedType& operator=(const AidlDefinedType&) = delete; AidlDefinedType& operator=(AidlDefinedType&&) = delete; const std::string& GetName() const { return name_; }; std::string ResolveName(const std::string& name) const override; /* dot joined package, example: "android.package.foo" */ std::string GetPackage() const { return package_; } /* dot joined package and name, example: "android.package.foo.IBar" */ std::string GetCanonicalName() const; std::vector GetSplitPackage() const { if (package_.empty()) return std::vector(); return android::base::Split(package_, "."); } const AidlDocument& GetDocument() const; virtual std::string GetPreprocessDeclarationName() const = 0; virtual const AidlStructuredParcelable* AsStructuredParcelable() const { return nullptr; } virtual const AidlParcelable* AsParcelable() const { return nullptr; } virtual const AidlEnumDeclaration* AsEnumDeclaration() const { return nullptr; } virtual const AidlUnionDecl* AsUnionDeclaration() const { return nullptr; } virtual const AidlInterface* AsInterface() const { return nullptr; } virtual const AidlParameterizable* AsParameterizable() const { return nullptr; } virtual bool CheckValid(const AidlTypenames& typenames) const; bool LanguageSpecificCheckValid(Options::Language lang) const; AidlStructuredParcelable* AsStructuredParcelable() { return const_cast( const_cast(this)->AsStructuredParcelable()); } AidlParcelable* AsParcelable() { return const_cast(const_cast(this)->AsParcelable()); } AidlEnumDeclaration* AsEnumDeclaration() { return const_cast( const_cast(this)->AsEnumDeclaration()); } AidlUnionDecl* AsUnionDeclaration() { return const_cast( const_cast(this)->AsUnionDeclaration()); } AidlInterface* AsInterface() { return const_cast(const_cast(this)->AsInterface()); } AidlParameterizable* AsParameterizable() { return const_cast*>( const_cast(this)->AsParameterizable()); } const AidlParcelable* AsUnstructuredParcelable() const { if (this->AsStructuredParcelable() != nullptr) return nullptr; if (this->AsUnionDeclaration() != nullptr) return nullptr; return this->AsParcelable(); } AidlParcelable* AsUnstructuredParcelable() { return const_cast( const_cast(this)->AsUnstructuredParcelable()); } const AidlDefinedType* GetParentType() const; const AidlDefinedType* GetRootType() const; const std::vector>& GetNestedTypes() const { return types_; } const std::vector>& GetFields() const { return variables_; } const std::vector>& GetConstantDeclarations() const { return constants_; } const std::vector>& GetMethods() const { return methods_; } const std::vector& GetMembers() const { return members_; } void TraverseChildren(std::function traverse) const override { AidlAnnotatable::TraverseChildren(traverse); for (const auto c : GetMembers()) { traverse(*c); } } // Modifiers void AddMethod(std::unique_ptr method) { members_.push_back(method.get()); methods_.push_back(std::move(method)); } void AddType(std::unique_ptr type) { type->SetEnclosingScope(this); members_.push_back(type.get()); types_.push_back(std::move(type)); } protected: // utility for subclasses with getter names bool CheckValidForGetterNames() const; private: bool CheckValidWithMembers(const AidlTypenames& typenames) const; std::string name_; std::string package_; std::vector> variables_; std::vector> constants_; std::vector> methods_; std::vector> types_; std::vector members_; // keep members in order of appearance. }; struct AidlUnstructuredHeaders { std::string cpp; std::string ndk; std::string rust_type; }; class AidlParcelable : public AidlDefinedType, public AidlParameterizable { public: AidlParcelable(const AidlLocation& location, const std::string& name, const std::string& package, const Comments& comments, const AidlUnstructuredHeaders& headers, std::vector* type_params, std::vector>* members = nullptr); virtual ~AidlParcelable() = default; // non-copyable, non-movable AidlParcelable(const AidlParcelable&) = delete; AidlParcelable(AidlParcelable&&) = delete; AidlParcelable& operator=(const AidlParcelable&) = delete; AidlParcelable& operator=(AidlParcelable&&) = delete; std::string GetCppHeader() const { return headers_.cpp; } std::string GetNdkHeader() const { return headers_.ndk; } std::string GetRustType() const { return headers_.rust_type; } bool CheckValid(const AidlTypenames& typenames) const override; const AidlParcelable* AsParcelable() const override { return this; } const AidlParameterizable* AsParameterizable() const override { return this; } const AidlNode& AsAidlNode() const override { return *this; } std::string GetPreprocessDeclarationName() const override { return "parcelable"; } void DispatchVisit(AidlVisitor& v) const override { v.Visit(*this); } private: AidlUnstructuredHeaders headers_; }; class AidlStructuredParcelable : public AidlParcelable { public: AidlStructuredParcelable(const AidlLocation& location, const std::string& name, const std::string& package, const Comments& comments, std::vector* type_params, std::vector>* members); virtual ~AidlStructuredParcelable() = default; // non-copyable, non-movable AidlStructuredParcelable(const AidlStructuredParcelable&) = delete; AidlStructuredParcelable(AidlStructuredParcelable&&) = delete; AidlStructuredParcelable& operator=(const AidlStructuredParcelable&) = delete; AidlStructuredParcelable& operator=(AidlStructuredParcelable&&) = delete; const AidlStructuredParcelable* AsStructuredParcelable() const override { return this; } std::string GetPreprocessDeclarationName() const override { return "structured_parcelable"; } bool CheckValid(const AidlTypenames& typenames) const override; void DispatchVisit(AidlVisitor& v) const override { v.Visit(*this); } }; class AidlEnumerator : public AidlCommentable { public: AidlEnumerator(const AidlLocation& location, const std::string& name, AidlConstantValue* value, const Comments& comments); virtual ~AidlEnumerator() = default; // non-copyable, non-movable AidlEnumerator(const AidlEnumerator&) = delete; AidlEnumerator(AidlEnumerator&&) = delete; AidlEnumerator& operator=(const AidlEnumerator&) = delete; AidlEnumerator& operator=(AidlEnumerator&&) = delete; const std::string& GetName() const { return name_; } AidlConstantValue* GetValue() const { return value_.get(); } bool CheckValid(const AidlTypeSpecifier& enum_backing_type) const; string ValueString(const AidlTypeSpecifier& backing_type, const ConstantValueDecorator& decorator) const; // TODO: Set is errorprone. What if it was set before? void SetValue(std::unique_ptr value) { value_ = std::move(value); } bool IsValueUserSpecified() const { return value_user_specified_; } void TraverseChildren(std::function traverse) const override { traverse(*value_); } void DispatchVisit(AidlVisitor& v) const override { v.Visit(*this); } private: const std::string name_; unique_ptr value_; const bool value_user_specified_; }; class AidlEnumDeclaration : public AidlDefinedType { public: AidlEnumDeclaration(const AidlLocation& location, const string& name, std::vector>* enumerators, const std::string& package, const Comments& comments); virtual ~AidlEnumDeclaration() = default; // non-copyable, non-movable AidlEnumDeclaration(const AidlEnumDeclaration&) = delete; AidlEnumDeclaration(AidlEnumDeclaration&&) = delete; AidlEnumDeclaration& operator=(const AidlEnumDeclaration&) = delete; AidlEnumDeclaration& operator=(AidlEnumDeclaration&&) = delete; bool Autofill(const AidlTypenames&); const AidlTypeSpecifier& GetBackingType() const { return *backing_type_; } const std::vector>& GetEnumerators() const { return enumerators_; } bool CheckValid(const AidlTypenames& typenames) const override; std::string GetPreprocessDeclarationName() const override { return "enum"; } const AidlEnumDeclaration* AsEnumDeclaration() const override { return this; } void TraverseChildren(std::function traverse) const override { AidlDefinedType::TraverseChildren(traverse); if (backing_type_) { traverse(*backing_type_); } for (const auto& c : GetEnumerators()) { traverse(*c); } } void DispatchVisit(AidlVisitor& v) const override { v.Visit(*this); } private: const std::string name_; const std::vector> enumerators_; std::unique_ptr backing_type_; }; class AidlUnionDecl : public AidlParcelable { public: AidlUnionDecl(const AidlLocation& location, const std::string& name, const std::string& package, const Comments& comments, std::vector* type_params, std::vector>* members); virtual ~AidlUnionDecl() = default; // non-copyable, non-movable AidlUnionDecl(const AidlUnionDecl&) = delete; AidlUnionDecl(AidlUnionDecl&&) = delete; AidlUnionDecl& operator=(const AidlUnionDecl&) = delete; AidlUnionDecl& operator=(AidlUnionDecl&&) = delete; const AidlNode& AsAidlNode() const override { return *this; } bool CheckValid(const AidlTypenames& typenames) const override; std::string GetPreprocessDeclarationName() const override { return "union"; } const AidlUnionDecl* AsUnionDeclaration() const override { return this; } void DispatchVisit(AidlVisitor& v) const override { v.Visit(*this); } }; class AidlInterface final : public AidlDefinedType { public: AidlInterface(const AidlLocation& location, const std::string& name, const Comments& comments, bool oneway, const std::string& package, std::vector>* members); virtual ~AidlInterface() = default; // non-copyable, non-movable AidlInterface(const AidlInterface&) = delete; AidlInterface(AidlInterface&&) = delete; AidlInterface& operator=(const AidlInterface&) = delete; AidlInterface& operator=(AidlInterface&&) = delete; const AidlInterface* AsInterface() const override { return this; } std::string GetPreprocessDeclarationName() const override { return "interface"; } bool CheckValid(const AidlTypenames& typenames) const override; bool CheckValidPermissionAnnotations(const AidlMethod& m) const; bool UsesPermissions() const; std::string GetDescriptor() const; void DispatchVisit(AidlVisitor& v) const override { v.Visit(*this); } bool HasOnewayAnnotation() const { return oneway_annotation_; } private: bool oneway_annotation_; }; inline std::string SimpleName(const std::string& qualified_name) { return qualified_name.substr(qualified_name.rfind('.') + 1); } // AidlDocument models an AIDL file class AidlDocument : public AidlCommentable, public AidlScope { public: AidlDocument(const AidlLocation& location, const Comments& comments, std::vector imports, std::vector> defined_types, bool is_preprocessed); ~AidlDocument() = default; // non-copyable, non-movable AidlDocument(const AidlDocument&) = delete; AidlDocument(AidlDocument&&) = delete; AidlDocument& operator=(const AidlDocument&) = delete; AidlDocument& operator=(AidlDocument&&) = delete; std::string ResolveName(const std::string& name) const override; const std::vector& Imports() const { return imports_; } const std::vector>& DefinedTypes() const { return defined_types_; } bool IsPreprocessed() const { return is_preprocessed_; } void TraverseChildren(std::function traverse) const override { for (const auto& t : DefinedTypes()) { traverse(*t); } } void DispatchVisit(AidlVisitor& v) const override { v.Visit(*this); } private: const std::vector imports_; const std::vector> defined_types_; bool is_preprocessed_; }; template std::optional AidlAnnotation::ParamValue(const std::string& param_name) const { auto it = parameters_.find(param_name); if (it == parameters_.end()) { return std::nullopt; } return it->second->EvaluatedValue(); } // Utilities to make a visitor to visit AST tree in top-down order // Given: foo // / \ // bar baz // VisitTopDown(v, foo) makes v visit foo -> bar -> baz. inline void VisitTopDown(std::function v, const AidlNode& node) { std::function top_down = [&](const AidlNode& n) { v(n); n.TraverseChildren(top_down); }; top_down(node); } inline void VisitTopDown(AidlVisitor& v, const AidlNode& node) { VisitTopDown([&](const AidlNode& n) { n.DispatchVisit(v); }, node); } // Utility to make a visitor to visit AST tree in bottom-up order // Given: foo // / \ // bar baz // VisitBottomUp(v, foo) makes v visit bar -> baz -> foo. inline void VisitBottomUp(AidlVisitor& v, const AidlNode& node) { std::function bottom_up = [&](const AidlNode& n) { n.TraverseChildren(bottom_up); n.DispatchVisit(v); }; bottom_up(node); } template const T* AidlCast(const AidlNode& node) { struct CastVisitor : AidlVisitor { const T* cast = nullptr; void Visit(const T& t) override { cast = &t; } } visitor; node.DispatchVisit(visitor); return visitor.cast; } template <> const AidlDefinedType* AidlCast(const AidlNode& node); template T* AidlCast(AidlNode& node) { return const_cast(AidlCast(const_cast(node))); } template vector Collect(const AidlNode& root) { vector result; std::function top_down = [&](const AidlNode& n) { if (auto cast = AidlCast(n); cast) { result.push_back(cast); } n.TraverseChildren(top_down); }; top_down(root); return result; } template bool TopologicalVisit(const vector>& nested_types, VisitFn visit) { // 1. Maps deeply nested types to one of nested_types map roots; for (const auto& nested : nested_types) { for (const auto& t : Collect(*nested)) { roots[t] = nested.get(); } } // 2. Collect sibling types referenced within each nested type. map> required_types; for (const auto& nested : nested_types) { for (const auto& t : Collect(*nested)) { if (auto defined_type = t->GetDefinedType(); defined_type) { auto sibling = roots[defined_type]; if (sibling && sibling != nested.get()) { required_types[nested.get()].push_back(sibling); } } } }; // 3. Run DFS enum { NOT_STARTED = 0, STARTED = 1, FINISHED = 2 }; map visited; std::function dfs = [&](const AidlDefinedType& type) { if (visited[&type] == FINISHED) { return true; } else if (visited[&type] == STARTED) { return false; } else { visited[&type] = STARTED; // Visit every required dep first for (const auto& dep_type : required_types[&type]) { if (!dfs(*dep_type)) { return false; } } visited[&type] = FINISHED; visit(type); return true; } }; for (const auto& type : nested_types) { if (!dfs(*type)) { return false; } } return true; } ./PaxHeaders.X/aidl_language_l.ll0100644 0000000 0000000 00000000034 15172120304 015714 xustar000000000 0000000 28 mtime=1776853188.2880000 aidl_language_l.ll0100644 0000000 0000000 00000015201 15172120304 013217 0ustar000000000 0000000 /* * 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 #include #include "aidl_language.h" #include "parser.h" #include "aidl_language_y.h" #ifndef YYSTYPE #define YYSTYPE yy::parser::semantic_type #endif #ifndef YYLTYPE #define YYLTYPE yy::parser::location_type #endif #define YY_USER_ACTION yylloc->columns(yyleng); %} %option noyywrap %option nounput %option noinput %option reentrant %option bison-bridge %option bison-locations %x LONG_COMMENT identifier [_a-zA-Z][_a-zA-Z0-9]* whitespace ([ \t\r]+) intvalue [0-9_]+(u8|u32|u64|[lL])* hexvalue 0[x|X][0-9a-fA-F_]+(u8|u32|u64|[lL])* floatvalue [0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?f? %% %{ /* This happens at every call to yylex (every time we receive one token) */ using android::aidl::Comments; using android::aidl::Comment; std::string extra_text; Comments comments; yylloc->step(); %} \/\* { extra_text += yytext; BEGIN(LONG_COMMENT); } \*+\/ { extra_text += yytext; yylloc->step(); BEGIN(INITIAL); comments.push_back({extra_text}); extra_text.clear(); } \*+ { extra_text += yytext; } \n+ { extra_text += yytext; yylloc->lines(yyleng); } [^*\n]+ { extra_text += yytext; } \"([^\"]|\\.)*\" { yylval->token = new AidlToken(yytext, comments); return yy::parser::token::C_STR; } \/\/.* { extra_text += yytext; extra_text += "\n"; comments.push_back({extra_text}); extra_text.clear(); } \n+ { yylloc->lines(yyleng); yylloc->step(); } {whitespace} {} <> { yyterminate(); } /* symbols */ "(" { return('('); } ")" { return(')'); } "<" { return('<'); } ">" { return('>'); } "{" { return('{'); } "}" { return('}'); } "[" { return('['); } "]" { return(']'); } ":" { return(':'); } ";" { return(';'); } "," { return(','); } "." { return('.'); } "=" { return('='); } "+" { return('+'); } "-" { return('-'); } "*" { return('*'); } "/" { return('/'); } "%" { return('%'); } "&" { return('&'); } "|" { return('|'); } "^" { return('^'); } "<<" { return(yy::parser::token::LSHIFT); } ">>" { return(yy::parser::token::RSHIFT); } "&&" { return(yy::parser::token::LOGICAL_AND); } "||" { return(yy::parser::token::LOGICAL_OR); } "!" { return('!'); } "~" { return('~'); } "<=" { return(yy::parser::token::LEQ); } ">=" { return(yy::parser::token::GEQ); } "==" { return(yy::parser::token::EQUALITY); } "!=" { return(yy::parser::token::NEQ); } /* annotations */ @{identifier} { yylval->token = new AidlToken(yytext + 1, comments); return yy::parser::token::ANNOTATION; } /* keywords */ parcelable { yylval->token = new AidlToken("parcelable", comments); return yy::parser::token::PARCELABLE; } import { yylval->token = new AidlToken("import", comments); return yy::parser::token::IMPORT; } package { yylval->token = new AidlToken("package", comments); return yy::parser::token::PACKAGE; } in { return yy::parser::token::IN; } out { return yy::parser::token::OUT; } inout { return yy::parser::token::INOUT; } cpp_header { yylval->token = new AidlToken("cpp_header", comments); return yy::parser::token::CPP_HEADER; } ndk_header { yylval->token = new AidlToken("ndk_header", comments); return yy::parser::token::NDK_HEADER; } rust_type { yylval->token = new AidlToken("rust_type", comments); return yy::parser::token::RUST_TYPE; } const { yylval->token = new AidlToken("const", comments); return yy::parser::token::CONST; } true { return yy::parser::token::TRUE_LITERAL; } false { return yy::parser::token::FALSE_LITERAL; } interface { yylval->token = new AidlToken("interface", comments); return yy::parser::token::INTERFACE; } oneway { yylval->token = new AidlToken("oneway", comments); return yy::parser::token::ONEWAY; } enum { yylval->token = new AidlToken("enum", comments); return yy::parser::token::ENUM; } union { yylval->token = new AidlToken("union", comments); return yy::parser::token::UNION; } /* scalars */ {identifier} { yylval->token = new AidlToken(yytext, comments); return yy::parser::token::IDENTIFIER; } '.' { yylval->token = new AidlToken(std::string(yytext, yyleng), comments); return yy::parser::token::CHARVALUE; } {intvalue} { yylval->token = new AidlToken(yytext, comments); return yy::parser::token::INTVALUE; } {floatvalue} { yylval->token = new AidlToken(yytext, comments); return yy::parser::token::FLOATVALUE; } {hexvalue} { yylval->token = new AidlToken(yytext, comments); return yy::parser::token::HEXVALUE; } /* lexical error! */ . { return yy::parser::token::UNKNOWN; } %% // comment and whitespace handling // ================================================ ./PaxHeaders.X/aidl_language_y.yy0100644 0000000 0000000 00000000034 15172120304 015763 xustar000000000 0000000 28 mtime=1776853188.2890000 aidl_language_y.yy0100644 0000000 0000000 00000057706 15172120304 013306 0ustar000000000 0000000 /* * 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_language.h" #include "parser.h" #include "aidl_language_y.h" #include "logging.h" #include #include #include #include #include #include int yylex(yy::parser::semantic_type *, yy::parser::location_type *, void *); AidlLocation loc(const yy::parser::location_type& begin, const yy::parser::location_type& end) { AIDL_FATAL_IF(begin.begin.filename != begin.end.filename, AIDL_LOCATION_HERE); AIDL_FATAL_IF(begin.end.filename != end.begin.filename, AIDL_LOCATION_HERE); AIDL_FATAL_IF(end.begin.filename != end.end.filename, AIDL_LOCATION_HERE); AidlLocation::Point begin_point { .line = begin.begin.line, .column = begin.begin.column, }; AidlLocation::Point end_point { .line = end.end.line, .column = end.end.column, }; return AidlLocation(*begin.begin.filename, begin_point, end_point, AidlLocation::Source::EXTERNAL); } AidlLocation loc(const yy::parser::location_type& l) { return loc(l, l); } #define lex_scanner ps->Scanner() %} %initial-action { @$.begin.filename = @$.end.filename = const_cast(&ps->FileName()); } %parse-param { Parser* ps } %lex-param { void *lex_scanner } %glr-parser %skeleton "glr.cc" %expect-rr 0 %define parse.error verbose %locations %union { AidlToken* token; char character; std::string *str; std::vector> *token_list; AidlAnnotation* annotation; AidlAnnotationParameter* param; std::map>* param_list; std::vector>* annotation_list; AidlTypeSpecifier* type; AidlArgument* arg; AidlArgument::Direction direction; AidlConstantValue* const_expr; AidlEnumerator* enumerator; std::vector>* enumerators; std::vector>* constant_value_list; std::vector>* arg_list; AidlVariableDeclaration* variable; AidlMethod* method; AidlMember* constant; std::vector>* members; AidlDefinedType* declaration; std::vector>* type_args; std::vector* type_params; std::vector>* declarations; AidlUnstructuredHeaders* unstructured_headers; } %destructor { } %destructor { delete ($$); } <*> %token PACKAGE "package" %token IMPORT "import" %token ANNOTATION "annotation" %token C_STR "string literal" %token IDENTIFIER "identifier" %token INTERFACE "interface" %token PARCELABLE "parcelable" %token ONEWAY "oneway" %token ENUM "enum" %token UNION "union" %token CONST "const" %token CHARVALUE "char literal" %token FLOATVALUE "float literal" %token HEXVALUE "hex literal" %token INTVALUE "int literal" %token '(' ')' ',' '=' '[' ']' '.' '{' '}' ';' %token UNKNOWN "unrecognized character" %token CPP_HEADER "cpp_header (which can also be used as an identifier)" %token NDK_HEADER "ndk_header (which can also be used as an identifier)" %token RUST_TYPE "rust_type (which can also be used as an identifier)" %token IN "in" %token INOUT "inout" %token OUT "out" %token TRUE_LITERAL "true" %token FALSE_LITERAL "false" /* Operator precedence and associativity, as per * http://en.cppreference.com/w/cpp/language/operator_precedence */ /* Precedence level 13 - 14, LTR, logical operators*/ %left LOGICAL_OR %left LOGICAL_AND /* Precedence level 10 - 12, LTR, bitwise operators*/ %left '|' %left '^' %left '&' /* Precedence level 9, LTR */ %left EQUALITY NEQ /* Precedence level 8, LTR */ %left '<' '>' LEQ GEQ /* Precedence level 7, LTR */ %left LSHIFT RSHIFT /* Precedence level 6, LTR */ %left '+' '-' /* Precedence level 5, LTR */ %left '*' '/' '%' /* Precedence level 3, RTL; but we have to use %left here */ %right UNARY_PLUS UNARY_MINUS '!' '~' %type decl %type unannotated_decl %type interface_decl %type parcelable_decl %type enum_decl %type union_decl %type parcelable_members interface_members %type variable_decl %type optional_type_params %type method_decl %type constant_decl %type enumerator %type enumerators enum_decl_body %type parameter %type parameter_list %type parameter_non_empty_list %type annotation %typeannotation_list %type type %type non_array_type %type arg_list arg_non_empty_list %type arg %type direction %type type_args %type type_params %type const_expr %type constant_value_list %type constant_value_non_empty_list %type imports %type decls %type import identifier error qualified_name optional_package %type optional_unstructured_headers %% document : optional_package imports decls { std::vector imports; for (const auto& import : *$2) { imports.push_back(import->GetText()); } ps->MakeDocument(loc(@1), Comments(), std::move(imports), std::move(*$3)); for (auto i = $2->rbegin(); i != $2->rend(); ++i) { ps->GetDocument()->PrependComments((*i)->GetComments()); } if ($1) { ps->GetDocument()->PrependComments($1->GetComments()); } delete $1; delete $2; delete $3; } ; /* A couple of tokens that are keywords elsewhere are identifiers when * occurring in the identifier position. Therefore identifier is a * non-terminal, which is either an IDENTIFIER token, or one of the * aforementioned keyword tokens. */ identifier : IDENTIFIER | CPP_HEADER | NDK_HEADER | RUST_TYPE ; optional_package : { $$ = nullptr; } | PACKAGE qualified_name ';' { ps->SetPackage($2->GetText()); $$ = $1; // for comments delete $2; } ; imports : { $$ = new std::vector>(); } | imports import { $$ = $1; $$->emplace_back($2); } import : IMPORT qualified_name ';' { // carry the comments before "import" token $$ = new AidlToken($2->GetText(), $1->GetComments()); delete $1; delete $2; }; qualified_name : identifier { $$ = $1; } | qualified_name '.' identifier { $$ = $1; $$->Append('.'); $$->Append($3->GetText()); delete $3; }; decls : decl { $$ = new std::vector>(); if ($1 != nullptr) { $$->emplace_back($1); } } | decls decl { $$ = $1; if ($2 != nullptr) { $$->emplace_back($2); } } decl : annotation_list unannotated_decl { $$ = $2; if ($$ != nullptr) { $$->Annotate(std::move(*$1)); } delete $1; } ; unannotated_decl : parcelable_decl | interface_decl | enum_decl | union_decl ; type_params : identifier { $$ = new std::vector(); $$->emplace_back($1->GetText()); delete $1; } | type_params ',' identifier { $1->emplace_back($3->GetText()); $$ = $1; delete $3; }; optional_type_params : /* none */ { $$ = nullptr; } | '<' type_params '>' { $$ = $2; }; optional_unstructured_headers : /* none */ { $$ = new AidlUnstructuredHeaders; } | optional_unstructured_headers CPP_HEADER C_STR { $$ = $1; $$->cpp = $3->GetText(); delete $2; delete $3; } | optional_unstructured_headers NDK_HEADER C_STR { $$ = $1; $$->ndk = $3->GetText(); delete $2; delete $3; } | optional_unstructured_headers RUST_TYPE C_STR { $$ = $1; $$->rust_type = $3->GetText(); delete $2; delete $3; } ; parcelable_decl : PARCELABLE qualified_name optional_type_params optional_unstructured_headers ';' { // No check for type name here. We allow nested types for unstructured parcelables. $$ = new AidlParcelable(loc(@2), $2->GetText(), ps->Package(), $1->GetComments(), *$4, $3); delete $1; delete $2; delete $4; } | PARCELABLE qualified_name optional_type_params '{' parcelable_members '}' { ps->CheckValidTypeName(*$2, loc(@2)); $$ = new AidlStructuredParcelable(loc(@2), $2->GetText(), ps->Package(), $1->GetComments(), $3, $5); delete $1; delete $2; } | PARCELABLE error ';' { ps->AddError(); $$ = nullptr; delete $1; }; parcelable_members : /* empty */ { $$ = new std::vector>(); } | parcelable_members variable_decl { $1->emplace_back($2); $$ = $1; } | parcelable_members constant_decl { $1->emplace_back($2); $$ = $1; } | parcelable_members decl { if ($2) $1->emplace_back($2); // decl may be nullptr on error $$ = $1; } | parcelable_members error ';' { ps->AddError(); $$ = $1; }; variable_decl : type identifier ';' { $$ = new AidlVariableDeclaration(loc(@2), $1, $2->GetText()); delete $2; } | type identifier '=' const_expr ';' { // TODO(b/123321528): Support enum type default assignments (TestEnum foo = TestEnum.FOO). $$ = new AidlVariableDeclaration(loc(@2), $1, $2->GetText(), $4); delete $2; } ; interface_decl : INTERFACE qualified_name ';' { ps->CheckValidTypeName(*$2, loc(@2)); $$ = new AidlInterface(loc(@1), $2->GetText(), $1->GetComments(), false, ps->Package(), nullptr); delete $1; delete $2; } | INTERFACE qualified_name '{' interface_members '}' { ps->CheckValidTypeName(*$2, loc(@2)); $$ = new AidlInterface(loc(@1), $2->GetText(), $1->GetComments(), false, ps->Package(), $4); delete $1; delete $2; } | ONEWAY INTERFACE qualified_name '{' interface_members '}' { ps->CheckValidTypeName(*$3, loc(@3)); $$ = new AidlInterface(loc(@2), $3->GetText(), $1->GetComments(), true, ps->Package(), $5); delete $1; delete $2; delete $3; } | INTERFACE error '{' interface_members '}' { ps->AddError(); $$ = nullptr; delete $1; delete $4; }; interface_members : { $$ = new std::vector>(); } | interface_members method_decl { $1->push_back(std::unique_ptr($2)); $$ = $1; } | interface_members constant_decl { $1->push_back(std::unique_ptr($2)); $$ = $1; } | interface_members decl { if ($2) $1->emplace_back($2); // decl may be nullptr on error $$ = $1; } | interface_members error ';' { ps->AddError(); $$ = $1; }; const_expr : TRUE_LITERAL { $$ = AidlConstantValue::Boolean(loc(@1), true); } | FALSE_LITERAL { $$ = AidlConstantValue::Boolean(loc(@1), false); } | CHARVALUE { $$ = AidlConstantValue::Character(loc(@1), $1->GetText()); delete $1; } | INTVALUE { $$ = AidlConstantValue::Integral(loc(@1), $1->GetText()); if ($$ == nullptr) { AIDL_ERROR(loc(@1)) << "Could not parse integer: " << $1->GetText(); ps->AddError(); $$ = AidlConstantValue::Integral(loc(@1), "0"); } delete $1; } | FLOATVALUE { $$ = AidlConstantValue::Floating(loc(@1), $1->GetText()); delete $1; } | HEXVALUE { $$ = AidlConstantValue::Integral(loc(@1), $1->GetText()); if ($$ == nullptr) { AIDL_ERROR(loc(@1)) << "Could not parse hexvalue: " << $1->GetText(); ps->AddError(); $$ = AidlConstantValue::Integral(loc(@1), "0"); } delete $1; } | C_STR { $$ = AidlConstantValue::String(loc(@1), $1->GetText()); delete $1; } | qualified_name { $$ = new AidlConstantReference(loc(@1), $1->GetText()); delete $1; } | '{' constant_value_list '}' { $$ = AidlConstantValue::Array(loc(@1), std::unique_ptr>>($2)); } | const_expr LOGICAL_OR const_expr { $$ = new AidlBinaryConstExpression(loc(@1), std::unique_ptr($1), "||", std::unique_ptr($3)); } | const_expr LOGICAL_AND const_expr { $$ = new AidlBinaryConstExpression(loc(@1), std::unique_ptr($1), "&&", std::unique_ptr($3)); } | const_expr '|' const_expr { $$ = new AidlBinaryConstExpression(loc(@1), std::unique_ptr($1), "|" , std::unique_ptr($3)); } | const_expr '^' const_expr { $$ = new AidlBinaryConstExpression(loc(@1), std::unique_ptr($1), "^" , std::unique_ptr($3)); } | const_expr '&' const_expr { $$ = new AidlBinaryConstExpression(loc(@1), std::unique_ptr($1), "&" , std::unique_ptr($3)); } | const_expr EQUALITY const_expr { $$ = new AidlBinaryConstExpression(loc(@1), std::unique_ptr($1), "==", std::unique_ptr($3)); } | const_expr NEQ const_expr { $$ = new AidlBinaryConstExpression(loc(@1), std::unique_ptr($1), "!=", std::unique_ptr($3)); } | const_expr '<' const_expr { $$ = new AidlBinaryConstExpression(loc(@1), std::unique_ptr($1), "<" , std::unique_ptr($3)); } | const_expr '>' const_expr { $$ = new AidlBinaryConstExpression(loc(@1), std::unique_ptr($1), ">" , std::unique_ptr($3)); } | const_expr LEQ const_expr { $$ = new AidlBinaryConstExpression(loc(@1), std::unique_ptr($1), "<=", std::unique_ptr($3)); } | const_expr GEQ const_expr { $$ = new AidlBinaryConstExpression(loc(@1), std::unique_ptr($1), ">=", std::unique_ptr($3)); } | const_expr LSHIFT const_expr { $$ = new AidlBinaryConstExpression(loc(@1), std::unique_ptr($1), "<<", std::unique_ptr($3)); } | const_expr RSHIFT const_expr { $$ = new AidlBinaryConstExpression(loc(@1), std::unique_ptr($1), ">>", std::unique_ptr($3)); } | const_expr '+' const_expr { $$ = new AidlBinaryConstExpression(loc(@1), std::unique_ptr($1), "+" , std::unique_ptr($3)); } | const_expr '-' const_expr { $$ = new AidlBinaryConstExpression(loc(@1), std::unique_ptr($1), "-" , std::unique_ptr($3)); } | const_expr '*' const_expr { $$ = new AidlBinaryConstExpression(loc(@1), std::unique_ptr($1), "*" , std::unique_ptr($3)); } | const_expr '/' const_expr { $$ = new AidlBinaryConstExpression(loc(@1), std::unique_ptr($1), "/" , std::unique_ptr($3)); } | const_expr '%' const_expr { $$ = new AidlBinaryConstExpression(loc(@1), std::unique_ptr($1), "%" , std::unique_ptr($3)); } | '+' const_expr %prec UNARY_PLUS { $$ = new AidlUnaryConstExpression(loc(@1), "+", std::unique_ptr($2)); } | '-' const_expr %prec UNARY_MINUS { $$ = new AidlUnaryConstExpression(loc(@1), "-", std::unique_ptr($2)); } | '!' const_expr { $$ = new AidlUnaryConstExpression(loc(@1), "!", std::unique_ptr($2)); } | '~' const_expr { $$ = new AidlUnaryConstExpression(loc(@1), "~", std::unique_ptr($2)); } | '(' const_expr ')' { $$ = $2; } | '(' error ')' { AIDL_ERROR(loc(@1)) << "invalid const expression within parenthesis"; ps->AddError(); // to avoid segfaults $$ = AidlConstantValue::Integral(loc(@1), "0"); } ; constant_value_list : /* empty */ { $$ = new std::vector>; } | constant_value_non_empty_list { $$ = $1; } | constant_value_non_empty_list ',' { $$ = $1; } ; constant_value_non_empty_list : const_expr { $$ = new std::vector>; $$->push_back(std::unique_ptr($1)); } | constant_value_non_empty_list ',' const_expr { $$ = $1; $$->push_back(std::unique_ptr($3)); } ; constant_decl : annotation_list CONST type identifier '=' const_expr ';' { $3->PrependComments($2->GetComments()); // TODO(b/151102494) do not merge annotations. $3->Annotate(std::move(*$1)); $$ = new AidlConstantDeclaration(loc(@4), $3, $4->GetText(), $6); delete $1; delete $2; delete $4; } ; enumerator : identifier '=' const_expr { $$ = new AidlEnumerator(loc(@1), $1->GetText(), $3, $1->GetComments()); delete $1; } | identifier { $$ = new AidlEnumerator(loc(@1), $1->GetText(), nullptr, $1->GetComments()); delete $1; } ; enumerators : enumerator { $$ = new std::vector>(); $$->push_back(std::unique_ptr($1)); } | enumerators ',' enumerator { $1->push_back(std::unique_ptr($3)); $$ = $1; } ; enum_decl_body : '{' enumerators '}' { $$ = $2; } | '{' enumerators ',' '}' { $$ = $2; } ; enum_decl : ENUM qualified_name enum_decl_body { ps->CheckValidTypeName(*$2, loc(@2)); $$ = new AidlEnumDeclaration(loc(@2), $2->GetText(), $3, ps->Package(), $1->GetComments()); delete $1; delete $2; delete $3; } ; union_decl : UNION qualified_name optional_type_params '{' parcelable_members '}' { ps->CheckValidTypeName(*$2, loc(@2)); $$ = new AidlUnionDecl(loc(@2), $2->GetText(), ps->Package(), $1->GetComments(), $3, $5); delete $1; delete $2; } ; method_decl : type identifier '(' arg_list ')' ';' { $$ = new AidlMethod(loc(@2), false, $1, $2->GetText(), $4, $2->GetComments()); $$->PrependComments($1->GetComments()); delete $2; } | annotation_list ONEWAY type identifier '(' arg_list ')' ';' { $$ = new AidlMethod(loc(@4), true, $3, $4->GetText(), $6, $4->GetComments()); $3->PrependComments($2->GetComments()); $3->Annotate(std::move(*$1)); $$->PrependComments($3->GetComments()); delete $1; delete $2; delete $4; } | type identifier '(' arg_list ')' '=' INTVALUE ';' { int32_t serial = 0; if (!android::base::ParseInt($7->GetText(), &serial)) { AIDL_ERROR(loc(@7)) << "Could not parse int value: " << $7->GetText(); ps->AddError(); } $$ = new AidlMethod(loc(@2), false, $1, $2->GetText(), $4, $2->GetComments(), serial); $$->PrependComments($1->GetComments()); delete $2; delete $7; } | annotation_list ONEWAY type identifier '(' arg_list ')' '=' INTVALUE ';' { int32_t serial = 0; if (!android::base::ParseInt($9->GetText(), &serial)) { AIDL_ERROR(loc(@9)) << "Could not parse int value: " << $9->GetText(); ps->AddError(); } $$ = new AidlMethod(loc(@4), true, $3, $4->GetText(), $6, $4->GetComments(), serial); $3->PrependComments($2->GetComments()); $3->Annotate(std::move(*$1)); $$->PrependComments($3->GetComments()); delete $1; delete $2; delete $4; delete $9; }; arg_non_empty_list : arg { $$ = new std::vector>(); $$->push_back(std::unique_ptr($1)); } | arg_non_empty_list ',' arg { $$ = $1; $$->push_back(std::unique_ptr($3)); }; arg_list : /*empty*/ { $$ = new std::vector>(); } | arg_non_empty_list { $$ = $1; } ; arg : direction type identifier { $$ = new AidlArgument(loc(@3), $1, $2, $3->GetText()); delete $3; } | type identifier { $$ = new AidlArgument(loc(@2), $1, $2->GetText()); delete $2; }; non_array_type : annotation_list qualified_name { $$ = new AidlTypeSpecifier(loc(@2), $2->GetText(), /*array=*/std::nullopt, nullptr, $2->GetComments()); $$->Annotate(std::move(*$1)); delete $1; delete $2; } | non_array_type '<' type_args '>' { ps->SetTypeParameters($1, $3); $$ = $1; } | non_array_type '<' non_array_type '<' type_args RSHIFT { ps->SetTypeParameters($3, $5); auto params = new std::vector>(); params->emplace_back($3); ps->SetTypeParameters($1, params); $$ = $1; } | non_array_type '<' type_args ',' non_array_type '<' type_args RSHIFT { ps->SetTypeParameters($5, $7); $3->emplace_back($5); ps->SetTypeParameters($1, $3); $$ = $1; }; type : non_array_type | type annotation_list '[' ']' { if (!$2->empty()) { AIDL_ERROR(loc(@2)) << "Annotations for arrays are not supported."; ps->AddError(); } if (!$1->MakeArray(DynamicArray{})) { AIDL_ERROR(loc(@1)) << "Multi-dimensional arrays must be fixed size."; ps->AddError(); } $$ = $1; delete $2; } | type annotation_list '[' const_expr ']' { if (!$2->empty()) { AIDL_ERROR(loc(@2)) << "Annotations for arrays are not supported."; ps->AddError(); } if (!$1->MakeArray(FixedSizeArray{std::unique_ptr($4)})) { AIDL_ERROR(loc(@1)) << "Multi-dimensional arrays must be fixed size."; ps->AddError(); } $$ = $1; delete $2; } ; type_args : type { if (!$1->GetAnnotations().empty()) { AIDL_ERROR(loc(@1)) << "Annotations for type arguments are not supported."; ps->AddError(); } $$ = new std::vector>(); $$->emplace_back($1); } | type_args ',' type { $1->emplace_back($3); $$ = $1; }; annotation_list : { $$ = new std::vector>(); } | annotation_list annotation { if ($2 != nullptr) { $1->emplace_back(std::unique_ptr($2)); } $$ = $1; }; parameter : identifier '=' const_expr { $$ = new AidlAnnotationParameter{$1->GetText(), std::unique_ptr($3)}; delete $1; }; parameter_list : /*empty*/{ $$ = new std::map>(); } | parameter_non_empty_list { $$ = $1; }; parameter_non_empty_list : parameter { $$ = new std::map>(); $$->emplace(std::move($1->name), $1->value.release()); delete $1; } | parameter_non_empty_list ',' parameter { $$ = $1; if ($$->find($3->name) != $$->end()) { AIDL_ERROR(loc(@3)) << "Trying to redefine parameter " << $3->name << "."; ps->AddError(); } $$->emplace(std::move($3->name), std::move($3->value)); delete $3; }; annotation : ANNOTATION { // release() returns nullptr if unique_ptr is empty. $$ = AidlAnnotation::Parse(loc(@1), $1->GetText(), {}, $1->GetComments()).release(); if (!$$) { ps->AddError(); } delete $1; } | ANNOTATION '(' const_expr ')' { auto value = std::shared_ptr($3); std::map> parameter_list {{"value" , value}}; $$ = AidlAnnotation::Parse(loc(@1, @4), $1->GetText(), std::move(parameter_list), $1->GetComments()).release(); if (!$$) { ps->AddError(); } delete $1; } | ANNOTATION '(' parameter_list ')' { // release() returns nullptr if unique_ptr is empty. $$ = AidlAnnotation::Parse(loc(@1, @4), $1->GetText(), std::move(*$3), $1->GetComments()).release(); if (!$$) { ps->AddError(); } delete $1; delete $3; } ; direction : IN { $$ = AidlArgument::IN_DIR; } | OUT { $$ = AidlArgument::OUT_DIR; } | INOUT { $$ = AidlArgument::INOUT_DIR; }; %% #include #include void yy::parser::error(const yy::parser::location_type& l, const std::string& errstr) { AIDL_ERROR(loc(l)) << errstr; // parser will return error value } ./PaxHeaders.X/aidl_to_common.cpp0100644 0000000 0000000 00000000034 15172120304 015763 xustar000000000 0000000 28 mtime=1776853188.2890000 aidl_to_common.cpp0100644 0000000 0000000 00000002060 15172120304 013265 0ustar000000000 0000000 /* * Copyright (C) 2023 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_to_common.h" namespace android { namespace aidl { bool ShouldForceDowngradeFor(CommunicationSide e) { return kDowngradeCommunicationBitmap & static_cast(e); } void GenerateAutoGenHeader(CodeWriter& out, const Options& options) { out << "/*\n"; out << " * This file is auto-generated. DO NOT MODIFY.\n"; out << " * Using: " << options.RawArgs() << "\n"; out << " */\n"; } } // namespace aidl } // namespace android ./PaxHeaders.X/aidl_to_common.h0100644 0000000 0000000 00000000034 15172120304 015430 xustar000000000 0000000 28 mtime=1776853188.2890000 aidl_to_common.h0100644 0000000 0000000 00000003200 15172120304 012727 0ustar000000000 0000000 /* * Copyright (C) 2023, 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. */ #pragma once #include #include "aidl_language.h" #include "code_writer.h" #include "options.h" // This is used to help generate code targeting to any language namespace android { namespace aidl { enum class CommunicationSide { WRITE = 0x1, READ = 0x2, BOTH = WRITE | READ, }; constexpr int kDowngradeCommunicationBitmap = static_cast(CommunicationSide::BOTH); // This is used when adding the trunk stable downgrade to unfrozen interfaces. // The kDowngradeCommunicationBitmap constant can be used to only modify one side of // the generated interface libraries so we can make sure both sides are forced // to behave like the previous unfrozen version. // BOTH is standard operating config, but can be switched for testing. bool ShouldForceDowngradeFor(CommunicationSide e); // currently relies on all backends having the same comment style, but we // could take a comment type argument in the future void GenerateAutoGenHeader(CodeWriter& out, const Options& options); } // namespace aidl } // namespace android ./PaxHeaders.X/aidl_to_cpp.cpp0100644 0000000 0000000 00000000034 15172120304 015255 xustar000000000 0000000 28 mtime=1776853188.2900000 aidl_to_cpp.cpp0100644 0000000 0000000 00000027732 15172120304 012574 0ustar000000000 0000000 /* * Copyright (C) 2018, The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "aidl_to_cpp.h" #include "aidl_to_cpp_common.h" #include "aidl_language.h" #include "logging.h" #include #include #include #include using android::base::Join; using android::base::Split; using android::base::StringPrintf; using std::ostringstream; namespace android { namespace aidl { namespace cpp { namespace { std::string RawParcelMethod(const AidlTypeSpecifier& type, const AidlTypenames& typenames, bool readMethod) { static map kBuiltin = { {"byte", "Byte"}, {"boolean", "Bool"}, {"char", "Char"}, {"double", "Double"}, {"FileDescriptor", "UniqueFileDescriptor"}, {"float", "Float"}, {"IBinder", "StrongBinder"}, {"int", "Int32"}, {"long", "Int64"}, {"ParcelFileDescriptor", "Parcelable"}, {"String", "String16"}, {"ParcelableHolder", "Parcelable"}, }; static map kBuiltinVector = { {"FileDescriptor", "UniqueFileDescriptorVector"}, {"double", "DoubleVector"}, {"char", "CharVector"}, {"boolean", "BoolVector"}, {"byte", "ByteVector"}, {"float", "FloatVector"}, {"IBinder", "StrongBinderVector"}, {"String", "String16Vector"}, {"int", "Int32Vector"}, {"long", "Int64Vector"}, {"ParcelFileDescriptor", "ParcelableVector"}, }; const bool nullable = type.IsNullable(); const bool isVector = type.IsArray() || typenames.IsList(type); const bool utf8 = type.IsUtf8InCpp(); if (type.IsFixedSizeArray()) { return "FixedArray"; } if (auto enum_decl = typenames.GetEnumDeclaration(type); enum_decl != nullptr) { if (isVector) { return "EnumVector"; } else { return RawParcelMethod(enum_decl->GetBackingType(), typenames, readMethod); } } if (isVector) { string element_name; if (typenames.IsList(type)) { AIDL_FATAL_IF(type.GetTypeParameters().size() != 1, type); element_name = type.GetTypeParameters().at(0)->GetName(); } else { element_name = type.GetName(); } if (kBuiltinVector.find(element_name) != kBuiltinVector.end()) { AIDL_FATAL_IF(!AidlTypenames::IsBuiltinTypename(element_name), type); if (utf8) { AIDL_FATAL_IF(element_name != "String", type); return readMethod ? "Utf8VectorFromUtf16Vector" : "Utf8VectorAsUtf16Vector"; } return kBuiltinVector[element_name]; } auto definedType = typenames.TryGetDefinedType(element_name); if (definedType != nullptr && definedType->AsInterface() != nullptr) { return "StrongBinderVector"; } return "ParcelableVector"; } const string& type_name = type.GetName(); if (kBuiltin.find(type_name) != kBuiltin.end()) { AIDL_FATAL_IF(!AidlTypenames::IsBuiltinTypename(type_name), type); if (type_name == "IBinder" && nullable && readMethod) { return "NullableStrongBinder"; } if (type_name == "ParcelFileDescriptor" && nullable && !readMethod) { return "NullableParcelable"; } if (utf8) { AIDL_FATAL_IF(type_name != "String", type); return readMethod ? "Utf8FromUtf16" : "Utf8AsUtf16"; } return kBuiltin[type_name]; } AIDL_FATAL_IF(AidlTypenames::IsBuiltinTypename(type.GetName()), type); auto definedType = typenames.TryGetDefinedType(type.GetName()); // The type must be either primitive or interface or parcelable, // so it cannot be nullptr. AIDL_FATAL_IF(definedType == nullptr, type) << type.GetName() << " is not found."; if (definedType->AsInterface() != nullptr) { if (nullable && readMethod) { return "NullableStrongBinder"; } return "StrongBinder"; } // Parcelable if (nullable && !readMethod) { return "NullableParcelable"; } return "Parcelable"; } std::string GetRawCppName(const AidlTypeSpecifier& type) { return "::" + Join(type.GetSplitName(), "::"); } std::string WrapIfNullable(const std::string type_str, const AidlTypeSpecifier& raw_type, const AidlTypenames& typenames) { const auto& type = typenames.IsList(raw_type) ? (*raw_type.GetTypeParameters().at(0)) : raw_type; if (raw_type.IsNullable() && !AidlTypenames::IsPrimitiveTypename(type.GetName()) && type.GetName() != "IBinder" && typenames.GetEnumDeclaration(type) == nullptr) { if (raw_type.IsHeapNullable()) { return "::std::unique_ptr<" + type_str + ">"; } return "::std::optional<" + type_str + ">"; } return type_str; } std::string GetCppName(const AidlTypeSpecifier& raw_type, const AidlTypenames& typenames) { // map from AIDL built-in type name to the corresponding Cpp type name static map m = { {"boolean", "bool"}, {"byte", "int8_t"}, {"char", "char16_t"}, {"double", "double"}, {"FileDescriptor", "::android::base::unique_fd"}, {"float", "float"}, {"IBinder", "::android::sp<::android::IBinder>"}, {"int", "int32_t"}, {"long", "int64_t"}, {"ParcelFileDescriptor", "::android::os::ParcelFileDescriptor"}, {"String", "::android::String16"}, {"void", "void"}, {"ParcelableHolder", "::android::os::ParcelableHolder"}, }; AIDL_FATAL_IF(typenames.IsList(raw_type) && raw_type.GetTypeParameters().size() != 1, raw_type); const auto& type = typenames.IsList(raw_type) ? (*raw_type.GetTypeParameters().at(0)) : raw_type; const string& aidl_name = type.GetName(); if (m.find(aidl_name) != m.end()) { AIDL_FATAL_IF(!AidlTypenames::IsBuiltinTypename(aidl_name), raw_type); if (aidl_name == "byte" && type.IsArray()) { return "uint8_t"; } else if (raw_type.IsUtf8InCpp()) { AIDL_FATAL_IF(aidl_name != "String", type); return WrapIfNullable("::std::string", raw_type, typenames); } return WrapIfNullable(m[aidl_name], raw_type, typenames); } auto definedType = typenames.TryGetDefinedType(type.GetName()); if (definedType != nullptr && definedType->AsInterface() != nullptr) { return "::android::sp<" + GetRawCppName(type) + ">"; } auto cpp_name = GetRawCppName(type); if (type.IsGeneric()) { std::vector type_params; for (const auto& parameter : type.GetTypeParameters()) { type_params.push_back(CppNameOf(*parameter, typenames)); } cpp_name += "<" + base::Join(type_params, ", ") + ">"; } return WrapIfNullable(cpp_name, raw_type, typenames); } } // namespace std::string ConstantValueDecorator( const AidlTypeSpecifier& type, const std::variant>& raw_value) { return CppConstantValueDecorator(type, raw_value, /*is_ndk=*/false); }; std::string GetTransactionIdFor(const std::string& clazz, const AidlMethod& method) { return clazz + "::TRANSACTION_" + method.GetName(); } std::string CppNameOf(const AidlTypeSpecifier& type, const AidlTypenames& typenames) { // get base type's cpp_name with nullable processed. std::string cpp_name = GetCppName(type, typenames); if (type.IsArray() || typenames.IsList(type)) { if (type.IsFixedSizeArray()) { auto dimensions = type.GetFixedSizeArrayDimensions(); for (auto it = rbegin(dimensions), end = rend(dimensions); it != end; it++) { cpp_name = "std::array<" + cpp_name + ", " + std::to_string(*it) + ">"; } } else { cpp_name = "::std::vector<" + cpp_name + ">"; } // wrap nullable again because @nullable applies to BOTH array type(outermost type) AND base // type(innermost type) if (type.IsHeapNullable()) { cpp_name = "::std::unique_ptr<" + cpp_name + ">"; } else if (type.IsNullable()) { cpp_name = "::std::optional<" + cpp_name + ">"; } } return cpp_name; } bool IsNonCopyableType(const AidlTypeSpecifier& type, const AidlTypenames& typenames) { if (type.IsArray() || typenames.IsList(type)) { return false; } const std::string cpp_name = GetCppName(type, typenames); if (cpp_name == "::android::base::unique_fd") { return true; } return false; } std::string ParcelReadMethodOf(const AidlTypeSpecifier& type, const AidlTypenames& typenames) { return "read" + RawParcelMethod(type, typenames, true /* readMethod */); } std::string ParcelReadCastOf(const AidlTypeSpecifier& type, const AidlTypenames& typenames, const std::string& variable_name) { if (auto enum_decl = typenames.GetEnumDeclaration(type); enum_decl != nullptr && !type.IsArray()) { return StringPrintf("reinterpret_cast<%s *>(%s)", CppNameOf(enum_decl->GetBackingType(), typenames).c_str(), variable_name.c_str()); } return variable_name; } std::string ParcelWriteMethodOf(const AidlTypeSpecifier& type, const AidlTypenames& typenames) { return "write" + RawParcelMethod(type, typenames, false /* readMethod */); } std::string ParcelWriteCastOf(const AidlTypeSpecifier& type, const AidlTypenames& typenames, const std::string& variable_name) { if (auto enum_decl = typenames.GetEnumDeclaration(type); enum_decl != nullptr && !type.IsArray()) { return StringPrintf("static_cast<%s>(%s)", CppNameOf(enum_decl->GetBackingType(), typenames).c_str(), variable_name.c_str()); } return variable_name; } // Add includes for a type ref. Note that this is non-recursive. void AddHeaders(const AidlTypeSpecifier& type, const AidlTypenames& typenames, std::set* headers) { if (type.IsArray()) { if (type.IsFixedSizeArray()) { headers->insert("array"); } else { headers->insert("vector"); } } if (type.IsNullable()) { if (type.GetName() != "IBinder") { headers->insert("optional"); } } if (typenames.IsList(type)) { headers->insert("vector"); return; } if (type.GetName() == "String") { if (type.IsUtf8InCpp()) { headers->insert("string"); } else { headers->insert("utils/String16.h"); } return; } if (type.GetName() == "IBinder") { headers->insert("binder/IBinder.h"); return; } if (type.GetName() == "FileDescriptor") { headers->insert("android-base/unique_fd.h"); return; } if (type.GetName() == "ParcelFileDescriptor") { headers->insert("binder/ParcelFileDescriptor.h"); return; } if (type.GetName() == "ParcelableHolder") { headers->insert("binder/ParcelableHolder.h"); return; } static const std::set need_cstdint{"byte", "int", "long"}; if (need_cstdint.find(type.GetName()) != need_cstdint.end()) { headers->insert("cstdint"); return; } if (AidlTypenames::IsPrimitiveTypename(type.GetName())) { return; } auto defined_type = typenames.TryGetDefinedType(type.GetName()); AIDL_FATAL_IF(defined_type == nullptr, type) << "Unexpected type: " << type.GetName(); headers->insert(CppHeaderForType(*defined_type)); } std::string CppHeaderForType(const AidlDefinedType& defined_type) { // Unstructured parcelable should set its cpp_header. use it. if (auto unstructured = AidlCast(defined_type); unstructured) { const std::string cpp_header = unstructured->GetCppHeader(); AIDL_FATAL_IF(cpp_header.empty(), unstructured) << "Parcelable " << unstructured->GetCanonicalName() << " has no cpp_header defined."; return cpp_header; } return HeaderFile(defined_type, ClassNames::RAW, /*use_os_sep=*/false); } } // namespace cpp } // namespace aidl } // namespace android ./PaxHeaders.X/aidl_to_cpp.h0100644 0000000 0000000 00000000034 15172120304 014722 xustar000000000 0000000 28 mtime=1776853188.2900000 aidl_to_cpp.h0100644 0000000 0000000 00000005346 15172120304 012236 0ustar000000000 0000000 /* * Copyright (C) 2018, The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #pragma once #include "aidl_language.h" namespace android { namespace aidl { namespace cpp { // This header provides functions that translate AIDL things to cpp things. std::string ConstantValueDecorator( const AidlTypeSpecifier& type, const std::variant>& raw_value); struct CodeGeneratorContext { CodeWriter& writer; const AidlTypenames& types; const AidlTypeSpecifier& type; // an argument or return type to generate code for const string name; // name of the variable for the argument or the return value const bool isPointer; // whether the variable 'name' is a pointer or not }; std::string GetTransactionIdFor(const std::string& clazz, const AidlMethod& method); std::string CppNameOf(const AidlTypeSpecifier& type, const AidlTypenames& typenames); bool IsNonCopyableType(const AidlTypeSpecifier& type, const AidlTypenames& typenames); // Returns the name of the Parcel method suitable for reading data of the // given type. std::string ParcelReadMethodOf(const AidlTypeSpecifier& type, const AidlTypenames& typenames); // Returns the potentially-cast representation of the provided variable name, // suitable for being passed to a method from ParcelReadMethodOf. std::string ParcelReadCastOf(const AidlTypeSpecifier& type, const AidlTypenames& typenames, const std::string& variable_name); // Returns the name of the Parcel method suitable for writing data of the // given type. std::string ParcelWriteMethodOf(const AidlTypeSpecifier& type, const AidlTypenames& typenames); // Returns the potentially-cast representation of the provided variable name, // suitable for being passed to a method from ParcelWriteMethodOf. std::string ParcelWriteCastOf(const AidlTypeSpecifier& type, const AidlTypenames& typenames, const std::string& variable_name); void AddHeaders(const AidlTypeSpecifier& type, const AidlTypenames& typenames, std::set* headers); std::string CppHeaderForType(const AidlDefinedType& defined_type); } // namespace cpp } // namespace aidl } // namespace android ./PaxHeaders.X/aidl_to_cpp_common.cpp0100644 0000000 0000000 00000000034 15172120304 016625 xustar000000000 0000000 28 mtime=1776853188.2920000 aidl_to_cpp_common.cpp0100644 0000000 0000000 00000101120 15172120304 014124 0ustar000000000 0000000 /* * Copyright (C) 2018, The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "aidl_to_cpp_common.h" #include #include #include #include #include #include #include "comments.h" #include "logging.h" #include "os.h" using ::android::base::Join; using ::android::base::Split; namespace android { namespace aidl { namespace cpp { char kTransactionLogStruct[] = R"(struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; )"; bool HasDeprecatedField(const AidlParcelable& parcelable) { return std::any_of(parcelable.GetFields().begin(), parcelable.GetFields().end(), [](const auto& field) { return field->IsDeprecated(); }); } string ClassName(const AidlDefinedType& defined_type, ClassNames type) { if (type == ClassNames::MAYBE_INTERFACE && defined_type.AsInterface()) { type = ClassNames::INTERFACE; } string base_name = defined_type.GetName(); if (base_name.length() >= 2 && base_name[0] == 'I' && isupper(base_name[1])) { base_name = base_name.substr(1); } switch (type) { case ClassNames::CLIENT: return "Bp" + base_name; case ClassNames::SERVER: return "Bn" + base_name; case ClassNames::INTERFACE: return "I" + base_name; case ClassNames::DEFAULT_IMPL: return "I" + base_name + "Default"; case ClassNames::BASE: return base_name; case ClassNames::DELEGATOR_IMPL: return "I" + base_name + "Delegator"; case ClassNames::RAW: [[fallthrough]]; default: return defined_type.GetName(); } } std::string HeaderFile(const AidlDefinedType& defined_type, ClassNames class_type, bool use_os_sep) { // For a nested type, we need to include its top-most parent type's header. const AidlDefinedType* toplevel = &defined_type; for (auto parent = toplevel->GetParentType(); parent;) { // When including the parent's header, it should be always RAW class_type = ClassNames::RAW; toplevel = parent; parent = toplevel->GetParentType(); } AIDL_FATAL_IF(toplevel->GetParentType() != nullptr, defined_type) << "Can't find a top-level decl"; char separator = (use_os_sep) ? OS_PATH_SEPARATOR : '/'; vector paths = toplevel->GetSplitPackage(); paths.push_back(ClassName(*toplevel, class_type)); return Join(paths, separator) + ".h"; } // Ensures that output_file is //.cpp bool ValidateOutputFilePath(const string& output_file, const Options& options, const AidlDefinedType& defined_type) { const auto& out_dir = !options.OutputDir().empty() ? options.OutputDir() : options.OutputHeaderDir(); if (output_file.empty() || !android::base::StartsWith(output_file, out_dir)) { // If output_file is not set (which happens in the unit tests) or is outside of out_dir, we can // help but accepting it, because the path is what the user has requested. return true; } string canonical_name = defined_type.GetCanonicalName(); std::replace(canonical_name.begin(), canonical_name.end(), '.', OS_PATH_SEPARATOR); const string expected = out_dir + canonical_name + ".cpp"; if (expected != output_file) { AIDL_ERROR(defined_type) << "Output file is expected to be at " << expected << ", but is " << output_file << ".\n If this is an Android platform " << "build, consider providing the input AIDL files using a filegroup " << "with `path:\"\"` so that the AIDL files are located at " << "//.aidl."; return false; } return true; } void EnterNamespace(CodeWriter& out, const AidlDefinedType& defined_type) { const std::vector packages = defined_type.GetSplitPackage(); for (const std::string& package : packages) { out << "namespace " << package << " {\n"; } } void LeaveNamespace(CodeWriter& out, const AidlDefinedType& defined_type) { const std::vector packages = defined_type.GetSplitPackage(); for (auto it = packages.rbegin(); it != packages.rend(); ++it) { out << "} // namespace " << *it << "\n"; } } string BuildVarName(const AidlArgument& a) { string prefix = "out_"; if (a.GetDirection() & AidlArgument::IN_DIR) { prefix = "in_"; } return prefix + a.GetName(); } void WriteLogForArgument(CodeWriter& w, const AidlArgument& a, bool is_server, const string& log_var, bool is_ndk) { const string var_name = is_server || is_ndk ? BuildVarName(a) : a.GetName(); const bool is_pointer = a.IsOut() && !is_server; const string value_expr = (is_pointer ? "*" : "") + var_name; w << log_var << ".emplace_back(\"" + var_name + "\", ::android::internal::ToString(" + value_expr + "));\n"; } const string GenLogBeforeExecute(const string className, const AidlMethod& method, bool isServer, bool isNdk) { string code; CodeWriterPtr writer = CodeWriter::ForString(&code); (*writer) << className << "::TransactionLog _transaction_log;\n"; (*writer) << "if (" << className << "::logFunc != nullptr) {\n"; (*writer).Indent(); for (const auto& a : method.GetInArguments()) { WriteLogForArgument(*writer, *a, isServer, "_transaction_log.input_args", isNdk); } (*writer).Dedent(); (*writer) << "}\n"; (*writer) << "auto _log_start = std::chrono::steady_clock::now();\n"; writer->Close(); return code; } const string GenLogAfterExecute(const string className, const AidlInterface& interface, const AidlMethod& method, const string& statusVarName, const string& returnVarName, bool isServer, bool isNdk) { string code; CodeWriterPtr writer = CodeWriter::ForString(&code); (*writer) << "if (" << className << "::logFunc != nullptr) {\n"; (*writer).Indent(); const auto address = (isNdk && isServer) ? "_aidl_impl.get()" : "static_cast(this)"; (*writer) << "auto _log_end = std::chrono::steady_clock::now();\n"; (*writer) << "_transaction_log.duration_ms = std::chrono::duration(_log_end " "- _log_start).count();\n"; (*writer) << "_transaction_log.interface_name = \"" << interface.GetCanonicalName() << "\";\n"; (*writer) << "_transaction_log.method_name = \"" << method.GetName() << "\";\n"; (*writer) << "_transaction_log.stub_address = " << (isServer ? address : "nullptr") << ";\n"; (*writer) << "_transaction_log.proxy_address = " << (isServer ? "nullptr" : address) << ";\n"; if (isNdk) { (*writer) << "_transaction_log.exception_code = AStatus_getExceptionCode(" << statusVarName << ".get());\n"; (*writer) << "_transaction_log.exception_message = AStatus_getMessage(" << statusVarName << ".get());\n"; (*writer) << "_transaction_log.transaction_error = AStatus_getStatus(" << statusVarName << ".get());\n"; (*writer) << "_transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(" << statusVarName << ".get());\n"; } else { (*writer) << "_transaction_log.exception_code = " << statusVarName << ".exceptionCode();\n"; (*writer) << "_transaction_log.exception_message = " << statusVarName << ".exceptionMessage();\n"; (*writer) << "_transaction_log.transaction_error = " << statusVarName << ".transactionError();\n"; (*writer) << "_transaction_log.service_specific_error_code = " << statusVarName << ".serviceSpecificErrorCode();\n"; } for (const auto& a : method.GetOutArguments()) { WriteLogForArgument(*writer, *a, isServer, "_transaction_log.output_args", isNdk); } if (method.GetType().GetName() != "void") { const string expr = (isServer ? "" : "*") + returnVarName; (*writer) << "_transaction_log.result = ::android::internal::ToString(" << expr << ");\n"; } // call the user-provided function with the transaction log object (*writer) << className << "::logFunc(_transaction_log);\n"; (*writer).Dedent(); (*writer) << "}\n"; writer->Close(); return code; } // Returns Parent1::Parent2::Self. Namespaces are not included. string GetQualifiedName(const AidlDefinedType& type, ClassNames class_names) { string q_name = ClassName(type, class_names); for (auto parent = type.GetParentType(); parent; parent = parent->GetParentType()) { q_name = ClassName(*parent, ClassNames::MAYBE_INTERFACE) + "::" + q_name; } return q_name; } // Generates enum's class declaration. This should be called in a proper scope. For example, in its // namespace or parent type. void GenerateEnumClassDecl(CodeWriter& out, const AidlEnumDeclaration& enum_decl, const std::string& backing_type, ConstantValueDecorator decorator) { out << "enum class"; GenerateDeprecated(out, enum_decl); out << " " << enum_decl.GetName() << " : " << backing_type << " {\n"; out.Indent(); for (const auto& enumerator : enum_decl.GetEnumerators()) { out << enumerator->GetName(); GenerateDeprecated(out, *enumerator); out << " = " << enumerator->ValueString(enum_decl.GetBackingType(), decorator) << ",\n"; } out.Dedent(); out << "};\n"; } static bool IsEnumDeprecated(const AidlEnumDeclaration& enum_decl) { if (enum_decl.IsDeprecated()) { return true; } for (const auto& e : enum_decl.GetEnumerators()) { if (e->IsDeprecated()) { return true; } } return false; } // enum_values template value is defined in its own namespace (android::internal or ndk::internal), // so the enum_decl type should be fully qualified. std::string GenerateEnumValues(const AidlEnumDeclaration& enum_decl, const std::vector& enclosing_namespaces_of_enum_decl) { const auto fq_name = Join(Append(enclosing_namespaces_of_enum_decl, enum_decl.GetSplitPackage()), "::") + "::" + GetQualifiedName(enum_decl); const auto size = enum_decl.GetEnumerators().size(); std::ostringstream code; code << "#pragma clang diagnostic push\n"; code << "#pragma clang diagnostic ignored \"-Wc++17-extensions\"\n"; if (IsEnumDeprecated(enum_decl)) { code << "#pragma clang diagnostic ignored \"-Wdeprecated-declarations\"\n"; } code << "template <>\n"; code << "constexpr inline std::array<" << fq_name << ", " << size << ">"; code << " enum_values<" << fq_name << "> = {\n"; for (const auto& enumerator : enum_decl.GetEnumerators()) { code << " " << fq_name << "::" << enumerator->GetName() << ",\n"; } code << "};\n"; code << "#pragma clang diagnostic pop\n"; return code.str(); } // toString(enum_type) is defined in the same namespace of the type. // So, if enum_decl is nested in parent type(s), it should be qualified with parent type(s). std::string GenerateEnumToString(const AidlEnumDeclaration& enum_decl, const std::string& backing_type) { const auto q_name = GetQualifiedName(enum_decl); std::ostringstream code; bool is_enum_deprecated = IsEnumDeprecated(enum_decl); if (is_enum_deprecated) { code << "#pragma clang diagnostic push\n"; code << "#pragma clang diagnostic ignored \"-Wdeprecated-declarations\"\n"; } code << "[[nodiscard]] static inline std::string toString(" + q_name + " val) {\n"; code << " switch(val) {\n"; std::set unique_cases; for (const auto& enumerator : enum_decl.GetEnumerators()) { std::string c = enumerator->ValueString(enum_decl.GetBackingType(), AidlConstantValueDecorator); // Only add a case if its value has not yet been used in the switch // statement. C++ does not allow multiple cases with the same value, but // enums does allow this. In this scenario, the first declared // enumerator with the given value is printed. if (unique_cases.count(c) == 0) { unique_cases.insert(c); code << " case " << q_name << "::" << enumerator->GetName() << ":\n"; code << " return \"" << enumerator->GetName() << "\";\n"; } } code << " default:\n"; code << " return std::to_string(static_cast<" << backing_type << ">(val));\n"; code << " }\n"; code << "}\n"; if (is_enum_deprecated) { code << "#pragma clang diagnostic pop\n"; } return code.str(); } std::string TemplateDecl(const AidlParcelable& defined_type) { std::string decl = ""; if (defined_type.IsGeneric()) { std::vector template_params; for (const auto& parameter : defined_type.GetTypeParameters()) { template_params.push_back(parameter); } decl = base::StringPrintf("template \n", base::Join(template_params, ", typename ").c_str()); } return decl; } void GenerateParcelableComparisonOperators(CodeWriter& out, const AidlParcelable& parcelable) { std::set operators{"<", ">", "==", ">=", "<=", "!="}; if (parcelable.AsUnionDeclaration() && parcelable.IsFixedSize()) { auto name = parcelable.GetName(); auto max_tag = parcelable.GetFields().back()->GetName(); auto min_tag = parcelable.GetFields().front()->GetName(); constexpr auto tmpl = R"--(static int _cmp(const {name}& _lhs, const {name}& _rhs) {{ return _cmp_value(_lhs.getTag(), _rhs.getTag()) || _cmp_value_at<{max_tag}>(_lhs, _rhs); }} template static int _cmp_value_at(const {name}& _lhs, const {name}& _rhs) {{ if constexpr (_Tag == {min_tag}) {{ return _cmp_value(_lhs.get<_Tag>(), _rhs.get<_Tag>()); }} else {{ return (_lhs.getTag() == _Tag) ? _cmp_value(_lhs.get<_Tag>(), _rhs.get<_Tag>()) : _cmp_value_at(static_cast(_Tag)-1)>(_lhs, _rhs); }} }} template static int _cmp_value(const _Type& _lhs, const _Type& _rhs) {{ return (_lhs == _rhs) ? 0 : (_lhs < _rhs) ? -1 : 1; }} )--"; out << fmt::format(tmpl, fmt::arg("name", name), fmt::arg("min_tag", min_tag), fmt::arg("max_tag", max_tag)); for (const auto& op : operators) { out << "inline bool operator" << op << "(const " << name << "&_rhs) const {\n"; out << " return _cmp(*this, _rhs) " << op << " 0;\n"; out << "}\n"; } return; } bool is_empty = false; auto comparable = [&](const string& prefix) { vector fields; if (auto p = parcelable.AsStructuredParcelable(); p != nullptr) { is_empty = p->GetFields().empty(); for (const auto& f : p->GetFields()) { fields.push_back(prefix + f->GetName()); } return "std::tie(" + Join(fields, ", ") + ")"; } else if (auto p = parcelable.AsUnionDeclaration(); p != nullptr) { return prefix + "_value"; } else { AIDL_FATAL(parcelable) << "Unknown paracelable type"; } }; string lhs = comparable(""); string rhs = comparable("_rhs."); // Delegate < and == to the fields. for (const auto& op : {"==", "<"}) { out << "inline bool operator" << op << "(const " << parcelable.GetName() << "&" << (is_empty ? "" : " _rhs") << ") const {\n" << " return " << lhs << " " << op << " " << rhs << ";\n" << "}\n"; } // Delegate other ops to < and == for *this, which lets a custom parcelable // to be used with structured parcelables without implementation all operations. out << fmt::format(R"--(inline bool operator!=(const {name}& _rhs) const {{ return !(*this == _rhs); }} inline bool operator>(const {name}& _rhs) const {{ return _rhs < *this; }} inline bool operator>=(const {name}& _rhs) const {{ return !(*this < _rhs); }} inline bool operator<=(const {name}& _rhs) const {{ return !(_rhs < *this); }} )--", fmt::arg("name", parcelable.GetName())); out << "\n"; } // Output may look like: // inline std::string toString() const { // std::ostringstream _aidl_os; // _aidl_os << "MyData{"; // _aidl_os << "field1: " << field1; // _aidl_os << ", field2: " << v.field2; // ... // _aidl_os << "}"; // return _aidl_os.str(); // } void GenerateToString(CodeWriter& out, const AidlStructuredParcelable& parcelable) { out << "inline std::string toString() const {\n"; out.Indent(); out << "std::ostringstream _aidl_os;\n"; out << "_aidl_os << \"" << parcelable.GetName() << "{\";\n"; bool first = true; for (const auto& f : parcelable.GetFields()) { if (first) { out << "_aidl_os << \""; first = false; } else { out << "_aidl_os << \", "; } out << f->GetName() << ": \" << ::android::internal::ToString(" << f->GetName() << ");\n"; } out << "_aidl_os << \"}\";\n"; out << "return _aidl_os.str();\n"; out.Dedent(); out << "}\n"; } // Output may look like: // inline std::string toString() const { // std::ostringstream os; // os << "MyData{"; // switch (v.getTag()) { // case MyData::field: os << "field: " << v.get(); break; // ... // } // os << "}"; // return os.str(); // } void GenerateToString(CodeWriter& out, const AidlUnionDecl& parcelable) { out << "inline std::string toString() const {\n"; out.Indent(); out << "std::ostringstream os;\n"; out << "os << \"" + parcelable.GetName() + "{\";\n"; out << "switch (getTag()) {\n"; for (const auto& f : parcelable.GetFields()) { const string tag = f->GetName(); out << "case " << tag << ": os << \"" << tag << ": \" << " << "::android::internal::ToString(get<" + tag + ">()); break;\n"; } out << "}\n"; out << "os << \"}\";\n"; out << "return os.str();\n"; out.Dedent(); out << "}\n"; } std::string GetDeprecatedAttribute(const AidlCommentable& type) { if (auto deprecated = FindDeprecated(type.GetComments()); deprecated.has_value()) { if (deprecated->note.empty()) { return "__attribute__((deprecated))"; } return "__attribute__((deprecated(" + QuotedEscape(deprecated->note) + ")))"; } return ""; } size_t AlignmentOf(const AidlTypeSpecifier& type, const AidlTypenames& typenames) { static map alignment = { {"boolean", 1}, {"byte", 1}, {"char", 2}, {"double", 8}, {"float", 4}, {"int", 4}, {"long", 8}, }; string name = type.GetName(); if (auto enum_decl = typenames.GetEnumDeclaration(type); enum_decl) { name = enum_decl->GetBackingType().GetName(); } // default to 0 for parcelable types return alignment[name]; } std::set UnionWriter::GetHeaders(const AidlUnionDecl& decl) { std::set union_headers = { "cassert", // __assert for logging "type_traits", // std::is_same_v "utility", // std::mode/forward for value "variant", // union's impl }; if (decl.IsFixedSize()) { union_headers.insert("tuple"); // fixed-sized union's typelist } return union_headers; } // fixed-sized union class looks like: // class Union { // public: // enum Tag : uint8_t { // field1 = 0, // field2, // }; // ... methods ... // private: // Tag _tag; // union { // type1 field1; // type2 field2; // } _value; // }; void UnionWriter::PrivateFields(CodeWriter& out) const { if (decl.IsFixedSize()) { AIDL_FATAL_IF(decl.GetFields().empty(), decl) << "Union '" << decl.GetName() << "' is empty."; const auto& first_field = decl.GetFields()[0]; const auto& default_name = first_field->GetName(); const auto& default_value = name_of(first_field->GetType(), typenames) + "(" + first_field->ValueString(decorator) + ")"; out << "Tag _tag = " << default_name << ";\n"; out << "union _value_t {\n"; out.Indent(); out << "_value_t() {}\n"; out << "~_value_t() {}\n"; for (const auto& f : decl.GetFields()) { const auto& fn = f->GetName(); out << name_of(f->GetType(), typenames) << " " << fn; if (decl.IsFixedSize()) { int alignment = AlignmentOf(f->GetType(), typenames); if (alignment > 0) { out << " __attribute__((aligned (" << std::to_string(alignment) << ")))"; } } if (fn == default_name) { out << " = " << default_value; } out << ";\n"; } out.Dedent(); out << "} _value;\n"; } else { vector field_types; for (const auto& f : decl.GetFields()) { field_types.push_back(name_of(f->GetType(), typenames)); } out << "std::variant<" + Join(field_types, ", ") + "> _value;\n"; } } void UnionWriter::PublicFields(CodeWriter& out) const { out << "// Expose tag symbols for legacy code\n"; for (const auto& f : decl.GetFields()) { out << "static const inline Tag"; GenerateDeprecated(out, *f); out << " " << f->GetName() << " = Tag::" << f->GetName() << ";\n"; } const auto& name = decl.GetName(); if (decl.IsFixedSize()) { vector field_types; for (const auto& f : decl.GetFields()) { field_types.push_back(name_of(f->GetType(), typenames)); } auto typelist = Join(field_types, ", "); constexpr auto tmpl = R"--( template using _at = typename std::tuple_element(_Tag), std::tuple<{typelist}>>::type; template static {name} make(_Type&& _arg) {{ {name} _inst; _inst.set<_Tag>(std::forward<_Type>(_arg)); return _inst; }} constexpr Tag getTag() const {{ return _tag; }} template const _at<_Tag>& get() const {{ if (_Tag != _tag) {{ __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); }} return *(_at<_Tag>*)(&_value); }} template _at<_Tag>& get() {{ if (_Tag != _tag) {{ __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); }} return *(_at<_Tag>*)(&_value); }} template void set(_Type&& _arg) {{ _tag = _Tag; get<_Tag>() = std::forward<_Type>(_arg); }} )--"; out << fmt::format(tmpl, fmt::arg("name", name), fmt::arg("typelist", typelist)); } else { AIDL_FATAL_IF(decl.GetFields().empty(), decl) << "Union '" << name << "' is empty."; const auto& first_field = decl.GetFields()[0]; const auto& default_name = first_field->GetName(); const auto& default_value = name_of(first_field->GetType(), typenames) + "(" + first_field->ValueString(decorator) + ")"; constexpr auto tmpl = R"--( template static constexpr bool _not_self = !std::is_same_v>, {name}>; {name}() : _value(std::in_place_index({default_name})>, {default_value}) {{ }} template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr {name}(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {{}} template constexpr explicit {name}(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {{}} template static {name} make(_Tp&&... _args) {{ return {name}(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); }} template static {name} make(std::initializer_list<_Tp> _il, _Up&&... _args) {{ return {name}(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); }} Tag getTag() const {{ return static_cast(_value.index()); }} template const auto& get() const {{ if (getTag() != _tag) {{ __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); }} return std::get(_tag)>(_value); }} template auto& get() {{ if (getTag() != _tag) {{ __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); }} return std::get(_tag)>(_value); }} template void set(_Tp&&... _args) {{ _value.emplace(_tag)>(std::forward<_Tp>(_args)...); }} )--"; out << fmt::format(tmpl, fmt::arg("name", name), fmt::arg("default_name", default_name), fmt::arg("default_value", default_value)); } } void UnionWriter::ReadFromParcel(CodeWriter& out, const ParcelWriterContext& ctx) const { // Even though @FixedSize union may use a smaller type than int32_t, we need to read/write it // as if it is int32_t for compatibility with other bckends. auto tag_type = typenames.MakeResolvedType(AIDL_LOCATION_HERE, "int", /* is_array= */ false); const string tag = "_aidl_tag"; const string value = "_aidl_value"; const string status = "_aidl_ret_status"; auto read_var = [&](const string& var, const AidlTypeSpecifier& type) { out << fmt::format("{} {};\n", name_of(type, typenames), var); out << fmt::format("if (({} = ", status); ctx.read_func(out, var, type); out << fmt::format(") != {}) return {};\n", ctx.status_ok, status); }; out << fmt::format("{} {};\n", ctx.status_type, status); read_var(tag, *tag_type); out << fmt::format("switch (static_cast({})) {{\n", tag); for (const auto& variable : decl.GetFields()) { out << fmt::format("case {}: {{\n", variable->GetName()); out.Indent(); if (variable->IsNew()) { out << fmt::format("if (true) return {};\n", ctx.status_bad); } const auto& type = variable->GetType(); read_var(value, type); out << fmt::format("if constexpr (std::is_trivially_copyable_v<{}>) {{\n", name_of(type, typenames)); out.Indent(); out << fmt::format("set<{}>({});\n", variable->GetName(), value); out.Dedent(); out << "} else {\n"; out.Indent(); // Even when the `if constexpr` is false, the compiler runs the tidy check for the // next line, which doesn't make sense. Silence the check for the unreachable code. out << "// NOLINTNEXTLINE(performance-move-const-arg)\n"; out << fmt::format("set<{}>(std::move({}));\n", variable->GetName(), value); out.Dedent(); out << "}\n"; out << fmt::format("return {}; }}\n", ctx.status_ok); out.Dedent(); } out << "}\n"; out << fmt::format("return {};\n", ctx.status_bad); } void UnionWriter::WriteToParcel(CodeWriter& out, const ParcelWriterContext& ctx) const { // Even though @FixedSize union may use a smaller type than int32_t, we need to read/write it // as if it is int32_t for compatibility with other bckends. auto tag_type = typenames.MakeResolvedType(AIDL_LOCATION_HERE, "int", /* is_array= */ false); const string tag = "_aidl_tag"; const string value = "_aidl_value"; const string status = "_aidl_ret_status"; out << fmt::format("{} {} = ", ctx.status_type, status); ctx.write_func(out, "static_cast(getTag())", *tag_type); out << ";\n"; out << fmt::format("if ({} != {}) return {};\n", status, ctx.status_ok, status); out << "switch (getTag()) {\n"; for (const auto& variable : decl.GetFields()) { if (variable->IsDeprecated()) { out << "#pragma clang diagnostic push\n"; out << "#pragma clang diagnostic ignored \"-Wdeprecated-declarations\"\n"; } if (variable->IsNew()) { out << fmt::format("case {}: return true ? {} : ", variable->GetName(), ctx.status_bad); } else { out << fmt::format("case {}: return ", variable->GetName()); } ctx.write_func(out, "get<" + variable->GetName() + ">()", variable->GetType()); out << ";\n"; if (variable->IsDeprecated()) { out << "#pragma clang diagnostic pop\n"; } } out << "}\n"; out << "__assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, \"can't reach here\");\n"; } std::string CppConstantValueDecorator( const AidlTypeSpecifier& type, const std::variant>& raw_value, bool is_ndk) { if (type.IsArray()) { auto values = std::get>(raw_value); // Hexadecimal literals for byte arrays should be casted to uint8_t if (type.GetName() == "byte" && std::any_of(values.begin(), values.end(), [](const auto& value) { return !value.empty() && value[0] == '-'; })) { for (auto& value : values) { // cast only if necessary if (value[0] == '-') { value = "uint8_t(" + value + ")"; } } } std::string value = "{" + Join(values, ", ") + "}"; if (type.IsFixedSizeArray()) { // For arrays, use double braces because arrays can be nested. // e.g.) array, 3> ints = {{ {{1,2}}, {{3,4}}, {{5,6}} }}; // Vectors might need double braces, but since we don't have nested vectors (yet) // single brace would work even for optional vectors. value = "{" + value + "}"; } if (!type.IsMutated() && type.IsNullable()) { // For outermost std::optional<>, we need an additional brace pair to initialize its value. value = "{" + value + "}"; } return value; } const std::string& value = std::get(raw_value); if (AidlTypenames::IsBuiltinTypename(type.GetName())) { if (type.GetName() == "boolean") { return value; } else if (type.GetName() == "byte") { return value; } else if (type.GetName() == "char") { // TODO: consider 'L'-prefix for wide char literal return value; } else if (type.GetName() == "double") { return value; } else if (type.GetName() == "float") { return value; // value has 'f' suffix } else if (type.GetName() == "int") { return value; } else if (type.GetName() == "long") { return value + "L"; } else if (type.GetName() == "String") { if (is_ndk || type.IsUtf8InCpp()) { return value; } else { return "::android::String16(" + value + ")"; } } AIDL_FATAL(type) << "Unknown built-in type: " << type.GetName(); } auto defined_type = type.GetDefinedType(); AIDL_FATAL_IF(!defined_type, type) << "Invalid type for \"" << value << "\""; auto enum_type = defined_type->AsEnumDeclaration(); AIDL_FATAL_IF(!enum_type, type) << "Invalid type for \"" << value << "\""; auto cpp_type_name = "::" + Join(Split(enum_type->GetCanonicalName(), "."), "::"); if (is_ndk) { cpp_type_name = "::aidl" + cpp_type_name; } return cpp_type_name + "::" + value.substr(value.find_last_of('.') + 1); } // Collect all forward declarations for the type's interface header. // Nested types are visited as well via VisitTopDown. void GenerateForwardDecls(CodeWriter& out, const AidlDefinedType& root_type, bool is_ndk) { struct Visitor : AidlVisitor { using PackagePath = std::vector; struct ClassDeclInfo { std::string template_decl; }; std::map> classes; // Collect class names for each interface or parcelable type void Visit(const AidlTypeSpecifier& type) override { const auto defined_type = type.GetDefinedType(); if (defined_type && !defined_type->GetParentType()) { // Forward declarations are not supported for nested types auto package = defined_type->GetSplitPackage(); if (defined_type->AsInterface() != nullptr) { auto name = ClassName(*defined_type, ClassNames::INTERFACE); classes[package][std::move(name)] = ClassDeclInfo(); } else if (auto* p = defined_type->AsStructuredParcelable(); p != nullptr) { auto name = defined_type->GetName(); ClassDeclInfo info; info.template_decl = TemplateDecl(*p); classes[package][std::move(name)] = std::move(info); } } } } v; VisitTopDown(v, root_type); if (v.classes.empty()) { return; } for (const auto& it : v.classes) { auto package = it.first; auto& classes = it.second; if (is_ndk) { package.insert(package.begin(), "aidl"); } std::string namespace_name = Join(package, "::"); if (!namespace_name.empty()) { out << "namespace " << namespace_name << " {\n"; } for (const auto& [name, info] : classes) { out << info.template_decl << "class " << name << ";\n"; } if (!namespace_name.empty()) { out << "} // namespace " << namespace_name << "\n"; } } } } // namespace cpp } // namespace aidl } // namespace android ./PaxHeaders.X/aidl_to_cpp_common.h0100644 0000000 0000000 00000000034 15172120304 016272 xustar000000000 0000000 28 mtime=1776853188.2930000 aidl_to_cpp_common.h0100644 0000000 0000000 00000014237 15172120304 013605 0ustar000000000 0000000 /* * Copyright (C) 2018, The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #pragma once #include #include #include #include "aidl_language.h" // This is used to help generate code targetting C++ (the language) whether using the libbinder or // libbinder_ndk backend. namespace android { namespace aidl { namespace cpp { extern char kTransactionLogStruct[]; // These roughly correspond to the various class names in the C++ hierarchy: enum class ClassNames { BASE, // Foo (not a real class, but useful in some circumstances). CLIENT, // BpFoo SERVER, // BnFoo INTERFACE, // IFoo DEFAULT_IMPL, // IFooDefault RAW, // (as shown in the file) DELEGATOR_IMPL, // IFooDelegator MAYBE_INTERFACE, // == INTERFACE for AidlInterface, == RAW for other types }; string ClassName(const AidlDefinedType& defined_type, ClassNames type); // Return the alignment of known types and enum backing types. // If the alignment is unknown, or it is a FizedSize parcelable with its // own guaranteed alignment(so it does not need to be specified), 0 will be // returned. size_t AlignmentOf(const AidlTypeSpecifier& type, const AidlTypenames& typenames); // Generate the relative path to a header file. If |use_os_sep| we'll use the // operating system specific path separator rather than C++'s expected '/' when // including headers. std::string HeaderFile(const AidlDefinedType& defined_type, ClassNames class_type, bool use_os_sep = true); bool ValidateOutputFilePath(const string& output_file, const Options& options, const AidlDefinedType& defined_type); void EnterNamespace(CodeWriter& out, const AidlDefinedType& defined_type); void LeaveNamespace(CodeWriter& out, const AidlDefinedType& defined_type); string BuildVarName(const AidlArgument& a); const string GenLogBeforeExecute(const string className, const AidlMethod& method, bool isServer, bool isNdk); const string GenLogAfterExecute(const string className, const AidlInterface& interface, const AidlMethod& method, const string& statusVarName, const string& returnVarName, bool isServer, bool isNdk); template >> std::vector Append(std::vector as, const std::vector& bs) { as.insert(as.end(), bs.begin(), bs.end()); return as; } template std::vector Append(std::vector&& as, std::vector&& bs) { std::vector appended = std::move(as); std::copy(std::move_iterator(bs.begin()), std::move_iterator(bs.end()), std::back_inserter(appended)); return appended; } // Returns Parent1::Parent2::Self. Namespaces are not included. std::string GetQualifiedName(const AidlDefinedType& type, ClassNames name = ClassNames::RAW); void GenerateEnumClassDecl(CodeWriter& out, const AidlEnumDeclaration& enum_decl, const std::string& backing_type, ::ConstantValueDecorator decorator); std::string GenerateEnumToString(const AidlEnumDeclaration& enum_decl, const std::string& backing_type); std::string GenerateEnumValues(const AidlEnumDeclaration& enum_decl, const std::vector& enclosing_namespaces_of_enum_decl); std::string TemplateDecl(const AidlParcelable& defined_type); void GenerateParcelableComparisonOperators(CodeWriter& out, const AidlParcelable& parcelable); void GenerateToString(CodeWriter& out, const AidlStructuredParcelable& parcelable); void GenerateToString(CodeWriter& out, const AidlUnionDecl& parcelable); std::string GetDeprecatedAttribute(const AidlCommentable& type); template void GenerateDeprecated(Stream& out, const AidlCommentable& type) { if (auto deprecated = GetDeprecatedAttribute(type); !deprecated.empty()) { out << " " + deprecated; } } struct ParcelWriterContext { string status_type; string status_ok; string status_bad; std::function read_func; std::function write_func; }; struct UnionWriter { const AidlUnionDecl& decl; const AidlTypenames& typenames; const std::function name_of; const ::ConstantValueDecorator& decorator; static std::set GetHeaders(const AidlUnionDecl&); void PrivateFields(CodeWriter& out) const; void PublicFields(CodeWriter& out) const; void ReadFromParcel(CodeWriter& out, const ParcelWriterContext&) const; void WriteToParcel(CodeWriter& out, const ParcelWriterContext&) const; }; std::string CppConstantValueDecorator( const AidlTypeSpecifier& type, const std::variant>& raw_value, bool is_ndk); void GenerateForwardDecls(CodeWriter& out, const AidlDefinedType& root_type, bool is_ndk); struct ClangDiagnosticIgnoreDeprecated { CodeWriter& out; bool deprecated; ClangDiagnosticIgnoreDeprecated(CodeWriter& out, bool deprecated) : out(out), deprecated(deprecated) { // enter if (deprecated) { out << "#pragma clang diagnostic push\n"; out << "#pragma clang diagnostic ignored \"-Wdeprecated-declarations\"\n"; } } ~ClangDiagnosticIgnoreDeprecated() { // exit if (deprecated) { out << "#pragma clang diagnostic pop\n"; } } }; bool HasDeprecatedField(const AidlParcelable& parcelable); } // namespace cpp } // namespace aidl } // namespace android ./PaxHeaders.X/aidl_to_java.cpp0100644 0000000 0000000 00000000034 15172120304 015414 xustar000000000 0000000 28 mtime=1776853188.2940000 aidl_to_java.cpp0100644 0000000 0000000 00000113077 15172120304 012731 0ustar000000000 0000000 /* * Copyright (C) 2018, The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "aidl_to_java.h" #include "aidl_language.h" #include "aidl_typenames.h" #include "logging.h" #include #include #include #include #include #include namespace android { namespace aidl { namespace java { using android::base::Join; using std::function; using std::map; using std::string; using std::vector; std::string ConstantValueDecorator( const AidlTypeSpecifier& type, const std::variant>& raw_value) { if (type.IsArray()) { const auto& values = std::get>(raw_value); return "{" + Join(values, ", ") + "}"; } const std::string& value = std::get(raw_value); if (type.GetName() == "long") { return value + "L"; } if (auto defined_type = type.GetDefinedType(); defined_type) { auto enum_type = defined_type->AsEnumDeclaration(); AIDL_FATAL_IF(!enum_type, type) << "Invalid type for \"" << value << "\""; return type.GetName() + "." + value.substr(value.find_last_of('.') + 1); } return value; }; const string& JavaNameOf(const AidlTypeSpecifier& aidl, bool instantiable = false, bool boxing = false) { AIDL_FATAL_IF(!aidl.IsResolved(), aidl) << aidl.ToString(); if (instantiable) { // An instantiable type is used in only out type(not even inout type), // And instantiable type has to be either the type in List, Map, ParcelFileDescriptor or // user-defined type. static map instantiable_m = { {"List", "java.util.ArrayList"}, {"Map", "java.util.HashMap"}, {"ParcelFileDescriptor", "android.os.ParcelFileDescriptor"}, }; const string& aidl_name = aidl.GetName(); if (instantiable_m.find(aidl_name) != instantiable_m.end()) { return instantiable_m[aidl_name]; } } // map from AIDL built-in type name to the corresponding Java type name static map m = { {"void", "void"}, {"boolean", "boolean"}, {"byte", "byte"}, {"char", "char"}, {"int", "int"}, {"long", "long"}, {"float", "float"}, {"double", "double"}, {"String", "java.lang.String"}, {"List", "java.util.List"}, {"Map", "java.util.Map"}, {"IBinder", "android.os.IBinder"}, {"FileDescriptor", "java.io.FileDescriptor"}, {"CharSequence", "java.lang.CharSequence"}, {"ParcelFileDescriptor", "android.os.ParcelFileDescriptor"}, {"ParcelableHolder", "android.os.ParcelableHolder"}, }; // map from primitive types to the corresponding boxing types static map boxing_types = { {"void", "Void"}, {"boolean", "Boolean"}, {"byte", "Byte"}, {"char", "Character"}, {"int", "Integer"}, {"long", "Long"}, {"float", "Float"}, {"double", "Double"}, }; // Enums in Java are represented by their backing type when // referenced in parcelables, methods, etc. const auto defined_type = aidl.GetDefinedType(); if (defined_type && defined_type->AsEnumDeclaration()) { const auto enum_decl = defined_type->AsEnumDeclaration(); const string& backing_type_name = enum_decl->GetBackingType().GetName(); AIDL_FATAL_IF(m.find(backing_type_name) == m.end(), enum_decl); AIDL_FATAL_IF(!AidlTypenames::IsBuiltinTypename(backing_type_name), enum_decl); if (boxing) { return boxing_types[backing_type_name]; } else { return m[backing_type_name]; } } const string& aidl_name = aidl.GetName(); if (boxing && AidlTypenames::IsPrimitiveTypename(aidl_name)) { // Every primitive type must have the corresponding boxing type AIDL_FATAL_IF(boxing_types.find(aidl_name) == m.end(), aidl); return boxing_types[aidl_name]; } if (m.find(aidl_name) != m.end()) { AIDL_FATAL_IF(!AidlTypenames::IsBuiltinTypename(aidl_name), aidl); return m[aidl_name]; } else { // 'foo.bar.IFoo' in AIDL maps to 'foo.bar.IFoo' in Java return aidl_name; } } namespace { string JavaSignatureOfInternal(const AidlTypeSpecifier& aidl, bool instantiable, bool omit_array, bool boxing) { string ret = JavaNameOf(aidl, instantiable, boxing && !aidl.IsArray()); if (aidl.IsGeneric()) { vector arg_names; for (const auto& ta : aidl.GetTypeParameters()) { arg_names.emplace_back(JavaSignatureOfInternal(*ta, /*instantiable=*/false, /*omit_array=*/false, /*boxing=*/true)); } ret += "<" + Join(arg_names, ",") + ">"; } if (aidl.IsArray() && !omit_array) { if (aidl.IsFixedSizeArray()) { ret += Join(std::vector(aidl.GetFixedSizeArrayDimensions().size(), "[]"), ""); } else { ret += "[]"; } } return ret; } // Returns the name of the backing type for the specified type. // Note: Do not use the result in the generated code! It's supposed to be used as a key. // This returns type names as used in AIDL, not a Java signature. // For enums, this is the enum's backing type. // For all other types, this is the type itself. string AidlBackingTypeName(const AidlTypeSpecifier& type) { string type_name; const auto defined_type = type.GetDefinedType(); if (defined_type && defined_type->AsEnumDeclaration()) { const AidlEnumDeclaration* enum_decl = defined_type->AsEnumDeclaration(); type_name = enum_decl->GetBackingType().GetName(); } else { type_name = type.GetName(); } if (type.IsArray()) { if (type.IsFixedSizeArray()) { for (const auto& dim : type.GetFixedSizeArrayDimensions()) { type_name += "[" + std::to_string(dim) + "]"; } } else { type_name += "[]"; } } return type_name; } } // namespace string JavaSignatureOf(const AidlTypeSpecifier& aidl) { return JavaSignatureOfInternal(aidl, /*instantiable=*/false, /*omit_array=*/false, /*boxing=*/false); } // Used for "new" expression. Ignore arrays because "new" expression handles it. string InstantiableJavaSignatureOf(const AidlTypeSpecifier& aidl) { return JavaSignatureOfInternal(aidl, /*instantiable=*/true, /*omit_array=*/true, /*boxing=*/false); } string JavaBoxingTypeOf(const AidlTypeSpecifier& aidl) { AIDL_FATAL_IF(!AidlTypenames::IsPrimitiveTypename(aidl.GetName()), aidl); return JavaSignatureOfInternal(aidl, /*instantiable=*/false, /*omit_array=*/false, /*boxing=*/true); } string DefaultJavaValueOf(const AidlTypeSpecifier& aidl) { static map m = { {"boolean", "false"}, {"byte", "0"}, {"char", R"('\u0000')"}, {"int", "0"}, {"long", "0L"}, {"float", "0.0f"}, {"double", "0.0d"}, }; const string name = AidlBackingTypeName(aidl); AIDL_FATAL_IF(name == "void", aidl); if (!aidl.IsArray() && m.find(name) != m.end()) { AIDL_FATAL_IF(!AidlTypenames::IsBuiltinTypename(name), aidl); return m[name]; } else { return "null"; } } typedef void (*ParcelHelperGenerator)(CodeWriter&, const Options&); static void GenerateTypedObjectHelper(CodeWriter& out, const Options&) { // Note that the name is inconsistent here because Parcel.java defines readTypedObject as if it // "creates" a new value from a parcel. "in-place" read function is not necessary because // user-defined parcelable defines its readFromParcel. out << R"(static private T readTypedObject( android.os.Parcel parcel, android.os.Parcelable.Creator c) { if (parcel.readInt() != 0) { return c.createFromParcel(parcel); } else { return null; } } static private void writeTypedObject( android.os.Parcel parcel, T value, int parcelableFlags) { if (value != null) { parcel.writeInt(1); value.writeToParcel(parcel, parcelableFlags); } else { parcel.writeInt(0); } } )"; } static void GenerateTypedListHelper(CodeWriter& out, const Options& options) { out << R"(static private void writeTypedList( android.os.Parcel parcel, java.util.List value, int parcelableFlags) { if (value == null) { parcel.writeInt(-1); } else { int N = value.size(); int i = 0; parcel.writeInt(N); while (i < N) { )"; if (options.GetMinSdkVersion() < 23u) { out << "writeTypedObject(parcel, value.get(i), parcelableFlags);"; } else { out << "parcel.writeTypedObject(value.get(i), parcelableFlags);"; } out << R"( i++; } } } )"; } void GenerateParcelHelpers(CodeWriter& out, const AidlDefinedType& defined_type, const AidlTypenames& typenames, const Options& options) { // root-level type contains all necessary helpers if (defined_type.GetParentType()) { return; } // visits method parameters and parcelable fields to collect types which // requires read/write/create helpers. struct Visitor : AidlVisitor { const AidlTypenames& typenames; const Options& options; set helpers; Visitor(const AidlTypenames& typenames, const Options& options) : typenames(typenames), options(options) {} void Visit(const AidlTypeSpecifier& type) override { auto name = type.GetName(); if (auto defined_type = type.GetDefinedType(); defined_type) { if (defined_type->AsParcelable() != nullptr && !type.IsArray()) { // TypedObjects are supported since 23. So we don't need helpers. if (options.GetMinSdkVersion() < 23u) { helpers.insert(&GenerateTypedObjectHelper); } } } else { // There's parcelable-like built-in types as well. if (name == "ParcelFileDescriptor" || name == "CharSequence") { if (!type.IsArray()) { // TypedObjects are supported since 23. So we don't need helpers. if (options.GetMinSdkVersion() < 23u) { helpers.insert(&GenerateTypedObjectHelper); } } } if (name == "List" && type.IsGeneric()) { const auto& element_name = type.GetTypeParameters()[0]->GetName(); if (typenames.IsParcelable(element_name) && options.GetMinSdkVersion() <= 33u) { helpers.insert(&GenerateTypedListHelper); } } } } } v{typenames, options}; VisitTopDown(v, defined_type); if (!v.helpers.empty()) { // Nested class (_Parcel) is used to contain static helper methods because some targets are // still using Java 7 which doesn't allow interfaces to have static methods. // Helpers shouldn't bother API checks, but in case where AIDL types are not marked `@hide` // explicitly marks the helper class as @hide. out << "/** @hide */\n"; out << "static class _Parcel {\n"; out.Indent(); for (const auto& helper : v.helpers) { helper(out, options); } out.Dedent(); out << "}\n"; } } void WriteToParcelFor(const CodeGeneratorContext& c) { static map> method_map{ {"boolean", [](const CodeGeneratorContext& c) { if (c.min_sdk_version >= 29u) { c.writer << c.parcel << ".writeBoolean(" << c.var << ");\n"; } else { c.writer << c.parcel << ".writeInt(((" << c.var << ")?(1):(0)));\n"; } }}, {"boolean[]", [](const CodeGeneratorContext& c) { c.writer << c.parcel << ".writeBooleanArray(" << c.var << ");\n"; }}, {"byte", [](const CodeGeneratorContext& c) { c.writer << c.parcel << ".writeByte(" << c.var << ");\n"; }}, {"byte[]", [](const CodeGeneratorContext& c) { c.writer << c.parcel << ".writeByteArray(" << c.var << ");\n"; }}, {"char", [](const CodeGeneratorContext& c) { c.writer << c.parcel << ".writeInt(((int)" << c.var << "));\n"; }}, {"char[]", [](const CodeGeneratorContext& c) { c.writer << c.parcel << ".writeCharArray(" << c.var << ");\n"; }}, {"int", [](const CodeGeneratorContext& c) { c.writer << c.parcel << ".writeInt(" << c.var << ");\n"; }}, {"int[]", [](const CodeGeneratorContext& c) { c.writer << c.parcel << ".writeIntArray(" << c.var << ");\n"; }}, {"long", [](const CodeGeneratorContext& c) { c.writer << c.parcel << ".writeLong(" << c.var << ");\n"; }}, {"long[]", [](const CodeGeneratorContext& c) { c.writer << c.parcel << ".writeLongArray(" << c.var << ");\n"; }}, {"float", [](const CodeGeneratorContext& c) { c.writer << c.parcel << ".writeFloat(" << c.var << ");\n"; }}, {"float[]", [](const CodeGeneratorContext& c) { c.writer << c.parcel << ".writeFloatArray(" << c.var << ");\n"; }}, {"double", [](const CodeGeneratorContext& c) { c.writer << c.parcel << ".writeDouble(" << c.var << ");\n"; }}, {"double[]", [](const CodeGeneratorContext& c) { c.writer << c.parcel << ".writeDoubleArray(" << c.var << ");\n"; }}, {"String", [](const CodeGeneratorContext& c) { c.writer << c.parcel << ".writeString(" << c.var << ");\n"; }}, {"String[]", [](const CodeGeneratorContext& c) { c.writer << c.parcel << ".writeStringArray(" << c.var << ");\n"; }}, {"List", [](const CodeGeneratorContext& c) { if (c.type.IsGeneric()) { AIDL_FATAL_IF(c.type.GetTypeParameters().size() != 1, c.type); const auto& element_type = *c.type.GetTypeParameters().at(0); const auto& element_type_name = element_type.GetName(); if (element_type_name == "String") { c.writer << c.parcel << ".writeStringList(" << c.var << ");\n"; } else if (element_type_name == "IBinder") { c.writer << c.parcel << ".writeBinderList(" << c.var << ");\n"; } else if (c.typenames.IsParcelable(element_type_name)) { if (c.min_sdk_version > 33u) { c.writer << c.parcel << ".writeTypedList(" << c.var << ", " << c.write_to_parcel_flag << ");\n"; } else { c.writer << "_Parcel.writeTypedList(" << c.parcel << ", " << c.var << ", " << c.write_to_parcel_flag << ");\n"; } } else if (c.typenames.GetInterface(element_type)) { c.writer << c.parcel << ".writeInterfaceList(" << c.var << ");\n"; } else { AIDL_FATAL(c.type) << "write: NOT IMPLEMENTED for " << element_type_name; } } else { c.writer << c.parcel << ".writeList(" << c.var << ");\n"; } }}, {"Map", [](const CodeGeneratorContext& c) { if (c.type.IsGeneric()) { c.writer << "if (" << c.var << " == null) {\n"; c.writer.Indent(); c.writer << c.parcel << ".writeInt(-1);\n"; c.writer.Dedent(); c.writer << "} else {\n"; c.writer.Indent(); c.writer << c.parcel << ".writeInt(" << c.var << ".size());\n"; c.writer << c.var << ".forEach((k, v) -> {\n"; c.writer.Indent(); c.writer << c.parcel << ".writeString(k);\n"; CodeGeneratorContext value_context{ c.writer, c.typenames, *c.type.GetTypeParameters()[1].get(), c.parcel, "v", c.min_sdk_version, c.write_to_parcel_flag, c.is_classloader_created, }; WriteToParcelFor(value_context); c.writer.Dedent(); c.writer << "});\n"; c.writer.Dedent(); c.writer << "}\n"; } else { c.writer << c.parcel << ".writeMap(" << c.var << ");\n"; } }}, {"IBinder", [](const CodeGeneratorContext& c) { c.writer << c.parcel << ".writeStrongBinder(" << c.var << ");\n"; }}, {"IBinder[]", [](const CodeGeneratorContext& c) { c.writer << c.parcel << ".writeBinderArray(" << c.var << ");\n"; }}, {"FileDescriptor", [](const CodeGeneratorContext& c) { c.writer << c.parcel << ".writeRawFileDescriptor(" << c.var << ");\n"; }}, {"FileDescriptor[]", [](const CodeGeneratorContext& c) { c.writer << c.parcel << ".writeRawFileDescriptorArray(" << c.var << ");\n"; }}, {"ParcelFileDescriptor", [](const CodeGeneratorContext& c) { if (c.min_sdk_version >= 23u) { c.writer << c.parcel << ".writeTypedObject(" << c.var << ", " << c.write_to_parcel_flag << ");\n"; } else { c.writer << "_Parcel.writeTypedObject(" << c.parcel << ", " << c.var << ", " << c.write_to_parcel_flag << ");\n"; } }}, {"ParcelFileDescriptor[]", [](const CodeGeneratorContext& c) { c.writer << c.parcel << ".writeTypedArray(" << c.var << ", " << c.write_to_parcel_flag << ");\n"; }}, {"CharSequence", [](const CodeGeneratorContext& c) { // TextUtils.writeToParcel does not accept null. So, we need to handle // the case here. c.writer << "if (" << c.var << "!=null) {\n"; c.writer.Indent(); c.writer << c.parcel << ".writeInt(1);\n"; c.writer << "android.text.TextUtils.writeToParcel(" << c.var << ", " << c.parcel << ", " << c.write_to_parcel_flag << ");\n"; c.writer.Dedent(); c.writer << "}\n"; c.writer << "else {\n"; c.writer.Indent(); c.writer << c.parcel << ".writeInt(0);\n"; c.writer.Dedent(); c.writer << "}\n"; }}, {"ParcelableHolder", [](const CodeGeneratorContext& c) { c.writer << c.parcel << ".writeTypedObject(" << c.var << ", 0);\n"; }}, }; const string type_name = AidlBackingTypeName(c.type); const auto found = method_map.find(type_name); if (found != method_map.end()) { found->second(c); } else if (c.type.IsFixedSizeArray()) { std::vector args = {c.var, c.write_to_parcel_flag}; for (auto dim : c.type.GetFixedSizeArrayDimensions()) { args.push_back(std::to_string(dim)); } c.writer << c.parcel << ".writeFixedArray(" << Join(args, ", ") << ");\n"; } else { const AidlDefinedType* t = c.typenames.TryGetDefinedType(c.type.GetName()); AIDL_FATAL_IF(t == nullptr, c.type) << "Unknown type: " << c.type.GetName(); if (t->AsInterface() != nullptr) { if (c.type.IsArray()) { c.writer << c.parcel << ".writeInterfaceArray(" << c.var << ");\n"; } else { c.writer << c.parcel << ".writeStrongInterface(" << c.var << ");\n"; } } else if (t->AsParcelable() != nullptr) { if (c.type.IsArray()) { c.writer << c.parcel << ".writeTypedArray(" << c.var << ", " << c.write_to_parcel_flag << ");\n"; } else { if (c.min_sdk_version >= 23u) { c.writer << c.parcel << ".writeTypedObject(" << c.var << ", " << c.write_to_parcel_flag << ");\n"; } else { c.writer << "_Parcel.writeTypedObject(" << c.parcel << ", " << c.var << ", " << c.write_to_parcel_flag << ");\n"; } } } } } // Ensures that a variable is initialized to refer to the classloader // of the current object and returns the name of the variable. static string EnsureAndGetClassloader(CodeGeneratorContext& c) { AIDL_FATAL_IF(c.is_classloader_created == nullptr, AIDL_LOCATION_HERE); if (!*(c.is_classloader_created)) { c.writer << "java.lang.ClassLoader cl = " << "(java.lang.ClassLoader)this.getClass().getClassLoader();\n"; *(c.is_classloader_created) = true; } return "cl"; } bool CreateFromParcelFor(const CodeGeneratorContext& c) { static map> method_map{ {"boolean", [](const CodeGeneratorContext& c) { if (c.min_sdk_version >= 29u) { c.writer << c.var << " = " << c.parcel << ".readBoolean();\n"; } else { c.writer << c.var << " = (0!=" << c.parcel << ".readInt());\n"; } }}, {"boolean[]", [](const CodeGeneratorContext& c) { c.writer << c.var << " = " << c.parcel << ".createBooleanArray();\n"; }}, {"byte", [](const CodeGeneratorContext& c) { c.writer << c.var << " = " << c.parcel << ".readByte();\n"; }}, {"byte[]", [](const CodeGeneratorContext& c) { c.writer << c.var << " = " << c.parcel << ".createByteArray();\n"; }}, {"char", [](const CodeGeneratorContext& c) { c.writer << c.var << " = (char)" << c.parcel << ".readInt();\n"; }}, {"char[]", [](const CodeGeneratorContext& c) { c.writer << c.var << " = " << c.parcel << ".createCharArray();\n"; }}, {"int", [](const CodeGeneratorContext& c) { c.writer << c.var << " = " << c.parcel << ".readInt();\n"; }}, {"int[]", [](const CodeGeneratorContext& c) { c.writer << c.var << " = " << c.parcel << ".createIntArray();\n"; }}, {"long", [](const CodeGeneratorContext& c) { c.writer << c.var << " = " << c.parcel << ".readLong();\n"; }}, {"long[]", [](const CodeGeneratorContext& c) { c.writer << c.var << " = " << c.parcel << ".createLongArray();\n"; }}, {"float", [](const CodeGeneratorContext& c) { c.writer << c.var << " = " << c.parcel << ".readFloat();\n"; }}, {"float[]", [](const CodeGeneratorContext& c) { c.writer << c.var << " = " << c.parcel << ".createFloatArray();\n"; }}, {"double", [](const CodeGeneratorContext& c) { c.writer << c.var << " = " << c.parcel << ".readDouble();\n"; }}, {"double[]", [](const CodeGeneratorContext& c) { c.writer << c.var << " = " << c.parcel << ".createDoubleArray();\n"; }}, {"String", [](const CodeGeneratorContext& c) { c.writer << c.var << " = " << c.parcel << ".readString();\n"; }}, {"String[]", [](const CodeGeneratorContext& c) { c.writer << c.var << " = " << c.parcel << ".createStringArray();\n"; }}, {"List", [](const CodeGeneratorContext& c) { if (c.type.IsGeneric()) { AIDL_FATAL_IF(c.type.GetTypeParameters().size() != 1, c.type); const auto& element_type = *c.type.GetTypeParameters().at(0); const auto& element_type_name = element_type.GetName(); if (element_type_name == "String") { c.writer << c.var << " = " << c.parcel << ".createStringArrayList();\n"; } else if (element_type_name == "IBinder") { c.writer << c.var << " = " << c.parcel << ".createBinderArrayList();\n"; } else if (c.typenames.IsParcelable(element_type_name)) { c.writer << c.var << " = " << c.parcel << ".createTypedArrayList(" << JavaNameOf(element_type) << ".CREATOR);\n"; } else if (c.typenames.GetInterface(element_type)) { auto as_interface = element_type_name + ".Stub::asInterface"; c.writer << c.var << " = " << c.parcel << ".createInterfaceArrayList(" << as_interface << ");\n"; } else { AIDL_FATAL(c.type) << "create: NOT IMPLEMENTED for " << element_type_name; } } else { const string classloader = EnsureAndGetClassloader(const_cast(c)); c.writer << c.var << " = " << c.parcel << ".readArrayList(" << classloader << ");\n"; } }}, {"Map", [](const CodeGeneratorContext& c) { if (c.type.IsGeneric()) { c.writer << "{\n"; c.writer.Indent(); c.writer << "int N = " << c.parcel << ".readInt();\n"; c.writer << c.var << " = N < 0 ? null : new java.util.HashMap<>();\n"; auto creator = JavaNameOf(*(c.type.GetTypeParameters().at(1))) + ".CREATOR"; c.writer << "java.util.stream.IntStream.range(0, N).forEach(i -> {\n"; c.writer.Indent(); c.writer << "String k = " << c.parcel << ".readString();\n"; c.writer << JavaSignatureOf(*(c.type.GetTypeParameters().at(1))) << " v;\n"; CodeGeneratorContext value_context{ c.writer, c.typenames, *c.type.GetTypeParameters()[1].get(), c.parcel, "v", c.min_sdk_version, c.write_to_parcel_flag, c.is_classloader_created, }; CreateFromParcelFor(value_context); c.writer << c.var << ".put(k, v);\n"; c.writer.Dedent(); c.writer << "});\n"; c.writer.Dedent(); c.writer << "}\n"; } else { const string classloader = EnsureAndGetClassloader(const_cast(c)); c.writer << c.var << " = " << c.parcel << ".readHashMap(" << classloader << ");\n"; } }}, {"IBinder", [](const CodeGeneratorContext& c) { c.writer << c.var << " = " << c.parcel << ".readStrongBinder();\n"; }}, {"IBinder[]", [](const CodeGeneratorContext& c) { c.writer << c.var << " = " << c.parcel << ".createBinderArray();\n"; }}, {"FileDescriptor", [](const CodeGeneratorContext& c) { c.writer << c.var << " = " << c.parcel << ".readRawFileDescriptor();\n"; }}, {"FileDescriptor[]", [](const CodeGeneratorContext& c) { c.writer << c.var << " = " << c.parcel << ".createRawFileDescriptorArray();\n"; }}, {"ParcelFileDescriptor", [](const CodeGeneratorContext& c) { if (c.min_sdk_version >= 23u) { c.writer << c.var << " = " << c.parcel << ".readTypedObject(android.os.ParcelFileDescriptor.CREATOR);\n"; } else { c.writer << c.var << " = _Parcel.readTypedObject(" << c.parcel << ", android.os.ParcelFileDescriptor.CREATOR);\n"; } }}, {"ParcelFileDescriptor[]", [](const CodeGeneratorContext& c) { c.writer << c.var << " = " << c.parcel << ".createTypedArray(android.os.ParcelFileDescriptor.CREATOR);\n"; }}, {"CharSequence", [](const CodeGeneratorContext& c) { if (c.min_sdk_version >= 23u) { c.writer << c.var << " = " << c.parcel << ".readTypedObject(android.text.TextUtils.CHAR_SEQUENCE_CREATOR);\n"; } else { c.writer << c.var << " = _Parcel.readTypedObject(" << c.parcel << ", android.text.TextUtils.CHAR_SEQUENCE_CREATOR);\n"; } }}, {"ParcelableHolder", [](const CodeGeneratorContext& c) { c.writer << "if ((0!=" << c.parcel << ".readInt())) {\n"; c.writer.Indent(); c.writer << c.var << ".readFromParcel(" << c.parcel << ");\n"; c.writer.Dedent(); c.writer << "}\n"; }}, }; const auto found = method_map.find(AidlBackingTypeName(c.type)); if (found != method_map.end()) { found->second(c); } else if (c.type.IsFixedSizeArray()) { std::vector args = {JavaSignatureOf(c.type) + ".class"}; if (c.typenames.IsParcelable(c.type.GetName())) { args.push_back(JavaNameOf(c.type) + ".CREATOR"); } else if (c.typenames.GetInterface(c.type)) { args.push_back(c.type.GetName() + ".Stub::asInterface"); } for (auto dim : c.type.GetFixedSizeArrayDimensions()) { args.push_back(std::to_string(dim)); } c.writer << c.var << " = " << c.parcel << ".createFixedArray(" << Join(args, ", ") << ");\n"; } else { const AidlDefinedType* t = c.typenames.TryGetDefinedType(c.type.GetName()); AIDL_FATAL_IF(t == nullptr, c.type) << "Unknown type: " << c.type.GetName(); if (t->AsInterface() != nullptr) { auto name = c.type.GetName(); if (c.type.IsArray()) { auto new_array = name + "[]::new"; auto as_interface = name + ".Stub::asInterface"; c.writer << c.var << " = " << c.parcel << ".createInterfaceArray(" << new_array << ", " << as_interface << ");\n"; } else { c.writer << c.var << " = " << name << ".Stub.asInterface(" << c.parcel << ".readStrongBinder());\n"; } } else if (t->AsParcelable() != nullptr) { if (c.type.IsArray()) { c.writer << c.var << " = " << c.parcel << ".createTypedArray(" << JavaNameOf(c.type) << ".CREATOR);\n"; } else { if (c.min_sdk_version >= 23u) { c.writer << c.var << " = " << c.parcel << ".readTypedObject(" << c.type.GetName() << ".CREATOR);\n"; } else { c.writer << c.var << " = _Parcel.readTypedObject(" << c.parcel << ", " << c.type.GetName() << ".CREATOR);\n"; } } } } return true; } bool ReadFromParcelFor(const CodeGeneratorContext& c) { static map> method_map{ {"boolean[]", [](const CodeGeneratorContext& c) { c.writer << c.parcel << ".readBooleanArray(" << c.var << ");\n"; }}, {"byte[]", [](const CodeGeneratorContext& c) { c.writer << c.parcel << ".readByteArray(" << c.var << ");\n"; }}, {"char[]", [](const CodeGeneratorContext& c) { c.writer << c.parcel << ".readCharArray(" << c.var << ");\n"; }}, {"int[]", [](const CodeGeneratorContext& c) { c.writer << c.parcel << ".readIntArray(" << c.var << ");\n"; }}, {"long[]", [](const CodeGeneratorContext& c) { c.writer << c.parcel << ".readLongArray(" << c.var << ");\n"; }}, {"float[]", [](const CodeGeneratorContext& c) { c.writer << c.parcel << ".readFloatArray(" << c.var << ");\n"; }}, {"double[]", [](const CodeGeneratorContext& c) { c.writer << c.parcel << ".readDoubleArray(" << c.var << ");\n"; }}, {"String[]", [](const CodeGeneratorContext& c) { c.writer << c.parcel << ".readStringArray(" << c.var << ");\n"; }}, {"List", [](const CodeGeneratorContext& c) { if (c.type.IsGeneric()) { AIDL_FATAL_IF(c.type.GetTypeParameters().size() != 1, c.type); const auto& element_type = *c.type.GetTypeParameters().at(0); const auto& element_type_name = element_type.GetName(); if (element_type_name == "String") { c.writer << c.parcel << ".readStringList(" << c.var << ");\n"; } else if (element_type_name == "IBinder") { c.writer << c.parcel << ".readBinderList(" << c.var << ");\n"; } else if (c.typenames.IsParcelable(element_type_name)) { c.writer << c.parcel << ".readTypedList(" << c.var << ", " << JavaNameOf(*(c.type.GetTypeParameters().at(0))) << ".CREATOR);\n"; } else if (c.typenames.GetInterface(element_type)) { auto as_interface = element_type_name + ".Stub::asInterface"; c.writer << c.parcel << ".readInterfaceList(" << c.var << ", " << as_interface << ");\n"; } else { AIDL_FATAL(c.type) << "read: NOT IMPLEMENTED for " << element_type_name; } } else { const string classloader = EnsureAndGetClassloader(const_cast(c)); c.writer << c.parcel << ".readList(" << c.var << ", " << classloader << ");\n"; } }}, {"Map", [](const CodeGeneratorContext& c) { if (c.type.IsGeneric()) { c.writer << "if (" << c.var << " != null) " << c.var << ".clear();\n"; c.writer << "java.util.stream.IntStream.range(0, " << c.parcel << ".readInt()).forEach(i -> {\n"; c.writer.Indent(); c.writer << "String k = " << c.parcel << ".readString();\n"; c.writer << JavaSignatureOf(*(c.type.GetTypeParameters().at(1))) << " v;\n"; CodeGeneratorContext value_context{ c.writer, c.typenames, *c.type.GetTypeParameters()[1].get(), c.parcel, "v", c.min_sdk_version, c.write_to_parcel_flag, c.is_classloader_created, }; CreateFromParcelFor(value_context); c.writer << c.var << ".put(k, v);\n"; c.writer.Dedent(); c.writer << "});\n"; } else { const string classloader = EnsureAndGetClassloader(const_cast(c)); c.writer << c.var << " = " << c.parcel << ".readHashMap(" << classloader << ");\n"; } }}, {"IBinder[]", [](const CodeGeneratorContext& c) { c.writer << c.parcel << ".readBinderArray(" << c.var << ");\n"; }}, {"FileDescriptor[]", [](const CodeGeneratorContext& c) { c.writer << c.parcel << ".readRawFileDescriptorArray(" << c.var << ");\n"; }}, {"ParcelFileDescriptor", [](const CodeGeneratorContext& c) { c.writer << "if ((0!=" << c.parcel << ".readInt())) {\n"; c.writer.Indent(); c.writer << c.var << " = " << "android.os.ParcelFileDescriptor.CREATOR.createFromParcel(" << c.parcel << ");\n"; c.writer.Dedent(); c.writer << "}\n"; }}, {"ParcelFileDescriptor[]", [](const CodeGeneratorContext& c) { c.writer << c.parcel << ".readTypedArray(" << c.var << ", android.os.ParcelFileDescriptor.CREATOR);\n"; }}, }; const auto& found = method_map.find(AidlBackingTypeName(c.type)); if (found != method_map.end()) { found->second(c); } else if (c.type.IsFixedSizeArray()) { std::vector args = {c.var}; if (c.typenames.IsParcelable(c.type.GetName())) { args.push_back(c.type.GetName() + ".CREATOR"); } else if (c.typenames.GetInterface(c.type)) { args.push_back(c.type.GetName() + ".Stub::asInterface"); } c.writer << c.parcel << ".readFixedArray(" << Join(args, ", ") << ");\n"; } else { const AidlDefinedType* t = c.typenames.TryGetDefinedType(c.type.GetName()); AIDL_FATAL_IF(t == nullptr, c.type) << "Unknown type: " << c.type.GetName(); if (t->AsParcelable() != nullptr || t->AsUnionDeclaration() != nullptr) { if (c.type.IsArray()) { c.writer << c.parcel << ".readTypedArray(" << c.var << ", " << c.type.GetName() << ".CREATOR);\n"; } else { c.writer << "if ((0!=" << c.parcel << ".readInt())) {\n"; c.writer.Indent(); c.writer << c.var << ".readFromParcel(" << c.parcel << ");\n"; c.writer.Dedent(); c.writer << "}\n"; } } else if (t->AsInterface()) { AIDL_FATAL_IF(!c.type.IsArray(), c.type) << "readFromParcel(interface) doesn't make sense."; auto as_interface = c.type.GetName() + ".Stub::asInterface"; c.writer << c.parcel << ".readInterfaceArray(" << c.var << ", " << as_interface << ");\n"; } } return true; } void ToStringFor(const CodeGeneratorContext& c) { // Use derived toString() for enum type annotated with @JavaDerive(toString=true) if (auto t = c.type.GetDefinedType(); t != nullptr && t->AsEnumDeclaration() && t->JavaDerive("toString")) { if (c.type.IsArray()) { c.writer << c.type.GetName() << ".$.arrayToString(" << c.var << ")"; } else { c.writer << c.type.GetName() << ".$.toString(" << c.var << ")"; } return; } if (c.type.IsArray()) { if (c.type.IsDynamicArray() || c.type.GetFixedSizeArrayDimensions().size() == 1) { c.writer << "java.util.Arrays.toString(" << c.var << ")"; } else { c.writer << "java.util.Arrays.deepToString(" << c.var << ")"; } return; } const std::string name = c.type.GetName(); if (AidlTypenames::IsPrimitiveTypename(name)) { c.writer << c.var; return; } const AidlDefinedType* t = c.typenames.TryGetDefinedType(name); if (t != nullptr && t->AsEnumDeclaration()) { c.writer << c.var; return; } // FileDescriptor doesn't have a good toString() impl. if (name == "FileDescriptor") { c.writer << c.var << " == null ? \"null\" : "; c.writer << c.var << ".getInt$()"; return; } // Rest of the built-in types have reasonable toString() impls. if (AidlTypenames::IsBuiltinTypename(name)) { c.writer << "java.util.Objects.toString(" << c.var << ")"; return; } // For user-defined types, we also use toString() that we are generating here, but just make sure // that they are actually user-defined types. AIDL_FATAL_IF(t == nullptr, c.type) << "Unknown type"; if (t->AsInterface() != nullptr || t->AsParcelable() != nullptr) { c.writer << "java.util.Objects.toString(" << c.var << ")"; return; } AIDL_FATAL(AIDL_LOCATION_HERE) << "Unhandled typename: " << name; } } // namespace java } // namespace aidl } // namespace android ./PaxHeaders.X/aidl_to_java.h0100644 0000000 0000000 00000000034 15172120304 015061 xustar000000000 0000000 28 mtime=1776853188.2950000 aidl_to_java.h0100644 0000000 0000000 00000010467 15172120304 012375 0ustar000000000 0000000 /* * Copyright (C) 2018, The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #pragma once #include "aidl_language.h" #include "aidl_typenames.h" #include #include #include #include #include #include #include namespace android { namespace aidl { namespace java { using std::map; using std::pair; using std::set; using std::string; using std::unique_ptr; using std::vector; // This header provides functions that translate AIDL things to Java things. std::string ConstantValueDecorator( const AidlTypeSpecifier& type, const std::variant>& raw_value); // Returns the Java type signature of the AIDL type spec // This includes generic type parameters with array modifiers. string JavaSignatureOf(const AidlTypeSpecifier& aidl); // Returns the Java boxing type of the AIDL type spec. // aidl type should be a primitive type. string JavaBoxingTypeOf(const AidlTypeSpecifier& aidl); // Returns the instantiable Jva type signature of the AIDL type spec // This includes generic type parameters, but excludes array modifiers. string InstantiableJavaSignatureOf(const AidlTypeSpecifier& aidl); // Returns the default Java value of the AIDL type spec string DefaultJavaValueOf(const AidlTypeSpecifier& aidl); // This carries information that is required to generate code for // marshalling and unmarshalling a method argument or a parcelable field struct CodeGeneratorContext { CodeWriter& writer; // CodeWriter::Write() is mutable const AidlTypenames& typenames; const AidlTypeSpecifier& type; const string parcel; const string var; const uint32_t min_sdk_version; // Set PARCELABLE_WRITE_RETURN_VALUE when the marshalled data will be returned to the client. // This is given as a hint to the Parcelable that is being marshalled // so that the Parcelable can release its resource after the marshalling // is done. const string write_to_parcel_flag; // Most of the variables created by AIDL compiler are typed, i.e., the code // knows exactly what type of object is in the parcel -- because the parcel // itself is created by the code generated by AIDL compiler. // // However, for some collection types (List and Map for now), we write the // elements in them untyped (object is flattened along with its type name) // as the AIDL compiler does not know the type of the contained elements. // So, when unmarshalling such collection, we need to provide a classloader // from where the parcel can reflectively find a class object for // the contained element. // // This field is a pointer to a boolean state variable that indicates whether // the code for declaring and getting the classloader has been emitted or not. // We emit the code at most once per an AIDL method, otherwise we are wasting // time doing the same thing multiple time. bool* const is_classloader_created; }; // Writes code fragment that writes a variable to the parcel. void WriteToParcelFor(const CodeGeneratorContext& c); // Writes code fragment that reads data from the parcel into a variable. When // the variable type is array or List, the array or List is created. bool CreateFromParcelFor(const CodeGeneratorContext& c); // Writes code fragment that reads data from the parcel into an existing // array or a List. bool ReadFromParcelFor(const CodeGeneratorContext& c); // Writes an expression that returns the string representation of a field // in a parcelable void ToStringFor(const CodeGeneratorContext& c); // Generates create/read/write helper functions which are missing in Parcel. void GenerateParcelHelpers(CodeWriter& out, const AidlDefinedType& defined_type, const AidlTypenames& typenames, const Options& options); } // namespace java } // namespace aidl } // namespace android ./PaxHeaders.X/aidl_to_ndk.cpp0100644 0000000 0000000 00000000034 15172120304 015247 xustar000000000 0000000 28 mtime=1776853188.2960000 aidl_to_ndk.cpp0100644 0000000 0000000 00000023364 15172120304 012563 0ustar000000000 0000000 /* * Copyright (C) 2018, The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * limitations under the License. */ #include "aidl_to_ndk.h" #include "aidl_language.h" #include "aidl_to_cpp_common.h" #include "logging.h" #include "os.h" #include #include #include using ::android::base::Join; using ::android::base::Split; namespace android { namespace aidl { namespace ndk { std::string NdkHeaderFile(const AidlDefinedType& defined_type, cpp::ClassNames name, bool use_os_sep) { // Unstructured parcelable should set its ndk_header. use it. if (auto unstructured = AidlCast(defined_type); unstructured) { AIDL_FATAL_IF(name != cpp::ClassNames::RAW, "unstructured parcelable should only use raw name"); const std::string ndk_header = unstructured->GetNdkHeader(); AIDL_FATAL_IF(ndk_header.empty(), unstructured) << "Parcelable " << unstructured->GetCanonicalName() << " has no ndk_header defined."; return ndk_header; } char seperator = (use_os_sep) ? OS_PATH_SEPARATOR : '/'; return std::string("aidl") + seperator + cpp::HeaderFile(defined_type, name, use_os_sep); } // This represents a type in AIDL (e.g. 'String' which can be referenced in multiple ways) struct TypeInfo { // name of the type in C++ output std::string cpp_name; // whether to prefer 'value type' over 'const&' bool value_is_cheap = false; }; std::string ConstantValueDecorator( const AidlTypeSpecifier& type, const std::variant>& raw_value) { return cpp::CppConstantValueDecorator(type, raw_value, /*is_ndk=*/true); }; // map from AIDL built-in type name to the corresponding Ndk type info static map kNdkTypeInfoMap = { {"void", {"void", true}}, {"boolean", {"bool", true}}, {"byte", {"int8_t", true}}, {"char", {"char16_t", true}}, {"int", {"int32_t", true}}, {"long", {"int64_t", true}}, {"float", {"float", true}}, {"double", {"double", true}}, {"String", {"std::string"}}, // TODO(b/136048684) {"Map", ""}, {"IBinder", {"::ndk::SpAIBinder"}}, {"ParcelFileDescriptor", {"::ndk::ScopedFileDescriptor"}}, {"ParcelableHolder", {"::ndk::AParcelableHolder"}}, }; static TypeInfo GetBaseTypeInfo(const AidlTypenames& types, const AidlTypeSpecifier& aidl) { auto& aidl_name = aidl.GetName(); if (AidlTypenames::IsBuiltinTypename(aidl_name)) { auto it = kNdkTypeInfoMap.find(aidl_name); AIDL_FATAL_IF(it == kNdkTypeInfoMap.end(), aidl_name); return it->second; } const AidlDefinedType* type = types.TryGetDefinedType(aidl_name); AIDL_FATAL_IF(type == nullptr, aidl_name) << "Unrecognized type."; if (const AidlInterface* intf = type->AsInterface(); intf != nullptr) { const std::string clazz = NdkFullClassName(*intf, cpp::ClassNames::INTERFACE); return TypeInfo{"std::shared_ptr<" + clazz + ">"}; } else if (const AidlParcelable* parcelable = type->AsParcelable(); parcelable != nullptr) { std::string clazz = NdkFullClassName(*parcelable, cpp::ClassNames::RAW); std::string template_params = ""; if (aidl.IsGeneric()) { std::vector type_params; for (const auto& parameter : aidl.GetTypeParameters()) { type_params.push_back(NdkNameOf(types, *parameter, StorageMode::STACK)); } clazz += base::StringPrintf("<%s>", base::Join(type_params, ", ").c_str()); } return TypeInfo{clazz}; } else if (const AidlEnumDeclaration* enum_decl = type->AsEnumDeclaration(); enum_decl != nullptr) { const std::string clazz = NdkFullClassName(*enum_decl, cpp::ClassNames::RAW); return TypeInfo{clazz, true}; } else { AIDL_FATAL(aidl_name) << "Unrecognized type"; } } static TypeInfo WrapNullableType(TypeInfo info, bool is_heap) { if (is_heap) { info.cpp_name = "std::unique_ptr<" + info.cpp_name + ">"; } else { info.cpp_name = "std::optional<" + info.cpp_name + ">"; } info.value_is_cheap = false; return info; } static TypeInfo WrapArrayType(TypeInfo info, const ArrayType* array) { AIDL_FATAL_IF(!array, AIDL_LOCATION_HERE) << "not an array"; // When "byte"(AIDL) is used in an array, use "uint8_t" because it's more C++ idiomatic. if (info.cpp_name == "int8_t") { info.cpp_name = "uint8_t"; } if (std::get_if(array)) { info.cpp_name = "std::vector<" + info.cpp_name + ">"; } else { auto dimensions = std::get(*array).GetDimensionInts(); for (auto it = rbegin(dimensions), end = rend(dimensions); it != end; it++) { info.cpp_name = "std::array<" + info.cpp_name + ", " + std::to_string(*it) + ">"; } } info.value_is_cheap = false; return info; } static bool ShouldWrapNullable(const AidlTypenames& types, const std::string& aidl_name) { if (AidlTypenames::IsPrimitiveTypename(aidl_name) || aidl_name == "ParcelableHolder" || aidl_name == "IBinder" || aidl_name == "ParcelFileDescriptor") { return false; } if (auto defined_type = types.TryGetDefinedType(aidl_name); defined_type) { if (defined_type->AsEnumDeclaration() || defined_type->AsInterface()) { return false; } } return true; } static TypeInfo GetTypeInfo(const AidlTypenames& types, const AidlTypeSpecifier& aidl) { AIDL_FATAL_IF(!aidl.IsResolved(), aidl) << aidl.ToString(); // Keep original @nullable to handle the case of List. "@nullable" is attached to "List" not // "T" bool is_nullable = aidl.IsNullable(); const ArrayType* array = nullptr; const AidlTypeSpecifier* element_type = &aidl; // List is converted to T[]. if (aidl.GetName() == "List") { static const ArrayType kDynamicArray{DynamicArray{}}; AIDL_FATAL_IF(!aidl.IsGeneric(), aidl) << "List must be generic type."; AIDL_FATAL_IF(aidl.GetTypeParameters().size() != 1, aidl) << "List can accept only one type parameter."; const auto& type_param = *aidl.GetTypeParameters()[0]; // TODO(b/136048684) AIDL doesn't support nested type parameter yet. AIDL_FATAL_IF(type_param.IsGeneric(), aidl) << "AIDL doesn't support nested type parameter"; // Treat "List" as an array of T. array = &kDynamicArray; element_type = &type_param; } else if (aidl.IsArray()) { array = &aidl.GetArray(); } TypeInfo info = GetBaseTypeInfo(types, *element_type); if (is_nullable && ShouldWrapNullable(types, element_type->GetName())) { info = WrapNullableType(info, aidl.IsHeapNullable()); } if (array) { info = WrapArrayType(info, array); if (is_nullable) { AIDL_FATAL_IF(aidl.IsHeapNullable(), aidl) << "Array/List can't be @nullable(heap=true)"; info = WrapNullableType(info, /*is_heap=*/false); } } return info; } std::string NdkFullClassName(const AidlDefinedType& type, cpp::ClassNames name) { std::vector pieces = {"::aidl"}; std::vector split_name = Split(type.GetCanonicalName(), "."); pieces.insert(pieces.end(), split_name.begin(), split_name.end()); // Override name part with cpp::ClassName(type, name) pieces.back() = cpp::ClassName(type, name); return Join(pieces, "::"); } std::string NdkNameOf(const AidlTypenames& types, const AidlTypeSpecifier& aidl, StorageMode mode) { TypeInfo aspect = GetTypeInfo(types, aidl); switch (mode) { case StorageMode::STACK: return aspect.cpp_name; case StorageMode::ARGUMENT: if (aspect.value_is_cheap) { return aspect.cpp_name; } else { return "const " + aspect.cpp_name + "&"; } case StorageMode::OUT_ARGUMENT: return aspect.cpp_name + "*"; default: AIDL_FATAL(aidl.GetName()) << "Unrecognized mode type: " << static_cast(mode); } } void WriteToParcelFor(const CodeGeneratorContext& c) { if (c.type.IsNullable()) { c.writer << "::ndk::AParcel_writeNullableData(" << c.parcel << ", " << c.var << ")"; } else { c.writer << "::ndk::AParcel_writeData(" << c.parcel << ", " << c.var << ")"; } } void ReadFromParcelFor(const CodeGeneratorContext& c) { if (c.type.IsNullable()) { c.writer << "::ndk::AParcel_readNullableData(" << c.parcel << ", " << c.var << ")"; } else { c.writer << "::ndk::AParcel_readData(" << c.parcel << ", " << c.var << ")"; } } std::string NdkArgList( const AidlTypenames& types, const AidlMethod& method, std::function formatter) { std::vector method_arguments; for (const auto& a : method.GetArguments()) { StorageMode mode = a->IsOut() ? StorageMode::OUT_ARGUMENT : StorageMode::ARGUMENT; std::string type = NdkNameOf(types, a->GetType(), mode); std::string name = cpp::BuildVarName(*a); method_arguments.emplace_back(formatter(type, name, a->IsOut())); } if (method.GetType().GetName() != "void") { std::string type = NdkNameOf(types, method.GetType(), StorageMode::OUT_ARGUMENT); std::string name = "_aidl_return"; method_arguments.emplace_back(formatter(type, name, true)); } return Join(method_arguments, ", "); } std::string NdkMethodDecl(const AidlTypenames& types, const AidlMethod& method, const std::string& clazz) { std::string class_prefix = clazz.empty() ? "" : (clazz + "::"); return "::ndk::ScopedAStatus " + class_prefix + method.GetName() + "(" + NdkArgList(types, method, FormatArgForDecl) + ")"; } } // namespace ndk } // namespace aidl } // namespace android ./PaxHeaders.X/aidl_to_ndk.h0100644 0000000 0000000 00000000034 15172120304 014714 xustar000000000 0000000 28 mtime=1776853188.2960000 aidl_to_ndk.h0100644 0000000 0000000 00000006021 15172120304 012217 0ustar000000000 0000000 /* * Copyright (C) 2018, The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #pragma once #include "aidl_language.h" #include "aidl_to_cpp_common.h" namespace android { namespace aidl { namespace ndk { enum class StorageMode { STACK, ARGUMENT, // Value for primitives, const& for larger types OUT_ARGUMENT, // Pointer to raw type }; std::string NdkHeaderFile(const AidlDefinedType& defined_type, cpp::ClassNames name, bool use_os_sep = true); std::string ConstantValueDecorator( const AidlTypeSpecifier& type, const std::variant>& raw_value); // Returns ::aidl::some_package::some_sub_package::foo::IFoo/BpFoo/BnFoo std::string NdkFullClassName(const AidlDefinedType& type, cpp::ClassNames name); // Returns the corresponding Ndk type name for an AIDL type spec including // array modifiers. std::string NdkNameOf(const AidlTypenames& types, const AidlTypeSpecifier& aidl, StorageMode mode); struct CodeGeneratorContext { CodeWriter& writer; const AidlTypenames& types; const AidlTypeSpecifier& type; const string parcel; const string var; }; void WriteToParcelFor(const CodeGeneratorContext& c); void ReadFromParcelFor(const CodeGeneratorContext& c); // Returns argument list of a method where each arg is formatted by the fomatter std::string NdkArgList( const AidlTypenames& types, const AidlMethod& method, std::function formatter); inline std::string FormatArgForDecl(const std::string& type, const std::string& name, bool /*isOut*/) { return type + " " + name; } inline std::string FormatArgNameUnused(const std::string& type, const std::string& name, bool /*isOut*/) { return type + " /*" + name + "*/"; } inline std::string FormatArgForCall(const std::string& /*type*/, const std::string& name, bool isOut) { std::string reference_prefix = isOut ? "&" : ""; return reference_prefix + name; } inline std::string FormatArgNameOnly(const std::string& /*type*/, const std::string& name, bool /*isOut*/) { return name; } // -> 'status (class::)name(type name, ...)' for a method std::string NdkMethodDecl(const AidlTypenames& types, const AidlMethod& method, const std::string& clazz = ""); } // namespace ndk } // namespace aidl } // namespace android ./PaxHeaders.X/aidl_to_rust.cpp0100644 0000000 0000000 00000000034 15172120304 015470 xustar000000000 0000000 28 mtime=1776853188.2960000 aidl_to_rust.cpp0100644 0000000 0000000 00000031116 15172120304 012776 0ustar000000000 0000000 /* * 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 "aidl_to_rust.h" #include "aidl_language.h" #include "aidl_typenames.h" #include "logging.h" #include #include #include #include #include #include #include using android::base::Join; using android::base::Split; using android::base::StringPrintf; namespace android { namespace aidl { namespace rust { namespace { std::string GetRawRustName(const AidlTypeSpecifier& type); std::string ConstantValueDecoratorInternal( const AidlTypeSpecifier& type, const std::variant>& raw_value, bool by_ref) { if (type.IsArray()) { const auto& values = std::get>(raw_value); std::string value = "[" + Join(values, ", ") + "]"; if (type.IsDynamicArray()) { value = "vec!" + value; } if (!type.IsMutated() && type.IsNullable()) { value = "Some(" + value + ")"; } return value; } std::string value = std::get(raw_value); const auto& aidl_name = type.GetName(); if (aidl_name == "char") { return value + " as u16"; } if (aidl_name == "float") { // value already ends in `f`, so just add `32` return value + "32"; } if (aidl_name == "double") { return value + "f64"; } if (auto defined_type = type.GetDefinedType(); defined_type) { auto enum_type = defined_type->AsEnumDeclaration(); AIDL_FATAL_IF(!enum_type, type) << "Invalid type for \"" << value << "\""; return GetRawRustName(type) + "::" + value.substr(value.find_last_of('.') + 1); } if (aidl_name == "String" && !by_ref) { // The actual type might be String or &str, // and .into() transparently converts into either one value = value + ".into()"; } if (type.IsNullable()) { value = "Some(" + value + ")"; } return value; } std::string GetRawRustName(const AidlTypeSpecifier& type) { const auto defined_type = type.GetDefinedType(); if (defined_type != nullptr) { const auto unstructured = AidlCast(*defined_type); if (unstructured != nullptr) { // Unstructured parcelable should set its rust_type. Use it. const std::string rust_type = unstructured->GetRustType(); AIDL_FATAL_IF(rust_type.empty(), unstructured) << "Parcelable " << unstructured->GetCanonicalName() << " has no rust_type defined."; return rust_type; } } // Each Rust type is defined in a file with the same name, // e.g., IFoo is in IFoo.rs auto split_name = type.GetSplitName(); std::string rust_name{"crate::mangled::"}; for (const auto& component : split_name) { rust_name += StringPrintf("_%zd_%s", component.size(), component.c_str()); } return rust_name; } // Usually, this means that the type implements `Default`, however `ParcelableHolder` is also // included in this list because the code generator knows how to call `::new(stability)`. bool AutoConstructor(const AidlTypeSpecifier& type, const AidlTypenames& typenames) { return !(type.GetName() == "ParcelFileDescriptor" || type.GetName() == "IBinder" || TypeIsInterface(type, typenames)); } std::string GetRustName(const AidlTypeSpecifier& type, const AidlTypenames& typenames, StorageMode mode) { // map from AIDL built-in type name to the corresponding Rust type name static map m = { {"void", "()"}, {"boolean", "bool"}, {"byte", "i8"}, {"char", "u16"}, {"int", "i32"}, {"long", "i64"}, {"float", "f32"}, {"double", "f64"}, {"String", "String"}, {"IBinder", "binder::SpIBinder"}, {"ParcelFileDescriptor", "binder::ParcelFileDescriptor"}, {"ParcelableHolder", "binder::ParcelableHolder"}, }; const string& type_name = type.GetName(); if (m.find(type_name) != m.end()) { AIDL_FATAL_IF(!AidlTypenames::IsBuiltinTypename(type_name), type); if (type_name == "String" && mode == StorageMode::UNSIZED_ARGUMENT) { return "str"; } else { return m[type_name]; } } auto name = GetRawRustName(type); if (TypeIsInterface(type, typenames)) { name = "binder::Strong"; } if (type.IsGeneric()) { name += "<"; for (const auto& param : type.GetTypeParameters()) { name += GetRustName(*param, typenames, mode); name += ","; } name += ">"; } return name; } } // namespace std::string ConstantValueDecorator( const AidlTypeSpecifier& type, const std::variant>& raw_value) { return ConstantValueDecoratorInternal(type, raw_value, false); } std::string ConstantValueDecoratorRef( const AidlTypeSpecifier& type, const std::variant>& raw_value) { return ConstantValueDecoratorInternal(type, raw_value, true); } // Returns default value for array. std::string ArrayDefaultValue(const AidlTypeSpecifier& type) { AIDL_FATAL_IF(!type.IsFixedSizeArray(), type) << "not a fixed-size array"; auto dimensions = type.GetFixedSizeArrayDimensions(); std::string value = "Default::default()"; for (auto it = rbegin(dimensions), end = rend(dimensions); it != end; it++) { value = "[" + Join(std::vector(*it, value), ", ") + "]"; } return value; } // Returns true if @nullable T[] should be mapped Option> bool UsesOptionInNullableVector(const AidlTypeSpecifier& type, const AidlTypenames& typenames) { AIDL_FATAL_IF(!type.IsArray() && !typenames.IsList(type), type) << "not a vector"; AIDL_FATAL_IF(typenames.IsList(type) && type.GetTypeParameters().size() != 1, type) << "List should have a single type arg."; const auto& element_type = type.IsArray() ? type : *type.GetTypeParameters().at(0); if (typenames.IsPrimitiveTypename(element_type.GetName())) { return false; } if (typenames.GetEnumDeclaration(element_type)) { return false; } return true; } std::string RustLifetimeName(Lifetime lifetime) { switch (lifetime) { case Lifetime::NONE: return ""; case Lifetime::A: return "'a "; } } std::string RustLifetimeGeneric(Lifetime lifetime) { switch (lifetime) { case Lifetime::NONE: return ""; case Lifetime::A: return "<'a>"; } } std::string RustNameOf(const AidlTypeSpecifier& type, const AidlTypenames& typenames, StorageMode mode, Lifetime lifetime) { std::string rust_name; if (type.IsArray() || typenames.IsList(type)) { const auto& element_type = type.IsGeneric() ? (*type.GetTypeParameters().at(0)) : type; StorageMode element_mode; if (type.IsFixedSizeArray() && mode == StorageMode::PARCELABLE_FIELD) { // Elements of fixed-size array field need to have Default. element_mode = StorageMode::DEFAULT_VALUE; } else if (mode == StorageMode::OUT_ARGUMENT || mode == StorageMode::DEFAULT_VALUE) { // Elements need to have Default for resize_out_vec() element_mode = StorageMode::DEFAULT_VALUE; } else { element_mode = StorageMode::VALUE; } if (type.IsArray() && element_type.GetName() == "byte") { rust_name = "u8"; } else { rust_name = GetRustName(element_type, typenames, element_mode); } // Needs `Option` wrapping because type is not default constructible const bool default_option = element_mode == StorageMode::DEFAULT_VALUE && !AutoConstructor(element_type, typenames); // Needs `Option` wrapping due to being a nullable, non-primitive, non-enum type in a vector. const bool nullable_option = type.IsNullable() && UsesOptionInNullableVector(type, typenames); if (default_option || nullable_option) { rust_name = "Option<" + rust_name + ">"; } if (mode == StorageMode::UNSIZED_ARGUMENT) { rust_name = "[" + rust_name + "]"; } else if (type.IsFixedSizeArray()) { auto dimensions = type.GetFixedSizeArrayDimensions(); // T[N][M] => [[T; M]; N] for (auto it = rbegin(dimensions), end = rend(dimensions); it != end; it++) { rust_name = "[" + rust_name + "; " + std::to_string(*it) + "]"; } } else { rust_name = "Vec<" + rust_name + ">"; } } else { rust_name = GetRustName(type, typenames, mode); } if (mode == StorageMode::IN_ARGUMENT || mode == StorageMode::UNSIZED_ARGUMENT) { // If this is a nullable input argument, put the reference inside the option, // e.g., `Option<&str>` instead of `&Option` rust_name = "&" + RustLifetimeName(lifetime) + rust_name; } if (type.IsNullable() || // Some types don't implement Default, so we wrap them // in Option, which defaults to None (TypeNeedsOption(type, typenames) && (mode == StorageMode::DEFAULT_VALUE || mode == StorageMode::OUT_ARGUMENT || mode == StorageMode::PARCELABLE_FIELD))) { if (type.IsHeapNullable()) { rust_name = "Option>"; } else { rust_name = "Option<" + rust_name + ">"; } } if (mode == StorageMode::OUT_ARGUMENT || mode == StorageMode::INOUT_ARGUMENT) { rust_name = "&" + RustLifetimeName(lifetime) + "mut " + rust_name; } return rust_name; } StorageMode ArgumentStorageMode(const AidlArgument& arg, const AidlTypenames& typenames) { if (arg.IsOut()) { return arg.IsIn() ? StorageMode::INOUT_ARGUMENT : StorageMode::OUT_ARGUMENT; } const auto typeName = arg.GetType().GetName(); const auto definedType = typenames.TryGetDefinedType(typeName); const bool isEnum = definedType && definedType->AsEnumDeclaration() != nullptr; const bool isPrimitive = AidlTypenames::IsPrimitiveTypename(typeName); if (typeName == "String" || arg.GetType().IsDynamicArray() || typenames.IsList(arg.GetType())) { return StorageMode::UNSIZED_ARGUMENT; } else if (!(isPrimitive || isEnum) || arg.GetType().IsFixedSizeArray()) { return StorageMode::IN_ARGUMENT; } else { return StorageMode::VALUE; } } ReferenceMode ArgumentReferenceMode(const AidlArgument& arg, const AidlTypenames& typenames) { auto arg_mode = ArgumentStorageMode(arg, typenames); switch (arg_mode) { case StorageMode::IN_ARGUMENT: if (arg.GetType().IsNullable()) { // &Option => Option<&T> return ReferenceMode::AS_REF; } else { return ReferenceMode::REF; } case StorageMode::OUT_ARGUMENT: case StorageMode::INOUT_ARGUMENT: return ReferenceMode::MUT_REF; case StorageMode::UNSIZED_ARGUMENT: if (arg.GetType().IsNullable()) { // &Option => Option<&str> // &Option> => Option<&[T]> return ReferenceMode::AS_DEREF; } else { return ReferenceMode::REF; } default: return ReferenceMode::VALUE; } } std::string TakeReference(ReferenceMode ref_mode, const std::string& name) { switch (ref_mode) { case ReferenceMode::REF: return "&" + name; case ReferenceMode::MUT_REF: return "&mut " + name; case ReferenceMode::AS_REF: return name + ".as_ref()"; case ReferenceMode::AS_DEREF: return name + ".as_deref()"; default: return name; } } bool TypeIsInterface(const AidlTypeSpecifier& type, const AidlTypenames& typenames) { const auto definedType = typenames.TryGetDefinedType(type.GetName()); return definedType != nullptr && definedType->AsInterface() != nullptr; } bool TypeNeedsOption(const AidlTypeSpecifier& type, const AidlTypenames& typenames) { if (type.IsArray() || typenames.IsList(type)) { return false; } // Already an Option if (type.IsNullable()) { return false; } const string& aidl_name = type.GetName(); if (aidl_name == "IBinder") { return true; } if (aidl_name == "ParcelFileDescriptor") { return true; } if (aidl_name == "ParcelableHolder") { // ParcelableHolder never needs an Option because we always // call its new() constructor directly instead of default() return false; } // Strong values don't implement Default if (TypeIsInterface(type, typenames)) { return true; } return false; } } // namespace rust } // namespace aidl } // namespace android ./PaxHeaders.X/aidl_to_rust.h0100644 0000000 0000000 00000000034 15172120304 015135 xustar000000000 0000000 28 mtime=1776853188.2970000 aidl_to_rust.h0100644 0000000 0000000 00000005717 15172120304 012453 0ustar000000000 0000000 /* * 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. */ #pragma once #include "aidl_language.h" #include "aidl_typenames.h" namespace android { namespace aidl { namespace rust { // This header provides functions that translate AIDL things to Rust things. enum class StorageMode { VALUE, DEFAULT_VALUE, // Value that implements Default::default() IN_ARGUMENT, // Value for primitives, & for larger types UNSIZED_ARGUMENT, // Unsized input argument, e.g., str/slice OUT_ARGUMENT, // Mutable reference to write-only raw type INOUT_ARGUMENT, // Mutable reference to inout argument PARCELABLE_FIELD, // Field in a parcelable }; enum class ReferenceMode { VALUE, REF, MUT_REF, AS_REF, AS_DEREF, }; enum class Lifetime { NONE, A, }; inline bool IsReference(ReferenceMode ref_mode) { switch (ref_mode) { case ReferenceMode::REF: case ReferenceMode::MUT_REF: return true; default: return false; } } std::string ConstantValueDecorator( const AidlTypeSpecifier& type, const std::variant>& raw_value); std::string ConstantValueDecoratorRef( const AidlTypeSpecifier& type, const std::variant>& raw_value); std::string ArrayDefaultValue(const AidlTypeSpecifier& type); // Returns "'lifetime_name " including the initial apostrophe and the trailing space. // Returns empty string for NONE. std::string RustLifetimeName(Lifetime lifetime); // Returns "<'lifetime_name>" or empty string for NONE. std::string RustLifetimeGeneric(Lifetime lifetime); // Returns the Rust type signature of the AIDL type spec // This includes generic type parameters with array modifiers. // // The lifetime argument is used to annotate all references. std::string RustNameOf(const AidlTypeSpecifier& aidl, const AidlTypenames& typenames, StorageMode mode, Lifetime lifetime); StorageMode ArgumentStorageMode(const AidlArgument& arg, const AidlTypenames& typenames); ReferenceMode ArgumentReferenceMode(const AidlArgument& arg, const AidlTypenames& typenames); std::string TakeReference(ReferenceMode ref_mode, const std::string& name); bool TypeIsInterface(const AidlTypeSpecifier& type, const AidlTypenames& typenames); bool TypeNeedsOption(const AidlTypeSpecifier& type, const AidlTypenames& typenames); } // namespace rust } // namespace aidl } // namespace android ./PaxHeaders.X/aidl_typenames.cpp0100644 0000000 0000000 00000000034 15172120304 015776 xustar000000000 0000000 28 mtime=1776853188.2990000 aidl_typenames.cpp0100644 0000000 0000000 00000035557 15172120304 013321 0ustar000000000 0000000 /* * Copyright (C) 2018, The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "aidl_typenames.h" #include "aidl_language.h" #include "logging.h" #include #include #include #include #include #include #include #include using android::base::Split; using std::make_pair; using std::map; using std::pair; using std::set; using std::string; using std::unique_ptr; using std::vector; namespace android { namespace aidl { // The built-in AIDL types.. static const set kBuiltinTypes = {"void", "boolean", "byte", "char", "int", "long", "float", "double", "String", "List", "Map", "IBinder", "FileDescriptor", "CharSequence", "ParcelFileDescriptor", "ParcelableHolder"}; static const set kPrimitiveTypes = {"void", "boolean", "byte", "char", "int", "long", "float", "double"}; // Note: these types may look wrong because they look like Java // types, but they have long been supported from the time when Java // was the only target language of this compiler. They are added here for // backwards compatibility, but we internally treat them as List and Map, // respectively. static const map kJavaLikeTypeToAidlType = { {"java.util.List", "List"}, {"java.util.Map", "Map"}, {"android.os.ParcelFileDescriptor", "ParcelFileDescriptor"}, }; // Package name and type name can't be one of these as they are keywords // in Java and C++. Using these names will eventually cause compilation error, // so checking this here is not a must have, but early detection of errors // is always better. static const set kCppOrJavaReservedWord = { "break", "case", "catch", "char", "class", "continue", "default", "do", "double", "else", "enum", "false", "float", "for", "goto", "if", "int", "long", "new", "private", "protected", "public", "return", "short", "static", "switch", "this", "throw", "true", "try", "void", "volatile", "while"}; static bool HasValidNameComponents(const AidlDefinedType& defined) { bool success = true; vector pieces = Split(defined.GetCanonicalName(), "."); for (const string& piece : pieces) { if (kCppOrJavaReservedWord.find(piece) != kCppOrJavaReservedWord.end()) { AIDL_ERROR(defined) << defined.GetCanonicalName() << " is an invalid name because '" << piece << "' is a Java or C++ identifier."; success = false; } // not checking kJavaLikeTypeToAidl, since that wouldn't make sense here if (kBuiltinTypes.find(piece) != kBuiltinTypes.end()) { AIDL_ERROR(defined) << defined.GetCanonicalName() << " is an invalid name because '" << piece << "' is a built-in AIDL type."; success = false; } } return success; } bool AidlTypenames::IsIgnorableImport(const string& import) const { if (IsBuiltinTypename(import)) return true; static set ignore_import = { "android.os.IInterface", "android.os.IBinder", "android.os.Parcelable", "android.os.Parcel", "android.content.Context", "java.lang.String", "java.lang.CharSequence"}; // these known built-in types don't need to be imported if (ignore_import.find(import) != ignore_import.end()) return true; if (TryGetDefinedType(import)) return true; return false; } // Add a parsed document and populate type names in it. // Name conflict is an error unless one of them is from preprocessed. // For legacy, we populate unqualified names from preprocessed unstructured parcelable types // so that they can be referenced via a simple name. bool AidlTypenames::AddDocument(std::unique_ptr doc) { bool is_preprocessed = doc->IsPreprocessed(); std::vector types_to_add; // Add types in two steps to avoid adding a type while the doc is rejected. // 1. filter types to add // 2. add types std::function>&)> collect_types_to_add; collect_types_to_add = [&](auto& types) { for (const auto& type : types) { if (IsBuiltinTypename(type->GetName())) { // ParcelFileDescriptor is treated as a built-in type, but it's also in the framework.aidl. // So aidl should ignore built-in types in framework.aidl to prevent duplication. // (b/130899491) if (is_preprocessed) { continue; } // HasValidNameComponents handles name conflicts with built-in types } if (auto prev_definition = defined_types_.find(type->GetCanonicalName()); prev_definition != defined_types_.end()) { // Skip duplicate type in preprocessed document if (is_preprocessed) { continue; } // Overwrite duplicate type which is already added via preprocessed with a new one if (!prev_definition->second->GetDocument().IsPreprocessed()) { AIDL_ERROR(type) << "redefinition: " << type->GetCanonicalName() << " is defined " << prev_definition->second->GetLocation(); return false; } } if (!HasValidNameComponents(*type)) { return false; } types_to_add.push_back(type.get()); // recursively check nested types if (!collect_types_to_add(type->GetNestedTypes())) { return false; } } return true; }; if (!collect_types_to_add(doc->DefinedTypes())) { return false; } for (const auto& type : types_to_add) { // populate global 'type' namespace with fully-qualified names defined_types_.emplace(type->GetCanonicalName(), type); // preprocessed unstructured parcelable types can be referenced without qualification if (is_preprocessed && type->AsUnstructuredParcelable()) { defined_types_.emplace(type->GetName(), type); } } // transfer ownership of document documents_.push_back(std::move(doc)); return true; } const AidlDocument& AidlTypenames::MainDocument() const { AIDL_FATAL_IF(documents_.size() == 0, AIDL_LOCATION_HERE) << "Main document doesn't exist"; return *(documents_[0]); } bool AidlTypenames::IsBuiltinTypename(const string& type_name) { return kBuiltinTypes.find(type_name) != kBuiltinTypes.end() || kJavaLikeTypeToAidlType.find(type_name) != kJavaLikeTypeToAidlType.end(); } bool AidlTypenames::IsPrimitiveTypename(const string& type_name) { return kPrimitiveTypes.find(type_name) != kPrimitiveTypes.end(); } bool AidlTypenames::IsParcelable(const string& type_name) const { if (IsBuiltinTypename(type_name)) { return type_name == "ParcelableHolder" || type_name == "ParcelFileDescriptor"; } if (auto defined_type = TryGetDefinedType(type_name); defined_type) { return defined_type->AsParcelable() != nullptr; } return false; } const AidlDefinedType* AidlTypenames::TryGetDefinedType(const string& type_name) const { auto found_def = defined_types_.find(type_name); if (found_def != defined_types_.end()) { return found_def->second; } return nullptr; } std::vector AidlTypenames::AllDefinedTypes() const { std::vector res; for (const auto& doc : AllDocuments()) { VisitTopDown( [&](const AidlNode& node) { if (auto defined_type = AidlCast(node); defined_type) { res.push_back(defined_type); } }, *doc); } return res; } AidlTypenames::ResolvedTypename AidlTypenames::ResolveTypename(const string& type_name) const { if (IsBuiltinTypename(type_name)) { auto found = kJavaLikeTypeToAidlType.find(type_name); if (found != kJavaLikeTypeToAidlType.end()) { return {found->second, true, nullptr}; } return {type_name, true, nullptr}; } const AidlDefinedType* defined_type = TryGetDefinedType(type_name); if (defined_type != nullptr) { return {defined_type->GetCanonicalName(), true, defined_type}; } else { return {type_name, false, nullptr}; } } std::unique_ptr AidlTypenames::MakeResolvedType(const AidlLocation& location, const string& name, bool is_array) const { std::optional array; if (is_array) { array = DynamicArray{}; } std::unique_ptr type( new AidlTypeSpecifier(location, name, std::move(array), nullptr, {})); AIDL_FATAL_IF(!type->Resolve(*this, nullptr), type) << "Can't make unknown type: " << name; type->MarkVisited(); return type; } // Only immutable Parcelable, primitive type, and String, and List, Map, array of the types can be // immutable. bool AidlTypenames::CanBeJavaOnlyImmutable(const AidlTypeSpecifier& type) const { const string& name = type.GetName(); if (type.IsGeneric()) { if (type.GetName() == "List" || type.GetName() == "Map") { const auto& types = type.GetTypeParameters(); return std::all_of(types.begin(), types.end(), [this](const auto& t) { return CanBeJavaOnlyImmutable(*t); }); } AIDL_ERROR(type) << "For a generic type, an immutable parcelable can contain only List or Map."; return false; } if (IsPrimitiveTypename(name) || name == "String") { return true; } const AidlDefinedType* t = TryGetDefinedType(type.GetName()); if (t == nullptr) { AIDL_ERROR(type) << "An immutable parcelable can contain only immutable Parcelable, primitive " "type, and String."; return false; } if (t->AsEnumDeclaration()) { return true; } return t->IsJavaOnlyImmutable(); } // Followings can be FixedSize: // - @FixedSize parcelables // - primitive types and enum types // - fixed-size arrays of FixedSize types bool AidlTypenames::CanBeFixedSize(const AidlTypeSpecifier& type) const { const string& name = type.GetName(); if (type.IsGeneric() || type.IsNullable()) { return false; } if (type.IsArray() && !type.IsFixedSizeArray()) { return false; } if (IsPrimitiveTypename(name)) { return true; } if (IsBuiltinTypename(name)) { return false; } const AidlDefinedType* t = TryGetDefinedType(type.GetName()); AIDL_FATAL_IF(t == nullptr, type) << "Failed to look up type. Cannot determine if it can be fixed size: " << type.GetName(); if (t->AsEnumDeclaration()) { return true; } return t->IsFixedSize(); } bool AidlTypenames::IsList(const AidlTypeSpecifier& type) { return type.GetName() == "List"; } ArgumentAspect AidlTypenames::GetArgumentAspect(const AidlTypeSpecifier& type) const { if (type.IsArray()) { return {"array", {AidlArgument::Direction::IN_DIR, AidlArgument::Direction::OUT_DIR, AidlArgument::Direction::INOUT_DIR}}; } const string& name = type.GetName(); if (IsBuiltinTypename(name)) { if (name == "List" || name == "Map") { return {name, {AidlArgument::Direction::IN_DIR, AidlArgument::Direction::OUT_DIR, AidlArgument::Direction::INOUT_DIR}}; } else if (name == "ParcelFileDescriptor") { // "out ParcelFileDescriptor" is not allowed because ParcelFileDescriptor is not // default-constructible. return {name, {AidlArgument::Direction::IN_DIR, AidlArgument::Direction::INOUT_DIR}}; } else if (name == "ParcelableHolder") { // TODO(b/156872582): Support it when ParcelableHolder supports every backend. return {name, {}}; } else { return {name, {AidlArgument::Direction::IN_DIR}}; } } const AidlDefinedType* t = TryGetDefinedType(name); AIDL_FATAL_IF(t == nullptr, type) << "Unrecognized type: '" << name << "'"; // An 'out' field is passed as an argument, so it doesn't make sense if it is immutable. if (t->AsParcelable() != nullptr) { if (t->IsJavaOnlyImmutable()) { return {"@JavaOnlyImmutable", {AidlArgument::Direction::IN_DIR}}; } return {"parcelable/union", {AidlArgument::Direction::IN_DIR, AidlArgument::Direction::OUT_DIR, AidlArgument::Direction::INOUT_DIR}}; } return {t->GetPreprocessDeclarationName(), {AidlArgument::Direction::IN_DIR}}; } const AidlEnumDeclaration* AidlTypenames::GetEnumDeclaration(const AidlTypeSpecifier& type) const { if (auto defined_type = TryGetDefinedType(type.GetName()); defined_type != nullptr) { if (auto enum_decl = defined_type->AsEnumDeclaration(); enum_decl != nullptr) { return enum_decl; } } return nullptr; } const AidlInterface* AidlTypenames::GetInterface(const AidlTypeSpecifier& type) const { if (auto defined_type = TryGetDefinedType(type.GetName()); defined_type != nullptr) { if (auto intf = defined_type->AsInterface(); intf != nullptr) { return intf; } } return nullptr; } const AidlParcelable* AidlTypenames::GetParcelable(const AidlTypeSpecifier& type) const { if (auto defined_type = TryGetDefinedType(type.GetName()); defined_type != nullptr) { if (auto parcelable = defined_type->AsParcelable(); parcelable != nullptr) { return parcelable; } } return nullptr; } void AidlTypenames::IterateTypes(const std::function& body) const { for (const auto& kv : defined_types_) { body(*kv.second); } } bool AidlTypenames::Autofill() const { bool success = true; IterateTypes([&](const AidlDefinedType& type) { // BackingType is filled in for all known enums, including imported enums, // because other types that may use enums, such as Interface or // StructuredParcelable, need to know the enum BackingType when // generating code. if (auto enum_decl = const_cast(type).AsEnumDeclaration(); enum_decl) { if (!enum_decl->Autofill(*this)) { success = false; } } }); return success; } } // namespace aidl } // namespace android ./PaxHeaders.X/aidl_typenames.h0100644 0000000 0000000 00000000034 15172120304 015443 xustar000000000 0000000 28 mtime=1776853188.3000000 aidl_typenames.h0100644 0000000 0000000 00000007442 15172120304 012756 0ustar000000000 0000000 /* * Copyright (C) 2018, The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #pragma once #include #include #include #include #include #include #include #include using std::map; using std::optional; using std::pair; using std::set; using std::string; using std::unique_ptr; using std::vector; class AidlDefinedType; class AidlEnumDeclaration; class AidlInterface; class AidlLocation; class AidlParcelable; class AidlTypeSpecifier; class AidlDocument; struct ArgumentAspect; namespace android { namespace aidl { // AidlTypenames is a collection of AIDL types available to a compilation unit. // // Basic types (such as int, String, etc.) are added by default, while defined // types (such as IFoo, MyParcelable, etc.) and types from preprocessed inputs // are added as they are recognized by the parser. // // When AidlTypeSpecifier is encountered during parsing, parser defers the // resolution of it until the end of the parsing, where it uses AidlTypenames // to resolve type names in AidlTypeSpecifier. // // Note that nothing here is specific to either Java or C++. class AidlTypenames final { public: AidlTypenames() = default; bool AddDocument(std::unique_ptr doc); const std::vector>& AllDocuments() const { return documents_; } const AidlDocument& MainDocument() const; static bool IsBuiltinTypename(const string& type_name); static bool IsPrimitiveTypename(const string& type_name); bool IsParcelable(const string& type_name) const; const AidlDefinedType* TryGetDefinedType(const string& type_name) const; std::vector AllDefinedTypes() const; struct ResolvedTypename { std::string canonical_name; bool is_resolved; const AidlDefinedType* defined_type; }; ResolvedTypename ResolveTypename(const string& type_name) const; std::unique_ptr MakeResolvedType(const AidlLocation& location, const string& name, bool is_array) const; ArgumentAspect GetArgumentAspect(const AidlTypeSpecifier& type) const; bool CanBeJavaOnlyImmutable(const AidlTypeSpecifier& type) const; bool CanBeFixedSize(const AidlTypeSpecifier& type) const; static bool IsList(const AidlTypeSpecifier& type); bool IsIgnorableImport(const string& import) const; // Returns the AidlEnumDeclaration of the given type, or nullptr if the type // is not an AidlEnumDeclaration; const AidlEnumDeclaration* GetEnumDeclaration(const AidlTypeSpecifier& type) const; // Returns the AidlInterface of the given type, or nullptr if the type // is not an AidlInterface; const AidlInterface* GetInterface(const AidlTypeSpecifier& type) const; // Returns the AidlParcelable of the given type, or nullptr if the type // is not an AidlParcelable; const AidlParcelable* GetParcelable(const AidlTypeSpecifier& type) const; // Iterates over all defined types void IterateTypes(const std::function& body) const; // Fixes AST after type/ref resolution before validation bool Autofill() const; private: map defined_types_; std::vector> documents_; }; } // namespace aidl } // namespace android ./PaxHeaders.X/aidl_unittest.cpp0100644 0000000 0000000 00000000034 15172120304 015650 xustar000000000 0000000 28 mtime=1776853188.3020000 aidl_unittest.cpp0100644 0000000 0000000 00000746323 15172120304 013173 0ustar000000000 0000000 /* * Copyright (C) 2015, 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 #include #include #include #include #include #include #include #include #include #include #include #include "aidl_checkapi.h" #include "aidl_dumpapi.h" #include "aidl_language.h" #include "aidl_to_cpp.h" #include "aidl_to_cpp_common.h" #include "aidl_to_java.h" #include "aidl_to_ndk.h" #include "aidl_to_rust.h" #include "comments.h" #include "logging.h" #include "options.h" #include "parser.h" #include "preprocess.h" #include "tests/fake_io_delegate.h" using android::aidl::test::FakeIoDelegate; using android::base::StringPrintf; using std::map; using std::set; using std::string; using std::unique_ptr; using std::variant; using std::vector; using testing::HasSubstr; using testing::TestParamInfo; using testing::internal::CaptureStderr; using testing::internal::GetCapturedStderr; namespace android { namespace aidl { namespace { const char kExpectedDepFileContents[] = R"(place/for/output/p/IFoo.java : \ p/IFoo.aidl p/IFoo.aidl : )"; const char kExpectedNinjaDepFileContents[] = R"(place/for/output/p/IFoo.java : \ p/IFoo.aidl )"; const char kExpectedParcelableDeclarationDepFileContents[] = R"( : \ p/Foo.aidl p/Foo.aidl : )"; const char kExpectedStructuredParcelableDepFileContents[] = R"(place/for/output/p/Foo.java : \ p/Foo.aidl p/Foo.aidl : )"; } // namespace const string INVALID_INT8_VALUE = "Invalid type specifier for an int8 literal"; const string INVALID_FLOAT_VALUE = "Invalid type specifier for a literal float"; const string INVALID_OPERATION = "Cannot perform operation"; class AidlTest : public ::testing::TestWithParam { protected: AidlDefinedType* Parse(const string& path, const string& contents, AidlTypenames& typenames_, Options::Language lang, AidlError* error = nullptr, const vector additional_arguments = {}) { io_delegate_.SetFileContents(path, contents); vector args; args.emplace_back("aidl"); args.emplace_back("--min_sdk_version=current"); args.emplace_back("--lang=" + to_string(lang)); for (const string& s : additional_arguments) { args.emplace_back(s); } for (const string& f : preprocessed_files_) { args.emplace_back("--preprocessed=" + f); } args.emplace_back("--include=."); for (const string& i : import_paths_) { args.emplace_back("--include=" + i); } args.emplace_back(path); Options options = Options::From(args); vector imported_files; ImportResolver import_resolver{io_delegate_, path, import_paths_}; AidlError actual_error = ::android::aidl::internals::load_and_validate_aidl( path, options, io_delegate_, &typenames_, &imported_files); if (error != nullptr) { *error = actual_error; } if (actual_error != AidlError::OK) { return nullptr; } const auto& defined_types = typenames_.MainDocument().DefinedTypes(); EXPECT_EQ(1ul, defined_types.size()); return defined_types.front().get(); } void EvaluateInvalidAssignment(string content, string expected_stderr, AidlTypenames& typenames_, Options::Language lang) { AidlError error; CaptureStderr(); EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", content, typenames_, lang, &error)); EXPECT_THAT(GetCapturedStderr(), HasSubstr(expected_stderr)); }; void EvaluateValidAssignment(string content, string expected_stderr, AidlTypenames& typenames_, Options::Language lang) { AidlError error; CaptureStderr(); EXPECT_NE(nullptr, Parse("a/IFoo.aidl", content, typenames_, lang, &error)); EXPECT_THAT(GetCapturedStderr(), HasSubstr(expected_stderr)); }; Options::Language GetLanguage() { return GetParam(); } FakeIoDelegate io_delegate_; vector preprocessed_files_; set import_paths_; AidlTypenames typenames_; }; // Instantiate the AidlTest parameterized suite, calling all of the TEST_P // tests with each of the supported languages as a parameter. INSTANTIATE_TEST_SUITE_P(AidlTestSuite, AidlTest, testing::Values(Options::Language::CPP, Options::Language::JAVA, Options::Language::NDK, Options::Language::RUST), [](const testing::TestParamInfo& info) { return to_string(info.param); }); TEST_P(AidlTest, AcceptMissingPackage) { EXPECT_NE(nullptr, Parse("IFoo.aidl", "interface IFoo { }", typenames_, GetLanguage())); } TEST_P(AidlTest, EndsInSingleLineComment) { EXPECT_NE(nullptr, Parse("IFoo.aidl", "interface IFoo { } // foo", typenames_, GetLanguage())); } TEST_P(AidlTest, InterfaceRequiresCorrectPath) { const string expected_stderr = "ERROR: a/Foo.aidl:1.11-21: IBar should be declared in a file called a/IBar.aidl\n"; const std::string file_contents = "package a; interface IBar {}"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("a/Foo.aidl", file_contents, typenames_, GetLanguage())); EXPECT_EQ(expected_stderr, GetCapturedStderr()) << file_contents; } TEST_P(AidlTest, ParcelableRequiresCorrectPath) { const string expected_stderr = "ERROR: a/Foo.aidl:1.11-21: Bar should be declared in a file called a/Bar.aidl\n"; const std::string file_contents = "package a; interface Bar {}"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("a/Foo.aidl", file_contents, typenames_, GetLanguage())); EXPECT_EQ(expected_stderr, GetCapturedStderr()) << file_contents; } TEST_P(AidlTest, UnstructuredParcelableRequiresCorrectPath) { const string expected_stderr = "ERROR: a/Foo.aidl:1.22-26: Bar should be declared in a file called a/Bar.aidl\n"; const std::string file_contents = "package a; parcelable Bar cpp_header \"anything.h\";"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("a/Foo.aidl", file_contents, typenames_, GetLanguage())); EXPECT_EQ(expected_stderr, GetCapturedStderr()) << file_contents; } TEST_P(AidlTest, EnumRequiresCorrectPath) { const string expected_stderr = "ERROR: a/Foo.aidl:1.16-20: Bar should be declared in a file called a/Bar.aidl\n"; const std::string file_contents = "package a; enum Bar { A, }"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("a/Foo.aidl", file_contents, typenames_, GetLanguage())); EXPECT_EQ(expected_stderr, GetCapturedStderr()) << file_contents; } TEST_P(AidlTest, SupportOnlyOutParameters) { const string interface_list = "package a; interface IBar { void f(out List bar); }"; EXPECT_NE(nullptr, Parse("a/IBar.aidl", interface_list, typenames_, GetLanguage())); } TEST_P(AidlTest, RejectOutParametersForIBinder) { const string interface_ibinder = "package a; interface IBaz { void f(out IBinder bar); }"; const string expected_ibinder_stderr = "ERROR: a/IBaz.aidl:1.47-51: 'bar' can't be an out parameter because IBinder can only be an " "in parameter.\n"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("a/IBaz.aidl", interface_ibinder, typenames_, GetLanguage())); EXPECT_EQ(expected_ibinder_stderr, GetCapturedStderr()); } TEST_P(AidlTest, RejectsOutParametersInOnewayInterface) { const string oneway_interface = "package a; oneway interface IBar { void f(out int[] bar); }"; const string expected_stderr = "ERROR: a/IBar.aidl:1.40-42: oneway method 'f' cannot have out parameters\n"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("a/IBar.aidl", oneway_interface, typenames_, GetLanguage())); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_P(AidlTest, RejectsOutParametersInOnewayMethod) { const string oneway_method = "package a; interface IBar { oneway void f(out int[] bar); }"; const string expected_stderr = "ERROR: a/IBar.aidl:1.40-42: oneway method 'f' cannot have out parameters\n"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("a/IBar.aidl", oneway_method, typenames_, GetLanguage())); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_P(AidlTest, RejectsOnewayNonVoidReturn) { const string oneway_method = "package a; interface IFoo { oneway int f(); }"; const string expected_stderr = "ERROR: a/IFoo.aidl:1.39-41: oneway method 'f' cannot return a value\n"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", oneway_method, typenames_, GetLanguage())); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_P(AidlTest, RejectsNullablePrimitive) { const string oneway_method = "package a; interface IFoo { @nullable int f(); }"; const string expected_stderr = "ERROR: a/IFoo.aidl:1.38-42: Primitive type cannot get nullable annotation\n"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", oneway_method, typenames_, GetLanguage())); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_P(AidlTest, AcceptNullableList) { const string oneway_method = "package a; interface IFoo { @nullable List f(); }"; const string expected_stderr = ""; CaptureStderr(); EXPECT_NE(nullptr, Parse("a/IFoo.aidl", oneway_method, typenames_, GetLanguage())); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_P(AidlTest, RejectRecursiveParcelable) { CaptureStderr(); EXPECT_EQ(nullptr, Parse("Foo.aidl", "parcelable Foo { Foo foo; }", typenames_, GetLanguage())); EXPECT_THAT(GetCapturedStderr(), HasSubstr("Foo is a recursive parcelable")); } TEST_P(AidlTest, RejectIndirectRecursiveParcelable) { io_delegate_.SetFileContents("Bar.aidl", "parcelable Bar { Foo foo; }"); import_paths_.emplace(""); CaptureStderr(); EXPECT_EQ(nullptr, Parse("Foo.aidl", "parcelable Foo { Bar bar; }", typenames_, GetLanguage())); EXPECT_THAT(GetCapturedStderr(), HasSubstr("Foo is a recursive parcelable")); } TEST_P(AidlTest, RejectRecursiveTypeEvenIfNullable) { // Note: in native backends @nullable is mapped to non-heap wrapper like std::optional/Option io_delegate_.SetFileContents("Bar.aidl", "parcelable Bar { @nullable Foo foo; }"); import_paths_.emplace(""); CaptureStderr(); EXPECT_EQ(nullptr, Parse("Foo.aidl", "parcelable Foo { Bar bar; }", typenames_, GetLanguage())); EXPECT_THAT(GetCapturedStderr(), HasSubstr("Foo is a recursive parcelable")); } TEST_P(AidlTest, OkayIfRecursionInvolvesHeapType) { CaptureStderr(); std::string java_only_map_field; if (GetLanguage() == Options::Language::JAVA) { java_only_map_field = " Map map;\n"; } EXPECT_NE(nullptr, Parse("Foo.aidl", "parcelable Foo {\n" " List list;\n" + java_only_map_field + " Foo[] arr;\n" " @nullable(heap=true) Foo heap_nullable;\n" "}\n", typenames_, GetLanguage())); EXPECT_THAT(GetCapturedStderr(), ""); } TEST_P(AidlTest, InterfaceCanReferenceItself) { CaptureStderr(); EXPECT_NE(nullptr, Parse("IFoo.aidl", "interface IFoo { void foo(in IFoo self); }", typenames_, GetLanguage())); EXPECT_THAT(GetCapturedStderr(), ""); } TEST_P(AidlTest, HeapNullableCantApplyToOtherThanParcelables) { CaptureStderr(); EXPECT_EQ(nullptr, Parse("Foo.aidl", "parcelable Foo {\n" " @nullable(heap=true) String s;\n" "}", typenames_, GetLanguage())); EXPECT_THAT(GetCapturedStderr(), HasSubstr("@nullable(heap=true) is available to parcelables")); } TEST_P(AidlTest, RejectsDuplicatedArgumentNames) { const string method = "package a; interface IFoo { void f(int a, int a); }"; const string expected_stderr = "ERROR: a/IFoo.aidl:1.33-35: method 'f' has duplicate argument name 'a'\n"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", method, typenames_, GetLanguage())); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_P(AidlTest, RejectsDuplicatedFieldNames) { const string method = "package a; parcelable Foo { int a; String a; }"; const string expected_stderr = "ERROR: a/Foo.aidl:1.42-44: 'Foo' has duplicate field name 'a'\n"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("a/Foo.aidl", method, typenames_, GetLanguage())); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_P(AidlTest, AcceptsEmptyParcelable) { CaptureStderr(); EXPECT_NE(nullptr, Parse("Foo.aidl", "parcelable Foo {}", typenames_, GetLanguage())); EXPECT_EQ("", GetCapturedStderr()); } TEST_P(AidlTest, RejectsDuplicatedAnnotationParams) { const string method = "package a; interface IFoo { @UnsupportedAppUsage(foo=1, foo=2)void f(); }"; const string expected_stderr = "ERROR: a/IFoo.aidl:1.56-62: Trying to redefine parameter foo.\n"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", method, typenames_, GetLanguage())); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_P(AidlTest, RejectUnsupportedInterfaceAnnotations) { AidlError error; const string method = "package a; @nullable interface IFoo { int f(); }"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", method, typenames_, GetLanguage(), &error)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("@nullable is not available.")); EXPECT_EQ(AidlError::BAD_TYPE, error); } TEST_P(AidlTest, RejectUnsupportedTypeAnnotations) { AidlError error; const string method = "package a; interface IFoo { @JavaOnlyStableParcelable int f(); }"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", method, typenames_, GetLanguage(), &error)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("@JavaOnlyStableParcelable is not available.")); EXPECT_EQ(AidlError::BAD_TYPE, error); } TEST_P(AidlTest, RejectUnsupportedParcelableDefineAnnotations) { AidlError error; const string method = "package a; @nullable parcelable Foo { String a; String b; }"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("a/Foo.aidl", method, typenames_, GetLanguage(), &error)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("@nullable is not available.")); EXPECT_EQ(AidlError::BAD_TYPE, error); } TEST_P(AidlTest, ParsesNonNullableAnnotation) { auto parse_result = Parse("a/IFoo.aidl", "package a; interface IFoo { String f(); }", typenames_, GetLanguage()); ASSERT_NE(nullptr, parse_result); const AidlInterface* interface = parse_result->AsInterface(); ASSERT_NE(nullptr, interface); ASSERT_FALSE(interface->GetMethods().empty()); EXPECT_FALSE(interface->GetMethods()[0]->GetType().IsNullable()); } TEST_P(AidlTest, ParsesNullableAnnotation) { auto parse_result = Parse("a/IFoo.aidl", "package a; interface IFoo { @nullable String f(); }", typenames_, GetLanguage()); ASSERT_NE(nullptr, parse_result); const AidlInterface* interface = parse_result->AsInterface(); ASSERT_NE(nullptr, interface); ASSERT_FALSE(interface->GetMethods().empty()); EXPECT_TRUE(interface->GetMethods()[0]->GetType().IsNullable()); } TEST_P(AidlTest, ParsesNonUtf8Annotations) { auto parse_result = Parse("a/IFoo.aidl", "package a; interface IFoo { String f(); }", typenames_, GetLanguage()); ASSERT_NE(nullptr, parse_result); const AidlInterface* interface = parse_result->AsInterface(); ASSERT_NE(nullptr, interface); ASSERT_FALSE(interface->GetMethods().empty()); EXPECT_FALSE(interface->GetMethods()[0]->GetType().IsUtf8InCpp()); } TEST_P(AidlTest, ParsesUtf8Annotations) { auto parse_result = Parse("a/IFoo.aidl", "package a; interface IFoo { @utf8InCpp String f(); }", typenames_, GetLanguage()); ASSERT_NE(nullptr, parse_result); const AidlInterface* interface = parse_result->AsInterface(); ASSERT_NE(nullptr, interface); ASSERT_FALSE(interface->GetMethods().empty()); EXPECT_TRUE(interface->GetMethods()[0]->GetType().IsUtf8InCpp()); } TEST_P(AidlTest, VintfRequiresStructuredAndStability) { AidlError error; const string expected_stderr = "ERROR: IFoo.aidl:1.16-26: Must compile @VintfStability type w/ aidl_interface 'stability: " "\"vintf\"'\n" "ERROR: IFoo.aidl:1.16-26: Must compile @VintfStability type w/ aidl_interface " "--structured\n"; CaptureStderr(); ASSERT_EQ(nullptr, Parse("IFoo.aidl", "@VintfStability interface IFoo {}", typenames_, GetLanguage(), &error)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); ASSERT_EQ(AidlError::NOT_STRUCTURED, error); } TEST_P(AidlTest, VintfRequiresStructured) { AidlError error; const string expected_stderr = "ERROR: IFoo.aidl:1.16-26: Must compile @VintfStability type w/ aidl_interface " "--structured\n"; CaptureStderr(); ASSERT_EQ(nullptr, Parse("IFoo.aidl", "@VintfStability interface IFoo {}", typenames_, GetLanguage(), &error, {"--stability", "vintf"})); EXPECT_EQ(expected_stderr, GetCapturedStderr()); ASSERT_EQ(AidlError::NOT_STRUCTURED, error); } TEST_P(AidlTest, VintfRequiresSpecifiedStability) { AidlError error; const string expected_stderr = "ERROR: IFoo.aidl:1.16-26: Must compile @VintfStability type w/ aidl_interface 'stability: " "\"vintf\"'\n"; CaptureStderr(); ASSERT_EQ(nullptr, Parse("IFoo.aidl", "@VintfStability interface IFoo {}", typenames_, GetLanguage(), &error, {"--structured"})); EXPECT_EQ(expected_stderr, GetCapturedStderr()); ASSERT_EQ(AidlError::NOT_STRUCTURED, error); } TEST_P(AidlTest, ParsesStabilityAnnotations) { AidlError error; auto parse_result = Parse("IFoo.aidl", "@VintfStability interface IFoo {}", typenames_, GetLanguage(), &error, {"--structured", "--stability", "vintf"}); ASSERT_EQ(AidlError::OK, error); ASSERT_NE(nullptr, parse_result); const AidlInterface* interface = parse_result->AsInterface(); ASSERT_NE(nullptr, interface); ASSERT_TRUE(interface->IsVintfStability()); } TEST_P(AidlTest, TypesShouldHaveVintfStabilityWhenCompilingWithTheVintfFlag) { CaptureStderr(); string code = "@VintfStability\n" "parcelable Foo {\n" " interface INested { interface INastyNester {} }" "}"; EXPECT_NE(nullptr, Parse("Foo.aidl", code, typenames_, GetLanguage(), nullptr, {"--structured", "--stability", "vintf"})); EXPECT_EQ(GetCapturedStderr(), ""); auto nested = typenames_.TryGetDefinedType("Foo.INested"); ASSERT_NE(nullptr, nested); ASSERT_TRUE(nested->IsVintfStability()); auto nastyNester = typenames_.TryGetDefinedType("Foo.INested.INastyNester"); ASSERT_NE(nullptr, nastyNester); ASSERT_TRUE(nastyNester->IsVintfStability()); } TEST_P(AidlTest, VintfStabilityAppliesToNestedTypesAsWell) { CaptureStderr(); EXPECT_EQ(nullptr, Parse("Foo.aidl", "parcelable Foo {}", typenames_, GetLanguage(), nullptr, {"--structured", "--stability", "vintf"})); EXPECT_THAT(GetCapturedStderr(), HasSubstr("Foo does not have VINTF level stability (marked @VintfStability)")); } TEST_F(AidlTest, ParsesJavaOnlyStableParcelable) { Options java_options = Options::From("aidl -I . -o out --structured a/Foo.aidl"); Options cpp_options = Options::From("aidl -I . --lang=cpp -o out -h out/include a/Foo.aidl"); Options cpp_structured_options = Options::From("aidl --lang=cpp -I . --structured -o out -h out/include a/Foo.aidl"); Options rust_options = Options::From("aidl -I . --lang=rust -o out --structured a/Foo.aidl"); io_delegate_.SetFileContents( "a/Foo.aidl", StringPrintf("package a; @JavaOnlyStableParcelable parcelable Foo cpp_header \"Foo.h\" ;")); EXPECT_TRUE(compile_aidl(java_options, io_delegate_)); EXPECT_TRUE(compile_aidl(cpp_options, io_delegate_)); CaptureStderr(); EXPECT_FALSE(compile_aidl(cpp_structured_options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("Cannot declare unstructured")); CaptureStderr(); EXPECT_FALSE(compile_aidl(rust_options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("Cannot declare unstructured")); } TEST_F(AidlTest, ParsesNdkOnlyStableParcelable) { Options java_options = Options::From("aidl -I . -o out --structured a/Foo.aidl"); Options ndk_structured_options = Options::From("aidl --lang=ndk --structured -I . -o out -h out/include a/Foo.aidl"); Options rust_options = Options::From("aidl --lang=rust -I . -o out --structured a/Foo.aidl"); Options cpp_options = Options::From("aidl --lang=cpp -I . -o out -h out/include a/Foo.aidl"); io_delegate_.SetFileContents( "a/Foo.aidl", StringPrintf("package a; @NdkOnlyStableParcelable parcelable Foo cpp_header \"Foo.h\" ;")); EXPECT_TRUE(compile_aidl(cpp_options, io_delegate_)); // not considered unstructured, but it still can't be compiled directly with // --structured AIDL - it can only be used as an import CaptureStderr(); EXPECT_FALSE(compile_aidl(ndk_structured_options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("Refusing to generate code with unstructured parcelables")); CaptureStderr(); EXPECT_FALSE(compile_aidl(java_options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("Cannot declare unstructured")); CaptureStderr(); EXPECT_FALSE(compile_aidl(rust_options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("Cannot declare unstructured")); } TEST_P(AidlTest, NdkAndJavaAndRustStabilityIsVintfStable) { CaptureStderr(); io_delegate_.SetFileContents( "NonPortableThing.aidl", "@NdkOnlyStableParcelable @JavaOnlyStableParcelable @RustOnlyStableParcelable parcelable " "NonPortableThing ndk_header \"lol.h\" cpp_header \"lolol.h\" rust_type \"lol::Lol\";"); import_paths_.emplace(""); auto result = Parse("IFoo.aidl", "import NonPortableThing; @VintfStability interface IFoo { NonPortableThing get(); }", typenames_, GetLanguage(), nullptr, {"--structured", "--stability", "vintf"}); if (GetLanguage() == Options::Language::NDK || GetLanguage() == Options::Language::JAVA || GetLanguage() == Options::Language::RUST) { EXPECT_NE(result, nullptr); EXPECT_EQ(GetCapturedStderr(), ""); } else { EXPECT_EQ(result, nullptr); EXPECT_THAT( GetCapturedStderr(), HasSubstr("NonPortableThing does not have VINTF level stability (marked @VintfStability)")); } } TEST_F(AidlTest, ParcelableSupportJavaDeriveToString) { io_delegate_.SetFileContents("a/Foo.aidl", R"(package a; @JavaDerive(toString=true) parcelable Foo { int a; float b; })"); Options java_options = Options::From("aidl --lang=java -I . -o out a/Foo.aidl"); EXPECT_TRUE(compile_aidl(java_options, io_delegate_)); string java_out; EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/Foo.java", &java_out)); EXPECT_THAT(java_out, testing::HasSubstr("public String toString() {")); // Other backends shouldn't be bothered Options cpp_options = Options::From("aidl --lang=cpp -I . -o out -h out a/Foo.aidl"); EXPECT_TRUE(compile_aidl(cpp_options, io_delegate_)); Options ndk_options = Options::From("aidl --lang=ndk -I . -o out -h out a/Foo.aidl"); EXPECT_TRUE(compile_aidl(ndk_options, io_delegate_)); } TEST_F(AidlTest, UnionSupportJavaDeriveToString) { io_delegate_.SetFileContents("a/Foo.aidl", R"(package a; @JavaDerive(toString=true) union Foo { int a; int[] b; })"); CaptureStderr(); Options java_options = Options::From("aidl --lang=java -I . -o out a/Foo.aidl"); EXPECT_TRUE(compile_aidl(java_options, io_delegate_)); EXPECT_EQ("", GetCapturedStderr()); } TEST_F(AidlTest, ParcelableSupportJavaDeriveEquals) { io_delegate_.SetFileContents("a/Foo.aidl", R"(package a; @JavaDerive(equals=true) parcelable Foo { int a; float b; })"); CaptureStderr(); Options java_options = Options::From("aidl --lang=java -I . -o out a/Foo.aidl"); EXPECT_TRUE(compile_aidl(java_options, io_delegate_)); EXPECT_EQ("", GetCapturedStderr()); const std::string expected = R"--( @Override public boolean equals(Object other) { if (this == other) return true; if (other == null) return false; if (!(other instanceof Foo)) return false; Foo that = (Foo)other; if (!java.util.Objects.deepEquals(a, that.a)) return false; if (!java.util.Objects.deepEquals(b, that.b)) return false; return true; } @Override public int hashCode() { return java.util.Arrays.deepHashCode(java.util.Arrays.asList(a, b).toArray()); } )--"; string java_out; EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/Foo.java", &java_out)); EXPECT_THAT(java_out, testing::HasSubstr(expected)); } TEST_F(AidlTest, UnionSupportJavaDeriveEquals) { io_delegate_.SetFileContents("a/Foo.aidl", R"(package a; @JavaDerive(equals=true) union Foo { int a; int[] b; })"); CaptureStderr(); Options java_options = Options::From("aidl --lang=java -I . -o out a/Foo.aidl"); EXPECT_TRUE(compile_aidl(java_options, io_delegate_)); EXPECT_EQ("", GetCapturedStderr()); const std::string expected = R"--( @Override public boolean equals(Object other) { if (this == other) return true; if (other == null) return false; if (!(other instanceof Foo)) return false; Foo that = (Foo)other; if (_tag != that._tag) return false; if (!java.util.Objects.deepEquals(_value, that._value)) return false; return true; } @Override public int hashCode() { return java.util.Arrays.deepHashCode(java.util.Arrays.asList(_tag, _value).toArray()); } )--"; string java_out; EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/Foo.java", &java_out)); EXPECT_THAT(java_out, testing::HasSubstr(expected)); } TEST_F(AidlTest, RejectsJavaDeriveAnnotation) { { io_delegate_.SetFileContents("a/Foo.aidl", "package a; @JavaDerive(blah=true) parcelable Foo{}"); Options java_options = Options::From("aidl --lang=java -I . -o out a/Foo.aidl"); CaptureStderr(); EXPECT_FALSE(compile_aidl(java_options, io_delegate_)); const std::string expected_stderr = "ERROR: a/Foo.aidl:1.11-34: Parameter blah not supported for annotation JavaDerive."; EXPECT_THAT(GetCapturedStderr(), HasSubstr("Parameter blah not supported for annotation JavaDerive.")); } { io_delegate_.SetFileContents("a/IFoo.aidl", "package a; @JavaDerive interface IFoo{}"); Options java_options = Options::From("aidl --lang=java -I . -o out a/IFoo.aidl"); CaptureStderr(); EXPECT_FALSE(compile_aidl(java_options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("@JavaDerive is not available.")); } } TEST_P(AidlTest, ParseDescriptorAnnotation) { AidlError error; auto parse_result = Parse("IFoo.aidl", R"(@Descriptor(value="IBar") interface IFoo{})", typenames_, GetLanguage(), &error, {"--structured"}); ASSERT_EQ(AidlError::OK, error); ASSERT_NE(nullptr, parse_result); const AidlInterface* interface = parse_result->AsInterface(); ASSERT_NE(nullptr, interface); ASSERT_EQ("IBar", interface->GetDescriptor()); } TEST_P(AidlTest, UnknownAnnotation) { CaptureStderr(); EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", "package a; @Unknown interface IFoo { }", typenames_, GetLanguage())); EXPECT_THAT(GetCapturedStderr(), HasSubstr("not a recognized annotation")); CaptureStderr(); EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", "package a; @Unknown(param=true) interface IFoo { }", typenames_, GetLanguage())); EXPECT_THAT(GetCapturedStderr(), HasSubstr("not a recognized annotation")); } TEST_P(AidlTest, AcceptsOnewayMethod) { const string oneway_method = "package a; interface IFoo { oneway void f(int a); }"; EXPECT_NE(nullptr, Parse("a/IFoo.aidl", oneway_method, typenames_, GetLanguage())); } TEST_P(AidlTest, AcceptsOnewayInterface) { const string oneway_interface = "package a; oneway interface IBar { void f(int a); }"; EXPECT_NE(nullptr, Parse("a/IBar.aidl", oneway_interface, typenames_, GetLanguage())); } TEST_P(AidlTest, AcceptsAnnotatedOnewayMethod) { const string oneway_method = "package a; interface IFoo { @UnsupportedAppUsage oneway void f(int a); }"; EXPECT_NE(nullptr, Parse("a/IFoo.aidl", oneway_method, typenames_, GetLanguage())); } TEST_P(AidlTest, AnnotationsInMultiplePlaces) { const string oneway_method = "package a; interface IFoo { @UnsupportedAppUsage oneway @PropagateAllowBlocking void f(int " "a); }"; const AidlDefinedType* defined = Parse("a/IFoo.aidl", oneway_method, typenames_, GetLanguage()); ASSERT_NE(nullptr, defined); const AidlInterface* iface = defined->AsInterface(); ASSERT_NE(nullptr, iface); const auto& methods = iface->GetMethods(); ASSERT_EQ(1u, methods.size()); const auto& method = methods[0]; const AidlTypeSpecifier& ret_type = method->GetType(); // TODO(b/151102494): these annotations should be on the method ASSERT_NE(nullptr, ret_type.UnsupportedAppUsage()); ASSERT_TRUE(ret_type.IsPropagateAllowBlocking()); } TEST_P(AidlTest, AnnotationValueAttribute) { const string content = "package a; @Descriptor(\"descriptor_value\") interface IFoo { void f(int a); }"; const AidlDefinedType* defined = Parse("a/IFoo.aidl", content, typenames_, GetLanguage()); ASSERT_NE(nullptr, defined); const AidlInterface* iface = defined->AsInterface(); ASSERT_NE(nullptr, iface); ASSERT_EQ("descriptor_value", iface->GetDescriptor()); } TEST_F(AidlTest, CheckApiForAnnotationValueAttribute) { Options options = Options::From("aidl --checkapi=equal old new"); io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p; @Descriptor(value=\"v1\") interface IFoo{ void foo();}"); io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p; @Descriptor(\"v1\") interface IFoo{ void foo();}"); EXPECT_TRUE(::android::aidl::check_api(options, io_delegate_)); } TEST_P(AidlTest, WritesComments) { string foo_interface = R"(package a; /* foo */ interface IFoo { /* i */ int i(); // j @nullable String j(); // k1 /* k2 */ @UnsupportedAppUsage oneway void k(int a); })"; CaptureStderr(); auto parse_result = Parse("a/IFoo.aidl", foo_interface, typenames_, GetLanguage()); EXPECT_NE(nullptr, parse_result); EXPECT_EQ("", GetCapturedStderr()); EXPECT_EQ((Comments{{"/* foo */"}}), parse_result->GetComments()); const AidlInterface* interface = parse_result->AsInterface(); EXPECT_EQ((Comments{{"/* i */"}}), interface->GetMethods()[0]->GetComments()); EXPECT_EQ((Comments{{"// j\n"}}), interface->GetMethods()[1]->GetComments()); EXPECT_EQ((Comments{{"// k1\n"}, {"/* k2 */"}}), interface->GetMethods()[2]->GetComments()); } TEST_P(AidlTest, CppHeaderCanBeIdentifierAsWell) { io_delegate_.SetFileContents("p/cpp_header.aidl", R"(package p; parcelable cpp_header cpp_header "bar/header" ndk_header "ndk/bar/header" )" R"(rust_type "package::SomeType";)"); import_paths_.emplace(""); const string input_path = "p/IFoo.aidl"; const string input = R"(package p; import p.cpp_header; interface IFoo { // get bar cpp_header get(); })"; auto parse_result = Parse(input_path, input, typenames_, GetLanguage()); EXPECT_NE(nullptr, parse_result); const AidlInterface* interface = parse_result->AsInterface(); EXPECT_EQ((Comments{{"// get bar\n"}}), interface->GetMethods()[0]->GetComments()); } TEST_F(AidlTest, RejectsIfCppHeaderIsMissing) { io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo;"); Options options = Options::From("aidl -I . --lang cpp -h h -o o Foo.aidl"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("must have cpp_header defined")); } TEST_F(AidlTest, RejectsIfTypeRefsCppHeaderIsMissing) { io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo;"); io_delegate_.SetFileContents("IBar.aidl", "interface IBar { void bar(in Foo foo); }"); Options options = Options::From("aidl -I . --lang cpp -h h -o o IBar.aidl"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("must have cpp_header defined")); } TEST_F(AidlTest, ParsesPreprocessedFile) { string simple_content = "parcelable a.Foo;\ninterface b.IBar;"; io_delegate_.SetFileContents("path", simple_content); EXPECT_FALSE(typenames_.ResolveTypename("a.Foo").is_resolved); EXPECT_TRUE(Parser::Parse("path", io_delegate_, typenames_, /*is_preprocessed=*/true)); EXPECT_TRUE(typenames_.ResolveTypename("a.Foo").is_resolved); EXPECT_TRUE(typenames_.ResolveTypename("b.IBar").is_resolved); } TEST_F(AidlTest, ParsesPreprocessedFileWithWhitespace) { string simple_content = "parcelable a.Foo;\n interface b.IBar ;\t"; io_delegate_.SetFileContents("path", simple_content); EXPECT_FALSE(typenames_.ResolveTypename("a.Foo").is_resolved); EXPECT_TRUE(Parser::Parse("path", io_delegate_, typenames_, /*is_preprocessed=*/true)); EXPECT_TRUE(typenames_.ResolveTypename("a.Foo").is_resolved); EXPECT_TRUE(typenames_.ResolveTypename("b.IBar").is_resolved); } TEST_P(AidlTest, PreferImportToPreprocessed) { io_delegate_.SetFileContents("preprocessed", "interface another.IBar;"); io_delegate_.SetFileContents("one/IBar.aidl", "package one; " "interface IBar {}"); preprocessed_files_.push_back("preprocessed"); import_paths_.emplace(""); auto parse_result = Parse("p/IFoo.aidl", "package p; import one.IBar; interface IFoo {}", typenames_, GetLanguage()); EXPECT_NE(nullptr, parse_result); // We expect to know about both kinds of IBar EXPECT_TRUE(typenames_.ResolveTypename("one.IBar").is_resolved); EXPECT_TRUE(typenames_.ResolveTypename("another.IBar").is_resolved); // But if we request just "IBar" we should get our imported one. AidlTypeSpecifier ambiguous_type(AIDL_LOCATION_HERE, "IBar", /*array=*/std::nullopt, nullptr, {}); ambiguous_type.Resolve(typenames_, parse_result); EXPECT_EQ("one.IBar", ambiguous_type.GetName()); } // Special case of PreferImportToPreprocessed. Imported type should be preferred // even when the preprocessed file already has the same type. TEST_P(AidlTest, B147918827) { io_delegate_.SetFileContents("preprocessed", "interface another.IBar;\ninterface one.IBar;"); io_delegate_.SetFileContents("one/IBar.aidl", "package one; " "interface IBar {}"); preprocessed_files_.push_back("preprocessed"); import_paths_.emplace(""); auto parse_result = Parse("p/IFoo.aidl", "package p; import one.IBar; interface IFoo {}", typenames_, GetLanguage()); EXPECT_NE(nullptr, parse_result); // We expect to know about both kinds of IBar EXPECT_TRUE(typenames_.ResolveTypename("one.IBar").is_resolved); EXPECT_TRUE(typenames_.ResolveTypename("another.IBar").is_resolved); // But if we request just "IBar" we should get our imported one. AidlTypeSpecifier ambiguous_type(AIDL_LOCATION_HERE, "IBar", /*array=*/std::nullopt, nullptr, {}); ambiguous_type.Resolve(typenames_, parse_result); EXPECT_EQ("one.IBar", ambiguous_type.GetName()); } TEST_F(AidlTest, WritePreprocessedFile) { io_delegate_.SetFileContents("p/Outer.aidl", "package p; parcelable Outer.Inner;"); io_delegate_.SetFileContents("one/IBar.aidl", "package one; import p.Outer;" "interface IBar {}"); vector args{"aidl", "--preprocess", "preprocessed", "-I.", "p/Outer.aidl", "one/IBar.aidl"}; Options options = Options::From(args); EXPECT_TRUE(::android::aidl::Preprocess(options, io_delegate_)); std::map expected = {{"preprocessed", "parcelable p.Outer.Inner;\n" "interface one.IBar {\n" "}\n"}}; EXPECT_THAT(io_delegate_.OutputFiles(), testing::Eq(expected)); } TEST_F(AidlTest, PreprocessVariousThings) { io_delegate_.SetFileContents("foo/bar/IFoo.aidl", "package foo.bar;\n" "interface IFoo {\n" " int foo();\n" " const int FOO = foo.bar.Bar.BAR + 1; // should be 44\n" "}\n"); io_delegate_.SetFileContents("foo/bar/Bar.aidl", "package foo.bar;\n" "parcelable Bar {\n" " const int BAR = imported.Foo.FOO + 1; // should be 43\n" " imported.Foo foo;\n" "}\n"); io_delegate_.SetFileContents("foo/bar/Gen.aidl", "package foo.bar;\n" "parcelable Gen {\n" "}\n"); io_delegate_.SetFileContents("foo/bar/Enum.aidl", "package foo.bar;\n" "enum Enum {\n" " FOO = 3, BAR = FOO + 3, // should be 3, 6\n" "}\n"); io_delegate_.SetFileContents("sub/imported/Foo.aidl", "package imported;\n" "parcelable Foo {\n" " const int FOO = 42;\n" "}\n"); vector args = { "aidl", "--preprocess", "preprocessed", "-Isub", "-I.", "foo/bar/IFoo.aidl", "foo/bar/Bar.aidl", "foo/bar/Gen.aidl", "foo/bar/Enum.aidl", }; ASSERT_TRUE(Preprocess(Options::From(args), io_delegate_)); std::string preprocessed = "interface foo.bar.IFoo {\n" " const int FOO = 44;\n" "}\n" "parcelable foo.bar.Bar {\n" " const int BAR = 43;\n" "}\n" "parcelable foo.bar.Gen {\n" "}\n" "enum foo.bar.Enum {\n" " FOO = 3,\n" " BAR = 6,\n" "}\n"; std::map expected = {{"preprocessed", preprocessed}}; EXPECT_THAT(io_delegate_.OutputFiles(), testing::Eq(expected)); // use preprocessed io_delegate_.SetFileContents("a/Foo.aidl", "package a; parcelable Foo { const int y = foo.bar.Bar.BAR; }"); io_delegate_.SetFileContents("preprocessed", preprocessed); CaptureStderr(); auto options = Options::From("aidl --lang java -I . -o out a/Foo.aidl -ppreprocessed"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); EXPECT_EQ("", GetCapturedStderr()); string code; EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/Foo.java", &code)); EXPECT_THAT(code, testing::HasSubstr("public static final int y = 43;")); } TEST_F(AidlTest, AllowMultipleUnstructuredNestedParcelablesInASingleDocument) { io_delegate_.SetFileContents("p/IFoo.aidl", "package p;\n" "import x.Outer;\n" "interface IFoo {\n" " void foo(in Outer.Inner1 in1, in Outer.Inner2 in2);\n" "}"); io_delegate_.SetFileContents("imported/x/Outer.aidl", "package x;\n" "parcelable Outer.Inner1;\n" "parcelable Outer.Inner2;\n"); auto opt = Options::From("aidl -I . -Iimported --lang=java p/IFoo.aidl"); CaptureStderr(); EXPECT_TRUE(compile_aidl(opt, io_delegate_)); EXPECT_EQ("", GetCapturedStderr()); } TEST_F(AidlTest, StubsSourceIsGeneratedFromDuplicateDefinitionWithFrameworkAidl_FrameworkAidlLater) { // Main doc(Foo.aidl) is loaded // And then framework.aidl is loaded as preprocessed. (conflict) io_delegate_.SetFileContents("sdk/framework.aidl", "parcelable x.Foo.Inner;\n"); io_delegate_.SetFileContents("x/Foo.aidl", "package x;\n" "parcelable Foo.Inner;\n"); auto opt = Options::From("aidl -psdk/framework.aidl -I. x/Foo.aidl"); CaptureStderr(); EXPECT_TRUE(compile_aidl(opt, io_delegate_)); EXPECT_EQ("", GetCapturedStderr()); } TEST_F(AidlTest, StubsSourceIsGeneratedFromDuplicateDefinitionWithFrameworkAidl_FrameworkAidlFirst) { // Main doc(IBar.aidl) is loaded first. // Framework.aidl is loaded as preprocessed. // And then import(Foo.aidl) is loaded. (conflict) io_delegate_.SetFileContents("sdk/framework.aidl", "parcelable x.Foo.Inner;\n"); io_delegate_.SetFileContents("x/IBar.aidl", "package x;\n" "import x.Foo;\n" "interface IBar {\n" " void bar(in Foo.Inner inner);\n" "}"); io_delegate_.SetFileContents("x/Foo.aidl", "package x;\n" "parcelable Foo.Inner;\n"); auto opt = Options::From("aidl -psdk/framework.aidl -I. x/IBar.aidl"); CaptureStderr(); EXPECT_TRUE(compile_aidl(opt, io_delegate_)); EXPECT_EQ("", GetCapturedStderr()); } TEST_F(AidlTest, PreprocessedFileCantDeclarePackage) { string simple_content = "package xxx; parcelable a.Foo;"; io_delegate_.SetFileContents("path", simple_content); CaptureStderr(); EXPECT_FALSE(Parser::Parse("path", io_delegate_, typenames_, /*is_preprocessed=*/true)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("Preprocessed file can't declare package.")); } TEST_F(AidlTest, RejectQualifiedTypeNameUnlessPreprocessed) { string simple_content = "parcelable a.Foo {}"; io_delegate_.SetFileContents("path", simple_content); CaptureStderr(); EXPECT_FALSE(Parser::Parse("path", io_delegate_, typenames_, /*is_preprocessed=*/false)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("Type name can't be qualified")); } TEST_P(AidlTest, PreprocessedCanDeclareJavaStyleBuiltinTypes) { string contents = R"( interface android.os.IBinder; interface android.os.IInterface; parcelable android.os.ParcelFileDescriptor; )"; io_delegate_.SetFileContents("path", contents); CaptureStderr(); EXPECT_TRUE(Parser::Parse("path", io_delegate_, typenames_, /*is_preprocessed=*/true)); EXPECT_THAT(GetCapturedStderr(), ""); } TEST_P(AidlTest, SupportDeprecated) { struct TestCase { std::string output_file; std::string annotation; }; auto CheckDeprecated = [&](const std::string& filename, const std::string& contents, std::vector> expectations) { io_delegate_.SetFileContents(filename, contents); auto options = Options::From("aidl -I . --lang=" + to_string(GetLanguage()) + " " + filename + " --out=out --header_out=out"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); for (const auto& [lang, test_case] : expectations) { if (lang != GetLanguage()) continue; string output; EXPECT_TRUE(io_delegate_.GetWrittenContents(test_case.output_file, &output)); EXPECT_THAT(output, HasSubstr(test_case.annotation)); } }; // Emit escaped string for notes CheckDeprecated( "IFoo.aidl", R"(interface IFoo { /** * @note asdf * @deprecated a really long deprecation message * * which is really long * @param foo bar */ List foo(); })", { {Options::Language::JAVA, {"out/IFoo.java", "@Deprecated"}}, {Options::Language::CPP, {"out/IFoo.h", R"(__attribute__((deprecated("a really long deprecation message which is really long"))))"}}, {Options::Language::NDK, {"out/aidl/IFoo.h", R"(__attribute__((deprecated("a really long deprecation message which is really long"))))"}}, {Options::Language::RUST, {"out/IFoo.rs", R"(#[deprecated = "a really long deprecation message which is really long"])"}}, }); // In AIDL @deprecated can be in block comments as well as javadoc style CheckDeprecated( "IFoo.aidl", "interface IFoo {\n" " /* @deprecated use bar() */\n" " List foo();\n" "}", { {Options::Language::JAVA, {"out/IFoo.java", "@Deprecated"}}, {Options::Language::JAVA, {"out/IFoo.java", "/** @deprecated use bar() */"}}, {Options::Language::CPP, {"out/IFoo.h", "__attribute__((deprecated(\"use bar()\")))"}}, {Options::Language::NDK, {"out/aidl/IFoo.h", "__attribute__((deprecated(\"use bar()\")))"}}, {Options::Language::RUST, {"out/IFoo.rs", "#[deprecated = \"use bar()\"]"}}, }); // but not in line comments auto parsed = Parse("IFoo.aidl", "// @deprecated\ninterface IFoo {}", typenames_, GetLanguage()); EXPECT_FALSE(parsed->IsDeprecated()); // parcelable CheckDeprecated("Foo.aidl", "parcelable Foo {\n" " /** @deprecated use bar*/\n" " int foo = 0;\n" "}", { {Options::Language::JAVA, {"out/Foo.java", "@Deprecated"}}, {Options::Language::CPP, {"out/Foo.h", "__attribute__((deprecated"}}, {Options::Language::NDK, {"out/aidl/Foo.h", "__attribute__((deprecated"}}, {Options::Language::RUST, {"out/Foo.rs", "#[deprecated"}}, }); // interface constants CheckDeprecated("IFoo.aidl", "interface IFoo {\n" " /** @deprecated use bar*/\n" " const int FOO = 0;\n" "}", { {Options::Language::JAVA, {"out/IFoo.java", "@Deprecated"}}, {Options::Language::CPP, {"out/IFoo.h", "__attribute__((deprecated"}}, {Options::Language::NDK, {"out/aidl/IFoo.h", "__attribute__((deprecated"}}, {Options::Language::RUST, {"out/IFoo.rs", "#[deprecated"}}, }); // union fields CheckDeprecated("Foo.aidl", "union Foo {\n" " int bar = 0;\n" " /** @deprecated use bar*/\n" " int foo;\n" "}", { {Options::Language::JAVA, {"out/Foo.java", "@Deprecated"}}, {Options::Language::CPP, {"out/Foo.h", "__attribute__((deprecated"}}, {Options::Language::NDK, {"out/aidl/Foo.h", "__attribute__((deprecated"}}, {Options::Language::RUST, {"out/Foo.rs", "#[deprecated"}}, }); CheckDeprecated("Foo.aidl", "/** @deprecated use Bar */\n" "parcelable Foo {}", { {Options::Language::JAVA, {"out/Foo.java", "@Deprecated"}}, {Options::Language::CPP, {"out/Foo.h", "__attribute__((deprecated"}}, {Options::Language::NDK, {"out/aidl/Foo.h", "__attribute__((deprecated"}}, {Options::Language::RUST, {"out/Foo.rs", "#[deprecated"}}, }); CheckDeprecated("Foo.aidl", "/** @deprecated use Bar */\n" "union Foo { int foo = 0; }", { {Options::Language::JAVA, {"out/Foo.java", "@Deprecated"}}, {Options::Language::CPP, {"out/Foo.h", "__attribute__((deprecated"}}, {Options::Language::NDK, {"out/aidl/Foo.h", "__attribute__((deprecated"}}, {Options::Language::RUST, {"out/Foo.rs", "#[deprecated"}}, }); CheckDeprecated("IFoo.aidl", "/** @deprecated use IBar */\n" "interface IFoo {}", { {Options::Language::JAVA, {"out/IFoo.java", "@Deprecated"}}, {Options::Language::CPP, {"out/IFoo.h", "__attribute__((deprecated"}}, {Options::Language::NDK, {"out/aidl/IFoo.h", "__attribute__((deprecated"}}, {Options::Language::RUST, {"out/IFoo.rs", "#[deprecated"}}, }); CheckDeprecated("Foo.aidl", "/** @deprecated use IBar */\n" "enum Foo { FOO }", { {Options::Language::JAVA, {"out/Foo.java", "@Deprecated"}}, {Options::Language::CPP, {"out/Foo.h", "__attribute__((deprecated"}}, {Options::Language::NDK, {"out/aidl/Foo.h", "__attribute__((deprecated"}}, {Options::Language::RUST, {"out/Foo.rs", "#[deprecated"}}, }); CheckDeprecated("Foo.aidl", "enum Foo {\n" " /** @deprecated */\n" " FOO,\n" " BAR,\n" "}", { {Options::Language::JAVA, {"out/Foo.java", "@Deprecated"}}, {Options::Language::CPP, {"out/Foo.h", "__attribute__((deprecated"}}, {Options::Language::NDK, {"out/aidl/Foo.h", "__attribute__((deprecated"}}, {Options::Language::RUST, {"out/Foo.rs", "#[deprecated"}}, }); } TEST_P(AidlTest, RequireOuterClass) { const string expected_stderr = "ERROR: p/IFoo.aidl: Couldn't find import for class Inner. Searched here:\n - ./\nERROR: " "p/IFoo.aidl:1.54-60: Failed to resolve 'Inner'\n"; io_delegate_.SetFileContents("p/Outer.aidl", "package p; parcelable Outer.Inner;"); import_paths_.emplace(""); CaptureStderr(); EXPECT_EQ(nullptr, Parse("p/IFoo.aidl", "package p; import p.Outer; interface IFoo { void f(in Inner c); }", typenames_, GetLanguage())); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_P(AidlTest, ParseCompoundParcelableFromPreprocess) { io_delegate_.SetFileContents("preprocessed", "parcelable p.Outer.Inner cpp_header \"inner.h\" ndk_header " "\"ndk/inner.h\" rust_type \"package::Inner\";"); preprocessed_files_.push_back("preprocessed"); auto parse_result = Parse("p/IFoo.aidl", "package p; interface IFoo { void f(in Inner c); }", typenames_, GetLanguage()); // Require legacy behavior - inner class name can be used without outer class name. EXPECT_NE(nullptr, parse_result); } TEST_F(AidlTest, ApiMappingAcceptsUnstructuredParcelables) { io_delegate_.SetFileContents("p/Foo.aidl", "package p; parcelable Foo;"); Options options1 = Options::From("aidl -I . --apimapping mapping.txt p/Foo.aidl"); CaptureStderr(); EXPECT_EQ(0, aidl_entry(options1, io_delegate_)); EXPECT_EQ("", GetCapturedStderr()); } TEST_F(AidlTest, FailOnParcelable) { const string expected_foo_stderr = "ERROR: p/IFoo.aidl:1.22-27: Refusing to generate code with unstructured parcelables. " "Declared parcelables should be in their own file and/or cannot be used with --structured " "interfaces.\n"; io_delegate_.SetFileContents("p/IFoo.aidl", "package p; parcelable IFoo;"); // By default, we shouldn't fail on parcelable. Options options1 = Options::From("aidl -I . p/IFoo.aidl"); CaptureStderr(); EXPECT_TRUE(compile_aidl(options1, io_delegate_)); EXPECT_EQ("", GetCapturedStderr()); // -b considers this an error Options options2 = Options::From("aidl -I . -b p/IFoo.aidl"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options2, io_delegate_)); EXPECT_EQ(expected_foo_stderr, GetCapturedStderr()); const string expected_bar_stderr = "ERROR: p/IBar.aidl:1.22-26: Refusing to generate code with unstructured parcelables. " "Declared parcelables should be in their own file and/or cannot be used with --structured " "interfaces.\n"; io_delegate_.SetFileContents("p/IBar.aidl", "package p; parcelable Foo; interface IBar{}"); // With '-b' option, a parcelable and an interface should fail. Options options3 = Options::From("aidl -I . p/IBar.aidl"); CaptureStderr(); EXPECT_TRUE(compile_aidl(options3, io_delegate_)); EXPECT_EQ("", GetCapturedStderr()); Options options4 = Options::From("aidl -I . -b p/IBar.aidl"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options4, io_delegate_)); EXPECT_EQ(expected_bar_stderr, GetCapturedStderr()); } TEST_P(AidlTest, ImportingJavaStyleBuiltinTypesIsAllowed) { string contents = R"( import android.os.IBinder; import android.os.IInterface; interface IFoo { void foo(in IBinder b); } )"; EXPECT_NE(nullptr, Parse("IFoo.aidl", contents, typenames_, GetLanguage())); } TEST_P(AidlTest, StructuredFailOnUnstructuredParcelable) { const string expected_stderr = "o.WhoKnowsWhat is not structured, but this is a structured interface"; io_delegate_.SetFileContents("o/WhoKnowsWhat.aidl", "package o; parcelable WhoKnowsWhat cpp_header \"who_knows.h\" " "ndk_header \"ndk/who_knows.h\" rust_type \"WhoKnows\";"); import_paths_.emplace(""); AidlError error; CaptureStderr(); EXPECT_EQ( nullptr, Parse("p/IFoo.aidl", "package p; import o.WhoKnowsWhat; interface IFoo { void f(in WhoKnowsWhat thisIs); }", typenames_, GetLanguage(), &error, {"--structured"})); EXPECT_THAT(GetCapturedStderr(), HasSubstr(expected_stderr)); EXPECT_EQ(AidlError::NOT_STRUCTURED, error); } TEST_P(AidlTest, FailOnDuplicateConstantNames) { AidlError error; const string expected_stderr = "ERROR: p/IFoo.aidl:4.34-45: Found duplicate constant name 'DUPLICATED'\n"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("p/IFoo.aidl", R"(package p; interface IFoo { const String DUPLICATED = "d"; const int DUPLICATED = 1; } )", typenames_, GetLanguage(), &error)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); EXPECT_EQ(AidlError::BAD_TYPE, error); } TEST_P(AidlTest, FailOnDoubleUnderscore) { AidlError error; const string expected_stderr = "ERROR: p/IFoo.aidl:3.52-57: Could not parse integer: 1__0\n"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("p/IFoo.aidl", R"(package p; interface IFoo { const int UNDERSCORE_USER = 1__0; } )", typenames_, GetLanguage(), &error)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); EXPECT_EQ(AidlError::PARSE_ERROR, error); } TEST_P(AidlTest, FailOnUnderscoreBeforeModifier) { AidlError error; const string expected_stderr = "ERROR: p/IFoo.aidl:3.52-59: Could not parse hexvalue: 0xFF_L\n"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("p/IFoo.aidl", R"(package p; interface IFoo { const int UNDERSCORE_USER = 0xFF_L; } )", typenames_, GetLanguage(), &error)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); EXPECT_EQ(AidlError::PARSE_ERROR, error); } TEST_P(AidlTest, FailOnEndingUnderscore) { AidlError error; const string expected_stderr = "ERROR: p/IFoo.aidl:3.52-56: Could not parse integer: 10_\n"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("p/IFoo.aidl", R"(package p; interface IFoo { const int UNDERSCORE_USER = 10_; } )", typenames_, GetLanguage(), &error)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); EXPECT_EQ(AidlError::PARSE_ERROR, error); } TEST_P(AidlTest, FailOnLeadingUnderscore) { AidlError error; const string expected_stderr = "ERROR: p/IFoo.aidl:3.52-56: Can't find _10 in IFoo\nERROR: p/IFoo.aidl:3.52-56: Unknown " "reference '_10'\n"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("p/IFoo.aidl", R"(package p; interface IFoo { const int UNDERSCORE_USER = _10; } )", typenames_, GetLanguage(), &error)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); EXPECT_EQ(AidlError::BAD_TYPE, error); } TEST_P(AidlTest, InvalidConstString) { AidlError error; const string expected_stderr = "ERROR: p/IFoo.aidl:3.47-60: Found invalid character '\\' at index 4 in string constant " "'\"test\\\"test\"'\n"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("p/IFoo.aidl", R"(package p; interface IFoo { const String someVar = "test\"test"; } )", typenames_, GetLanguage(), &error)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); EXPECT_EQ(AidlError::BAD_TYPE, error); } TEST_F(AidlTest, InvalidCharLiteral) { auto filename = "Foo.aidl"; char code[] = "parcelable Foo { char a = '\0'; char b = '\t'; }"; io_delegate_.SetFileContents(filename, string{code, sizeof(code) - 1}); // -1 to drop nil at the end CaptureStderr(); EXPECT_TRUE(Parser::Parse(filename, io_delegate_, typenames_, /*is_preprocessed=*/false)); auto err = GetCapturedStderr(); EXPECT_THAT(err, HasSubstr("Invalid character literal \\0")); EXPECT_THAT(err, HasSubstr("Invalid character literal \\t")); } TEST_P(AidlTest, RejectUnstructuredParcelablesInNDKandRust) { io_delegate_.SetFileContents("o/Foo.aidl", "package o; parcelable Foo cpp_header \"cpp/Foo.h\";"); const auto options = Options::From("aidl --lang=" + to_string(GetLanguage()) + " -o out -h out -I. o/Foo.aidl"); const bool reject_unstructured_parcelables = GetLanguage() == Options::Language::NDK || GetLanguage() == Options::Language::RUST; const string expected_err = reject_unstructured_parcelables ? "Refusing to generate code with unstructured parcelables" : ""; CaptureStderr(); EXPECT_EQ(compile_aidl(options, io_delegate_), !reject_unstructured_parcelables); EXPECT_THAT(GetCapturedStderr(), HasSubstr(expected_err)); } TEST_F(AidlTest, CosntantValueType) { unique_ptr num{AidlConstantValue::Integral(AIDL_LOCATION_HERE, "1")}; EXPECT_EQ(num->GetType(), AidlConstantValue::Type::INT8); } TEST_P(AidlTest, FailOnTooBigConstant) { AidlError error; const string expected_stderr = "ERROR: p/IFoo.aidl:3.48-52: Invalid type specifier for an int32 literal: byte (256).\n"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("p/IFoo.aidl", R"(package p; interface IFoo { const byte type2small = 256; } )", typenames_, GetLanguage(), &error)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); EXPECT_EQ(AidlError::BAD_TYPE, error); } TEST_F(AidlTest, BoolConstantsEvaluatesToIntegers) { io_delegate_.SetFileContents("a/Foo.aidl", "package a; parcelable Foo { const int y = true; }"); CaptureStderr(); auto options = Options::From("aidl -I . --lang java -o out a/Foo.aidl"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); EXPECT_EQ("", GetCapturedStderr()); string code; EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/Foo.java", &code)); EXPECT_THAT(code, testing::HasSubstr("public static final int y = 1;")); } TEST_F(AidlTest, AidlConstantValue_EvaluatedValue) { using Ptr = unique_ptr; const AidlLocation& loc = AIDL_LOCATION_HERE; EXPECT_EQ('c', Ptr(AidlConstantValue::Character(loc, "'c'"))->EvaluatedValue()); EXPECT_EQ("abc", Ptr(AidlConstantValue::String(loc, "\"abc\""))->EvaluatedValue()); EXPECT_FLOAT_EQ(1.0f, Ptr(AidlConstantValue::Floating(loc, "1.0f"))->EvaluatedValue()); EXPECT_EQ(true, Ptr(AidlConstantValue::Boolean(loc, true))->EvaluatedValue()); AidlBinaryConstExpression one_plus_one(loc, Ptr(AidlConstantValue::Integral(loc, "1")), "+", Ptr(AidlConstantValue::Integral(loc, "1"))); EXPECT_EQ(2, one_plus_one.EvaluatedValue()); auto values = unique_ptr>{new vector}; values->emplace_back(AidlConstantValue::String(loc, "\"hello\"")); values->emplace_back(AidlConstantValue::String(loc, "\"world\"")); vector expected{"hello", "world"}; EXPECT_EQ( expected, Ptr(AidlConstantValue::Array(loc, std::move(values)))->EvaluatedValue>()); // evaluate array of floating vector testFloats({32.f, 14.f, 50.f}); auto testFloatValues = unique_ptr>{new vector()}; testFloatValues->emplace_back(AidlConstantValue::Floating(loc, "32.f")); testFloatValues->emplace_back(AidlConstantValue::Floating(loc, "14.f")); testFloatValues->emplace_back(AidlConstantValue::Floating(loc, "50.f")); EXPECT_EQ(testFloats, Ptr(AidlConstantValue::Array(loc, std::move(testFloatValues))) ->EvaluatedValue>()); } // TODO: b/313951203 add floating/string operands test TEST_F(AidlTest, AidlBinaryConstExpression_CompatibleTypes) { const AidlLocation& loc = AIDL_LOCATION_HERE; static const std::unordered_map> compatibleTypesMap({{AidlConstantValue::Type::BOOLEAN, {AidlConstantValue::Type::BOOLEAN, AidlConstantValue::Type::INT8, AidlConstantValue::Type::INT32, AidlConstantValue::Type::INT64}}, {AidlConstantValue::Type::INT8, {AidlConstantValue::Type::BOOLEAN, AidlConstantValue::Type::INT8, AidlConstantValue::Type::INT32, AidlConstantValue::Type::INT64}}, {AidlConstantValue::Type::INT32, {AidlConstantValue::Type::BOOLEAN, AidlConstantValue::Type::INT8, AidlConstantValue::Type::INT32, AidlConstantValue::Type::INT64}}, {AidlConstantValue::Type::INT64, {AidlConstantValue::Type::BOOLEAN, AidlConstantValue::Type::INT8, AidlConstantValue::Type::INT32, AidlConstantValue::Type::INT64}}, {AidlConstantValue::Type::ARRAY, {AidlConstantValue::Type::ARRAY}}, {AidlConstantValue::Type::STRING, {AidlConstantValue::Type::STRING}}}); // go over all possible combination for (int l = 0; l <= (int)AidlConstantValue::Type::ERROR; ++l) { for (int r = 0; r <= (int)AidlConstantValue::Type::ERROR; ++r) { const AidlConstantValue::Type lType = static_cast(l), rType = static_cast(r); const auto typeItor = compatibleTypesMap.find(lType); const bool isCompatibleOperandType = typeItor != compatibleTypesMap.end() && typeItor->second.find(rType) != typeItor->second.end(); const bool isCompatibleArrayType = isCompatibleOperandType || (lType == AidlConstantValue::Type::FLOATING && rType == AidlConstantValue::Type::FLOATING); EXPECT_EQ(isCompatibleOperandType, AidlBinaryConstExpression::AreCompatibleOperandTypes(lType, rType)) << AidlConstantValue::ToString(lType) << ", " << AidlConstantValue::ToString(rType); EXPECT_EQ(isCompatibleArrayType, AidlBinaryConstExpression::AreCompatibleArrayTypes(lType, rType)) << AidlConstantValue::ToString(lType) << ", " << AidlConstantValue::ToString(rType); } } } TEST_F(AidlTest, AidlConstantCharacterDefault) { auto char_type = typenames_.MakeResolvedType(AIDL_LOCATION_HERE, "char", false); auto default_value = unique_ptr(AidlConstantValue::Default(*char_type)); EXPECT_EQ("'\\0'", default_value->ValueString(*char_type, cpp::ConstantValueDecorator)); EXPECT_EQ("'\\0'", default_value->ValueString(*char_type, ndk::ConstantValueDecorator)); EXPECT_EQ("'\\0'", default_value->ValueString(*char_type, java::ConstantValueDecorator)); } TEST_P(AidlTest, FailOnManyDefinedTypes) { AidlError error; const string expected_stderr = "ERROR: p/IFoo.aidl:3.33-38: You must declare only one type per file.\n"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("p/IFoo.aidl", R"(package p; interface IFoo {} parcelable IBar {} parcelable StructuredParcelable {} interface IBaz {} )", typenames_, GetLanguage(), &error)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); // Parse success is important for clear error handling even if the cases aren't // actually supported in code generation. EXPECT_EQ(AidlError::BAD_TYPE, error); } TEST_P(AidlTest, FailOnNoDefinedTypes) { AidlError error; const string expected_stderr = "ERROR: p/IFoo.aidl:1.11-11: syntax error, unexpected $end\n"; const string expected_stderr_newbison = "ERROR: p/IFoo.aidl:1.11-11: syntax error, unexpected end of file\n"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("p/IFoo.aidl", R"(package p;)", typenames_, GetLanguage(), &error)); EXPECT_THAT(GetCapturedStderr(), testing::AnyOf(testing::Eq(expected_stderr), testing::Eq(expected_stderr_newbison))); EXPECT_EQ(AidlError::PARSE_ERROR, error); } TEST_P(AidlTest, FailOnEmptyListWithComma) { AidlError error; const string expected_stderr = "ERROR: p/Foo.aidl:1.45-47: syntax error, unexpected ',', expecting '}'\n"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("p/Foo.aidl", R"(package p; parcelable Foo { uint64_t[] a = { , }; })", typenames_, GetLanguage(), &error)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); EXPECT_EQ(AidlError::PARSE_ERROR, error); } TEST_P(AidlTest, FailOnMalformedConstHexValue) { AidlError error; const string expected_stderr = "ERROR: p/IFoo.aidl:3.50-71: Could not parse hexvalue: 0xffffffffffffffffff\n"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("p/IFoo.aidl", R"(package p; interface IFoo { const int BAD_HEX_VALUE = 0xffffffffffffffffff; } )", typenames_, GetLanguage(), &error)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); EXPECT_EQ(AidlError::PARSE_ERROR, error); } TEST_P(AidlTest, FailOnMalformedQualifiedNameAsIdentifier) { AidlError error; const string expected_stderr = "ERROR: p/IFoo.aidl:1.25-26: syntax error, unexpected ';', expecting identifier"; CaptureStderr(); // Notice the trailing dot(.) in the name, which isn't a correct name EXPECT_EQ(nullptr, Parse("p/IFoo.aidl", R"(package p; parcelable A.; )", typenames_, GetLanguage(), &error)); EXPECT_THAT(GetCapturedStderr(), HasSubstr(expected_stderr)); EXPECT_EQ(AidlError::PARSE_ERROR, error); } TEST_P(AidlTest, FailOnAssigningByteSizeIntToByteWithHelp) { EvaluateInvalidAssignment( R"(package a; interface IFoo { const byte INT_VALUE = 0xFF; })", "Invalid type specifier for an int32 literal: byte (0xFF). Did you mean: 0xFFu8?", typenames_, GetLanguage()); } TEST_P(AidlTest, FailOnAssigningDoubleInFloatConst) { EvaluateInvalidAssignment(R"(package a; interface IFoo { const float DOUBLE_VALUE = 1.1; })", INVALID_FLOAT_VALUE, typenames_, GetLanguage()); } TEST_P(AidlTest, FailOnAssigningFloatInDoubleConst) { EvaluateValidAssignment(R"(package a; interface IFoo { const double FLOAT_VALUE = 1.1f; })", "", typenames_, GetLanguage()); } TEST_P(AidlTest, FailOnAssigningIntInFloatConst) { EvaluateInvalidAssignment(R"(package a; interface IFoo { const float INT_VALUE = 1; })", INVALID_INT8_VALUE, typenames_, GetLanguage()); } TEST_P(AidlTest, FailOnAssigningFloatInIntConst) { EvaluateInvalidAssignment(R"(package a; interface IFoo { const int FLOAT_VALUE = 1.1f; })", INVALID_FLOAT_VALUE, typenames_, GetLanguage()); } TEST_P(AidlTest, FailOnAssigningIntInDoubleConst) { EvaluateInvalidAssignment(R"(package a; interface IFoo { const double INT_VALUE = 1; })", INVALID_INT8_VALUE, typenames_, GetLanguage()); } TEST_P(AidlTest, FailOnAssigningDoubleInIntConst) { EvaluateInvalidAssignment(R"(package a; interface IFoo { const int DOUBLE_VALUE = 1.1; })", INVALID_FLOAT_VALUE, typenames_, GetLanguage()); } TEST_P(AidlTest, FailOnAssigningFloatPlusIntConst) { EvaluateInvalidAssignment(R"(package a; interface IFoo { const float FLOAT_VALUE = 1.1f + 1; })", INVALID_OPERATION, typenames_, GetLanguage()); } TEST_P(AidlTest, FailOnAssigningIntPlusFloatConst) { EvaluateInvalidAssignment(R"(package a; interface IFoo { const float FLOAT_VALUE = 1 + 1.1f; })", INVALID_OPERATION, typenames_, GetLanguage()); } TEST_P(AidlTest, FailOnAssigningDoublePlusIntConst) { EvaluateInvalidAssignment(R"(package a; interface IFoo { const double DOUBLE_VALUE = 1.1 + 1; })", INVALID_OPERATION, typenames_, GetLanguage()); } TEST_P(AidlTest, FailOnAssigningIntPlusDoubleConst) { EvaluateInvalidAssignment(R"(package a; interface IFoo { const double DOUBLE_VALUE = 1 + 1.1; })", INVALID_OPERATION, typenames_, GetLanguage()); } TEST_P(AidlTest, FailOnAssigningTooLargeFloatConst) { EvaluateInvalidAssignment(R"(package a; interface IFoo { const float DOUBLE_VALUE = 1e50f; })", INVALID_FLOAT_VALUE, typenames_, GetLanguage()); } TEST_P(AidlTest, FailOnAssigningTooLargeDoubleConst) { EvaluateInvalidAssignment(R"(package a; interface IFoo { const double DOUBLE_VALUE = 1e310; })", INVALID_FLOAT_VALUE, typenames_, GetLanguage()); } TEST_P(AidlTest, PassOnAssigningLargeFloatConst) { EvaluateValidAssignment(R"(package a; interface IFoo { const float DOUBLE_VALUE = 1e20f; })", "", typenames_, GetLanguage()); } TEST_P(AidlTest, PassOnAssigningLargeDoubleConst) { EvaluateValidAssignment(R"(package a; interface IFoo { const double DOUBLE_VALUE = 1e150; })", "", typenames_, GetLanguage()); } TEST_P(AidlTest, FailOnMalformedQualifiedNameAsPackage) { AidlError error; const string expected_stderr = "ERROR: p/IFoo.aidl:1.11-12: syntax error, unexpected ';', expecting identifier"; CaptureStderr(); // Notice the trailing dot(.) in the package name EXPECT_EQ(nullptr, Parse("p/IFoo.aidl", R"(package p.; parcelable A; )", typenames_, GetLanguage(), &error)); EXPECT_THAT(GetCapturedStderr(), HasSubstr(expected_stderr)); EXPECT_EQ(AidlError::PARSE_ERROR, error); } TEST_P(AidlTest, ParsePositiveConstHexValue) { AidlError error; auto parse_result = Parse("p/IFoo.aidl", R"(package p; interface IFoo { const int POSITIVE_HEX_VALUE = 0xf5; } )", typenames_, GetLanguage(), &error); EXPECT_NE(nullptr, parse_result); const AidlInterface* interface = parse_result->AsInterface(); ASSERT_NE(nullptr, interface); const auto& cpp_constants = interface->GetConstantDeclarations(); EXPECT_EQ((size_t)1, cpp_constants.size()); EXPECT_EQ("POSITIVE_HEX_VALUE", cpp_constants[0]->GetName()); EXPECT_TRUE(cpp_constants[0]->CheckValid(typenames_)); EXPECT_EQ("245", cpp_constants[0]->ValueString(cpp::ConstantValueDecorator)); } TEST_P(AidlTest, ParseNegativeConstHexValue) { AidlError error; auto parse_result = Parse("p/IFoo.aidl", R"(package p; interface IFoo { const int NEGATIVE_HEX_VALUE = 0xffffffff; } )", typenames_, GetLanguage(), &error); ASSERT_NE(nullptr, parse_result); const AidlInterface* interface = parse_result->AsInterface(); ASSERT_NE(nullptr, interface); const auto& cpp_constants = interface->GetConstantDeclarations(); EXPECT_EQ((size_t)1, cpp_constants.size()); EXPECT_EQ("NEGATIVE_HEX_VALUE", cpp_constants[0]->GetName()); EXPECT_EQ(true, cpp_constants[0]->CheckValid(typenames_)); EXPECT_EQ("-1", cpp_constants[0]->ValueString(cpp::ConstantValueDecorator)); } TEST_F(AidlTest, ByteAndByteArrayDifferInCpp) { auto type = Parse("p/Foo.aidl", R"( package p; parcelable Foo { byte a = -1; byte[] b = {-1, 1}; @nullable byte[] c = {-1, 1}; } )", typenames_, Options::Language::CPP); ASSERT_NE(nullptr, type); auto& fields = type->GetFields(); ASSERT_EQ(3ul, fields.size()); EXPECT_EQ("-1", fields[0]->ValueString(cpp::ConstantValueDecorator)); EXPECT_EQ("{uint8_t(-1), 1}", fields[1]->ValueString(cpp::ConstantValueDecorator)); EXPECT_EQ("{{uint8_t(-1), 1}}", fields[2]->ValueString(cpp::ConstantValueDecorator)); } TEST_F(AidlTest, ByteAndByteArrayDifferInNdk) { auto type = Parse("p/Foo.aidl", R"( package p; parcelable Foo { byte a = -1; byte[] b = {-1, 1}; @nullable byte[] c = {-1, 1}; } )", typenames_, Options::Language::NDK); ASSERT_NE(nullptr, type); auto& fields = type->GetFields(); ASSERT_EQ(3ul, fields.size()); EXPECT_EQ("-1", fields[0]->ValueString(ndk::ConstantValueDecorator)); EXPECT_EQ("{uint8_t(-1), 1}", fields[1]->ValueString(ndk::ConstantValueDecorator)); EXPECT_EQ("{{uint8_t(-1), 1}}", fields[2]->ValueString(ndk::ConstantValueDecorator)); } TEST_P(AidlTest, UnderstandsNestedUnstructuredParcelables) { io_delegate_.SetFileContents("p/Outer.aidl", "package p; parcelable Outer.Inner cpp_header \"baz/header\" " "ndk_header \"ndk/baz/header\" rust_type \"baz::Inner\";"); import_paths_.emplace(""); const string input_path = "p/IFoo.aidl"; const string input = "package p; import p.Outer; interface IFoo" " { Outer.Inner get(); }"; auto parse_result = Parse(input_path, input, typenames_, GetLanguage()); EXPECT_NE(nullptr, parse_result); EXPECT_TRUE(typenames_.ResolveTypename("p.Outer.Inner").is_resolved); // C++ uses "::" instead of "." to refer to a inner class. AidlTypeSpecifier nested_type(AIDL_LOCATION_HERE, "p.Outer.Inner", /*array=*/std::nullopt, nullptr, {}); EXPECT_EQ("::p::Outer::Inner", cpp::CppNameOf(nested_type, typenames_)); } TEST_P(AidlTest, UnderstandsNestedUnstructuredParcelablesWithoutImports) { io_delegate_.SetFileContents("p/Outer.aidl", "package p; parcelable Outer.Inner cpp_header \"baz/header\" " "ndk_header \"ndk/baz/header\" rust_type \"baz::Inner\";"); import_paths_.emplace(""); const string input_path = "p/IFoo.aidl"; const string input = "package p; interface IFoo { p.Outer.Inner get(); }"; auto parse_result = Parse(input_path, input, typenames_, GetLanguage()); EXPECT_NE(nullptr, parse_result); EXPECT_TRUE(typenames_.ResolveTypename("p.Outer.Inner").is_resolved); // C++ uses "::" instead of "." to refer to a inner class. AidlTypeSpecifier nested_type(AIDL_LOCATION_HERE, "p.Outer.Inner", /*array=*/std::nullopt, nullptr, {}); EXPECT_EQ("::p::Outer::Inner", cpp::CppNameOf(nested_type, typenames_)); } TEST_F(AidlTest, UnderstandsNestedTypes) { io_delegate_.SetFileContents("p/IOuter.aidl", "package p;\n" "interface IOuter {\n" " parcelable Inner {}\n" "}"); import_paths_.emplace(""); const string input_path = "p/IFoo.aidl"; const string input = "package p;\n" "import p.IOuter;\n" "interface IFoo {\n" " IOuter.Inner get();\n" "}"; CaptureStderr(); EXPECT_NE(nullptr, Parse(input_path, input, typenames_, Options::Language::CPP)); EXPECT_EQ(GetCapturedStderr(), ""); EXPECT_TRUE(typenames_.ResolveTypename("p.IOuter.Inner").is_resolved); // C++ uses "::" instead of "." to refer to a inner class. AidlTypeSpecifier nested_type(AIDL_LOCATION_HERE, "p.IOuter.Inner", /*array=*/std::nullopt, nullptr, {}); EXPECT_EQ("::p::IOuter::Inner", cpp::CppNameOf(nested_type, typenames_)); } TEST_F(AidlTest, DefinedTypeKnowsItsParentScope) { const string input_path = "p/IFoo.aidl"; const string input = "package p;\n" "interface IFoo {\n" " parcelable Inner {\n" " enum Enum { A }\n" " }\n" "}"; CaptureStderr(); EXPECT_NE(nullptr, Parse(input_path, input, typenames_, Options::Language::CPP)); EXPECT_EQ(GetCapturedStderr(), ""); auto enum_type = typenames_.ResolveTypename("p.IFoo.Inner.Enum"); auto inner_type = typenames_.ResolveTypename("p.IFoo.Inner"); auto ifoo_type = typenames_.ResolveTypename("p.IFoo"); EXPECT_TRUE(enum_type.is_resolved); EXPECT_TRUE(inner_type.is_resolved); EXPECT_TRUE(ifoo_type.is_resolved); // GetParentType() EXPECT_EQ(inner_type.defined_type, enum_type.defined_type->GetParentType()); EXPECT_EQ(ifoo_type.defined_type, inner_type.defined_type->GetParentType()); EXPECT_EQ(nullptr, ifoo_type.defined_type->GetParentType()); // GetRootType() EXPECT_EQ(ifoo_type.defined_type, enum_type.defined_type->GetRootType()); EXPECT_EQ(ifoo_type.defined_type, inner_type.defined_type->GetRootType()); EXPECT_EQ(ifoo_type.defined_type, ifoo_type.defined_type->GetRootType()); // GetDocument() auto main_document = &typenames_.MainDocument(); EXPECT_EQ(main_document, &enum_type.defined_type->GetDocument()); EXPECT_EQ(main_document, &inner_type.defined_type->GetDocument()); EXPECT_EQ(main_document, &ifoo_type.defined_type->GetDocument()); } TEST_F(AidlTest, UnderstandsNestedTypesViaFullyQualifiedName) { io_delegate_.SetFileContents("p/IOuter.aidl", "package p;\n" "interface IOuter {\n" " parcelable Inner {}\n" "}"); import_paths_.emplace(""); const string input_path = "p/IFoo.aidl"; const string input = "package p;\n" "interface IFoo {\n" " p.IOuter.Inner get();\n" "}"; CaptureStderr(); EXPECT_NE(nullptr, Parse(input_path, input, typenames_, Options::Language::CPP)); EXPECT_EQ(GetCapturedStderr(), ""); EXPECT_TRUE(typenames_.ResolveTypename("p.IOuter.Inner").is_resolved); } TEST_F(AidlTest, IncludeParentsRawHeaderForNestedInterface) { CaptureStderr(); EXPECT_NE(nullptr, Parse("p/Outer.aidl", "package p;\n" "parcelable Outer {\n" " interface IInner {}\n" "}", typenames_, Options::Language::CPP)); EXPECT_EQ(GetCapturedStderr(), ""); auto resolved = typenames_.ResolveTypename("p.Outer.IInner"); ASSERT_TRUE(resolved.defined_type); EXPECT_EQ(cpp::HeaderFile(*resolved.defined_type, cpp::ClassNames::CLIENT), "p/Outer.h"); } TEST_F(AidlTest, UnderstandsNestedTypesViaFullyQualifiedImport) { io_delegate_.SetFileContents("p/IOuter.aidl", "package p;\n" "interface IOuter {\n" " parcelable Inner {}\n" "}"); import_paths_.emplace(""); const string input_path = "p/IFoo.aidl"; const string input = "package p;\n" "import p.IOuter.Inner;" "interface IFoo {\n" " Inner get();\n" "}"; CaptureStderr(); EXPECT_NE(nullptr, Parse(input_path, input, typenames_, Options::Language::CPP)); EXPECT_EQ(GetCapturedStderr(), ""); EXPECT_TRUE(typenames_.ResolveTypename("p.IOuter.Inner").is_resolved); } TEST_F(AidlTest, UnderstandsNestedTypesInTheSameScope) { const string input_path = "p/IFoo.aidl"; const string input = "package p;\n" "interface IFoo {\n" " parcelable Result {}\n" " Result get();\n" "}"; CaptureStderr(); EXPECT_NE(nullptr, Parse(input_path, input, typenames_, Options::Language::CPP)); EXPECT_EQ(GetCapturedStderr(), ""); EXPECT_TRUE(typenames_.ResolveTypename("p.IFoo.Result").is_resolved); } // Finding the type of nested named member. struct TypeFinder : AidlVisitor { string name; const AidlTypeSpecifier* type = nullptr; TypeFinder(std::string name) : name(name) {} void Visit(const AidlVariableDeclaration& v) override { if (v.GetName() == name) { type = &v.GetType(); } } void Visit(const AidlMethod& m) override { if (m.GetName() == name) { type = &m.GetType(); } } static string Get(const AidlDefinedType& type, const string& name) { TypeFinder v(name); VisitTopDown(v, type); return v.type ? v.type->Signature() : "(null)"; }; }; TEST_F(AidlTest, UnderstandsNestedTypesViaQualifiedInTheSameScope) { io_delegate_.SetFileContents("q/IBar.aidl", "package q;\n" "interface IBar {\n" " parcelable Baz {}\n" "}"); import_paths_.emplace(""); const string input_path = "p/IFoo.aidl"; const string input = "package p;\n" "import q.IBar;\n" "interface IFoo {\n" " parcelable Nested {\n" " Baz t1;\n" " }\n" " parcelable Baz { }\n" " IBar.Baz t2();\n" " Baz t3();\n" "}"; CaptureStderr(); auto foo = Parse(input_path, input, typenames_, Options::Language::CPP); EXPECT_EQ(GetCapturedStderr(), ""); ASSERT_NE(nullptr, foo); EXPECT_EQ(TypeFinder::Get(*foo, "t1"), "p.IFoo.Baz"); EXPECT_EQ(TypeFinder::Get(*foo, "t2"), "q.IBar.Baz"); EXPECT_EQ(TypeFinder::Get(*foo, "t3"), "p.IFoo.Baz"); } TEST_F(AidlTest, NestedTypeResolutionWithNoPackage) { const string input_path = "Foo.aidl"; const string input = "parcelable Foo {\n" " parcelable Bar {\n" " enum Baz { BAZ }\n" " Baz baz = Baz.BAZ;\n" " }\n" " Bar bar;\n" "}"; CaptureStderr(); auto foo = Parse(input_path, input, typenames_, Options::Language::CPP); EXPECT_EQ(GetCapturedStderr(), ""); ASSERT_NE(nullptr, foo); EXPECT_EQ(TypeFinder::Get(*foo, "bar"), "Foo.Bar"); EXPECT_EQ(TypeFinder::Get(*foo, "baz"), "Foo.Bar.Baz"); } TEST_F(AidlTest, RejectsNestedTypesWithParentsName) { const string input_path = "p/Foo.aidl"; const string input = "package p;\n" "parcelable Foo {\n" " parcelable Foo {}\n" "}"; CaptureStderr(); EXPECT_EQ(nullptr, Parse(input_path, input, typenames_, Options::Language::CPP)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("Nested type 'Foo' has the same name as its parent.")); } TEST_F(AidlTest, RejectUnstructuredParcelableAsNestedTypes) { const string input_path = "p/IFoo.aidl"; const string input = "package p;\n" "interface IFoo {\n" " parcelable Bar cpp_header \"Bar.h\";\n" "}"; CaptureStderr(); EXPECT_EQ(nullptr, Parse(input_path, input, typenames_, Options::Language::CPP)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("Unstructured parcelables should be at the root scope")); } TEST_F(AidlTest, RejectGenericTypeWithNestedTypes) { const string input_path = "p/Foo.aidl"; const string input = "package p;\n" "parcelable Foo {\n" " parcelable Bar {}\n" "}"; CaptureStderr(); EXPECT_EQ(nullptr, Parse(input_path, input, typenames_, Options::Language::CPP)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("Generic types can't have nested types.")); } TEST_F(AidlTest, HandleSyntaxErrorsInNestedDecl) { const string input_path = "p/IFoo.aidl"; const string input = "package p;\n" "interface IFoo {\n" " parcelable;\n" // missing identifier "}"; CaptureStderr(); EXPECT_EQ(nullptr, Parse(input_path, input, typenames_, Options::Language::CPP)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("expecting identifier")); } TEST_F(AidlTest, RejectsNestedTypesWithDuplicateNames) { const string input_path = "p/Foo.aidl"; const string input = "package p;\n" "interface Foo {\n" " parcelable Bar {}\n" " parcelable Bar {}\n" "}"; CaptureStderr(); EXPECT_EQ(nullptr, Parse(input_path, input, typenames_, Options::Language::CPP)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("Redefinition of 'Bar'")); } TEST_F(AidlTest, TypeResolutionWithMultipleLevelsOfNesting) { struct Failure { string err; }; struct TestCase { string type; variant expected; // success<0> or failure<1> }; vector cases = { {"foo.A", "foo.A"}, {"foo.A.B", "foo.A.B"}, {"@nullable(heap=true) A", "foo.A.B.A"}, // In the scope of foo.A.B.A, B is resolved to A.B.A.B first. {"B.A", Failure{"Failed to resolve 'B.A'"}}, {"B", "foo.A.B.A.B"}, {"A.B", "foo.A.B.A.B"}, }; const string input_path = "foo/A.aidl"; for (auto& [type, expected] : cases) { AidlTypenames typenames; // clang-format off const string input = "package foo;\n" "parcelable A {\n" " parcelable B {\n" " parcelable A {\n" " parcelable B {\n" " }\n" " " + type + " m;\n" " }\n" " }\n" "}"; // clang-format on CaptureStderr(); auto foo = Parse(input_path, input, typenames, Options::Language::CPP); if (auto failure = std::get_if(&expected); failure) { ASSERT_EQ(nullptr, foo); EXPECT_THAT(GetCapturedStderr(), HasSubstr(failure->err)); } else { EXPECT_EQ(GetCapturedStderr(), ""); ASSERT_NE(nullptr, foo); EXPECT_EQ(TypeFinder::Get(*foo, "m"), std::get(expected)); } } } TEST_F(AidlTest, HeaderForNestedTypeShouldPointToTopMostParent) { const string input_path = "p/IFoo.aidl"; const string input = "package p;\n" "interface IFoo {\n" " parcelable Result {}\n" "}"; CaptureStderr(); auto foo = Parse(input_path, input, typenames_, Options::Language::CPP); ASSERT_NE(nullptr, foo); EXPECT_EQ(GetCapturedStderr(), ""); auto result = typenames_.ResolveTypename("p.IFoo.Result").defined_type; ASSERT_NE(nullptr, result); EXPECT_EQ("p/IFoo.h", cpp::CppHeaderForType(*result)); } TEST_F(AidlTest, ReorderNestedTypesForCppOutput) { const string input_path = "p/IFoo.aidl"; const string input = R"( package p; interface IFoo { // partial orderings for [A, D, G]: // D - A // A - G parcelable A { // partial orderings for [B, C]: // C - B parcelable B { C c; D.E d; } parcelable C {} } parcelable D { // partial orderings for [E, F]: // F - E parcelable E { F f; } parcelable F {} } parcelable G { A.B b; } } )"; Options options = Options::From("aidl --lang cpp -I. -oout -hout p/IFoo.aidl"); io_delegate_.SetFileContents(input_path, input); CaptureStderr(); EXPECT_TRUE(compile_aidl(options, io_delegate_)); EXPECT_EQ(GetCapturedStderr(), ""); string code; EXPECT_TRUE(io_delegate_.GetWrittenContents("out/p/IFoo.h", &code)); // check partial orderings: a should comes before b EXPECT_LE(code.find("class D"), code.find("class A")); EXPECT_LE(code.find("class A"), code.find("class G")); EXPECT_LE(code.find("class C"), code.find("class B")); EXPECT_LE(code.find("class F"), code.find("class E")); } TEST_F(AidlTest, RejectsNestedTypesWithCyclicDeps) { const string input_path = "p/IFoo.aidl"; const string input = R"( package p; interface IFoo { // Cycles: // D - A // A - G // G - D parcelable A { parcelable B { C c; } } parcelable C { parcelable D { E e; } } parcelable E { parcelable F { A a; } } } )"; Options options = Options::From("aidl --lang cpp -I. -oout -hout p/IFoo.aidl"); io_delegate_.SetFileContents(input_path, input); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("IFoo has nested types with cyclic references.")); } TEST_F(AidlTest, RejectsCyclicNestedInterfaces) { Options options = Options::From( "aidl --lang cpp -I. -oout -hout " "p/IFoo.aidl p/IBar.aidl p/IQux.aidl"); io_delegate_.SetFileContents("p/IFoo.aidl", "package p; import p.IBar; " "interface IFoo { IBar getBar(); }"); io_delegate_.SetFileContents("p/IBar.aidl", "package p; import p.IQux; " "interface IBar { IQux.Inner getQux(); }"); io_delegate_.SetFileContents("p/IQux.aidl", "package p; import p.IFoo; " "interface IQux { interface Inner { IFoo getFoo(); } }"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("ERROR: p/IQux.aidl:1.43-53: has cyclic references to nested types.")); } TEST_F(AidlTest, RejectsCyclicNestedInterfacesAndParcelables) { Options options = Options::From( "aidl --lang cpp -I. -oout -hout " "p/IFoo.aidl p/Bar.aidl"); io_delegate_.SetFileContents("p/IFoo.aidl", "package p; import p.Bar; " "interface IFoo { interface Inner { Bar getBar(); } }"); io_delegate_.SetFileContents("p/Bar.aidl", "package p; import p.IFoo; " "parcelable Bar { IFoo.Inner foo; }"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("ERROR: p/IFoo.aidl:1.42-52: has cyclic references to nested types.")); } TEST_F(AidlTest, CppNameOf_GenericType) { const string input_path = "p/Wrapper.aidl"; const string input = "package p; parcelable Wrapper {}"; auto parse_result = Parse(input_path, input, typenames_, Options::Language::CPP); EXPECT_NE(nullptr, parse_result); auto type = [](std::string name, auto&&... type_params) -> std::unique_ptr { auto params = new std::vector>; (..., params->emplace_back(std::move(type_params))); return std::make_unique(AIDL_LOCATION_HERE, name, std::nullopt, params, Comments{}); }; auto set_nullable = [](std::unique_ptr&& type) { std::vector> annotations; annotations.emplace_back(std::unique_ptr( AidlAnnotation::Parse(AIDL_LOCATION_HERE, "nullable", {}, {}))); type->Annotate(std::move(annotations)); return std::move(type); }; auto set_array = [](std::unique_ptr&& type) { (void)type->MakeArray(DynamicArray{}); return std::move(type); }; auto w = type("p.Wrapper", type("String")); EXPECT_EQ("::p::Wrapper<::android::String16>", cpp::CppNameOf(*w, typenames_)); auto nullable_w = set_nullable(type("p.Wrapper", type("String"))); EXPECT_EQ("::std::optional<::p::Wrapper<::android::String16>>", cpp::CppNameOf(*nullable_w, typenames_)); auto array_w = set_array(type("p.Wrapper", type("String"))); EXPECT_EQ("::std::vector<::p::Wrapper<::android::String16>>", cpp::CppNameOf(*array_w, typenames_)); auto nullable_array_w = set_nullable(set_array(type("p.Wrapper", type("String")))); EXPECT_EQ("::std::optional<::std::vector<::std::optional<::p::Wrapper<::android::String16>>>>", cpp::CppNameOf(*nullable_array_w, typenames_)); auto list_w = type("List", type("p.Wrapper", type("String"))); EXPECT_EQ("::std::vector<::p::Wrapper<::android::String16>>", cpp::CppNameOf(*list_w, typenames_)); auto nullable_list_w = set_nullable(type("List", type("p.Wrapper", type("String")))); EXPECT_EQ("::std::optional<::std::vector<::std::optional<::p::Wrapper<::android::String16>>>>", cpp::CppNameOf(*nullable_list_w, typenames_)); } TEST_P(AidlTest, UnderstandsNativeParcelables) { io_delegate_.SetFileContents( "p/Bar.aidl", "package p; parcelable Bar cpp_header \"baz/header\";"); import_paths_.emplace(""); const string input_path = "p/IFoo.aidl"; const string input = "package p; import p.Bar; interface IFoo { }"; auto parse_result = Parse(input_path, input, typenames_, GetLanguage()); EXPECT_NE(nullptr, parse_result); EXPECT_TRUE(typenames_.ResolveTypename("p.Bar").is_resolved); AidlTypeSpecifier native_type(AIDL_LOCATION_HERE, "p.Bar", /*array=*/std::nullopt, nullptr, {}); native_type.Resolve(typenames_, parse_result); EXPECT_EQ("p.Bar", java::InstantiableJavaSignatureOf(native_type)); // C++ understands C++ specific stuff EXPECT_EQ("::p::Bar", cpp::CppNameOf(native_type, typenames_)); set headers; cpp::AddHeaders(native_type, typenames_, &headers); EXPECT_EQ(1u, headers.size()); EXPECT_EQ(1u, headers.count("baz/header")); } TEST_F(AidlTest, WritesCorrectDependencyFile) { // While the in tree build system always gives us an output file name, // other android tools take advantage of our ability to infer the intended // file name. This test makes sure we handle this correctly. vector args = {"aidl", "-I .", "-d dep/file/path", "-o place/for/output", "p/IFoo.aidl"}; Options options = Options::From(args); io_delegate_.SetFileContents(options.InputFiles().front(), "package p; interface IFoo {}"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); string actual_dep_file_contents; EXPECT_TRUE(io_delegate_.GetWrittenContents(options.DependencyFile(), &actual_dep_file_contents)); EXPECT_EQ(actual_dep_file_contents, kExpectedDepFileContents); } TEST_F(AidlTest, WritesCorrectDependencyFileNinja) { // While the in tree build system always gives us an output file name, // other android tools take advantage of our ability to infer the intended // file name. This test makes sure we handle this correctly. vector args = {"aidl", "-I .", "-d dep/file/path", "--ninja", "-o place/for/output", "p/IFoo.aidl"}; Options options = Options::From(args); io_delegate_.SetFileContents(options.InputFiles().front(), "package p; interface IFoo {}"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); string actual_dep_file_contents; EXPECT_TRUE(io_delegate_.GetWrittenContents(options.DependencyFile(), &actual_dep_file_contents)); EXPECT_EQ(actual_dep_file_contents, kExpectedNinjaDepFileContents); } TEST_F(AidlTest, WritesTrivialDependencyFileForParcelableDeclaration) { // The SDK uses aidl to decide whether a .aidl file is a parcelable. It does // this by calling aidl with every .aidl file it finds, then parsing the // generated dependency files. Those that reference .java output files are // for interfaces and those that do not are parcelables. However, for both // parcelables and interfaces, we *must* generate a non-empty dependency file. vector args = {"aidl", "-I .", "-o place/for/output", "-d dep/file/path", "p/Foo.aidl"}; Options options = Options::From(args); io_delegate_.SetFileContents(options.InputFiles().front(), "package p; parcelable Foo;"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); string actual_dep_file_contents; EXPECT_TRUE(io_delegate_.GetWrittenContents(options.DependencyFile(), &actual_dep_file_contents)); EXPECT_EQ(actual_dep_file_contents, kExpectedParcelableDeclarationDepFileContents); } TEST_F(AidlTest, WritesDependencyFileForStructuredParcelable) { vector args = { "aidl", "-I .", "--structured", "-o place/for/output", "-d dep/file/path", "p/Foo.aidl"}; Options options = Options::From(args); io_delegate_.SetFileContents(options.InputFiles().front(), "package p; parcelable Foo {int a;}"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); string actual_dep_file_contents; EXPECT_TRUE(io_delegate_.GetWrittenContents(options.DependencyFile(), &actual_dep_file_contents)); EXPECT_EQ(actual_dep_file_contents, kExpectedStructuredParcelableDepFileContents); } TEST_F(AidlTest, NoJavaOutputForParcelableDeclaration) { vector args = {"aidl", "-I .", "--lang=java", "-o place/for/output", "p/Foo.aidl"}; Options options = Options::From(args); io_delegate_.SetFileContents(options.InputFiles().front(), "package p; parcelable Foo;"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); string output_file_contents; EXPECT_FALSE(io_delegate_.GetWrittenContents(options.OutputFile(), &output_file_contents)); } TEST_P(AidlTest, RejectsListArray) { const string input = "package a; parcelable Foo { List[] lists; }"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("a/Foo.aidl", input, typenames_, GetLanguage())); EXPECT_THAT(GetCapturedStderr(), HasSubstr("Arrays of List are not supported")); } TEST_P(AidlTest, RejectsPrimitiveListInStableAidl) { AidlError error; string expected_stderr = "ERROR: a/IFoo.aidl:2.7-11: " "Encountered an untyped List or Map. The use of untyped List/Map is " "prohibited because it is not guaranteed that the objects in the list are recognizable in " "the receiving side. Consider switching to an array or a generic List/Map.\n"; if (GetLanguage() != Options::Language::JAVA) { expected_stderr = "ERROR: a/IFoo.aidl:2.1-7: " "Currently, only the Java backend supports non-generic List.\n"; } const string primitive_interface = "package a; interface IFoo {\n" " List foo(); }"; CaptureStderr(); AidlTypenames tn1; EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", primitive_interface, tn1, GetLanguage(), &error, {"--structured"})); EXPECT_EQ(expected_stderr, GetCapturedStderr()); string primitive_parcelable = "package a; parcelable IFoo {\n" " List foo;}"; CaptureStderr(); AidlTypenames tn2; EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", primitive_parcelable, tn2, GetLanguage(), &error, {"--structured"})); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_P(AidlTest, ExtensionTest) { CaptureStderr(); string extendable_parcelable = "package a; parcelable Data {\n" " ParcelableHolder extension;\n" " ParcelableHolder extension2;\n" "}"; EXPECT_NE(nullptr, Parse("a/Data.aidl", extendable_parcelable, typenames_, GetLanguage())); EXPECT_EQ("", GetCapturedStderr()); } TEST_P(AidlTest, ParcelableHolderAsReturnType) { CaptureStderr(); string parcelableholder_return_interface = "package a; interface IFoo {\n" " ParcelableHolder foo();\n" "}"; EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", parcelableholder_return_interface, typenames_, GetLanguage())); EXPECT_EQ("ERROR: a/IFoo.aidl:2.19-23: ParcelableHolder cannot be a return type\n", GetCapturedStderr()); } TEST_P(AidlTest, ParcelableHolderAsArgumentType) { CaptureStderr(); string extendable_parcelable_arg_interface = "package a; interface IFoo {\n" " void foo(in ParcelableHolder ph);\n" "}"; EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", extendable_parcelable_arg_interface, typenames_, GetLanguage())); EXPECT_EQ("ERROR: a/IFoo.aidl:2.31-34: ParcelableHolder cannot be an argument type\n", GetCapturedStderr()); } TEST_P(AidlTest, RejectNullableParcelableHolderField) { io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo { @nullable ParcelableHolder ext; }"); Options options = Options::From("aidl Foo.aidl -I . --lang=" + to_string(GetLanguage())); const string expected_stderr = "ERROR: Foo.aidl:1.27-44: ParcelableHolder cannot be nullable.\n"; CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_P(AidlTest, ParcelablesWithConstants) { io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo { const int BIT = 0x1 << 3; }"); Options options = Options::From("aidl Foo.aidl -I . --lang=" + to_string(GetLanguage())); CaptureStderr(); EXPECT_TRUE(compile_aidl(options, io_delegate_)); EXPECT_EQ("", GetCapturedStderr()); } TEST_P(AidlTest, UnionWithConstants) { io_delegate_.SetFileContents("Foo.aidl", "union Foo { const int BIT = 0x1 << 3; int n; }"); Options options = Options::From("aidl Foo.aidl -I . --lang=" + to_string(GetLanguage())); CaptureStderr(); EXPECT_TRUE(compile_aidl(options, io_delegate_)); EXPECT_EQ("", GetCapturedStderr()); } TEST_F(AidlTest, ConstantsWithAnnotations) { io_delegate_.SetFileContents("IFoo.aidl", "interface IFoo {\n" " @JavaPassthrough(annotation=\"@Foo\")\n" " const @JavaPassthrough(annotation=\"@Bar\") int FOO = 0;\n" "}"); Options options = Options::From("aidl IFoo.aidl -I . --lang=java -o out"); CaptureStderr(); EXPECT_TRUE(compile_aidl(options, io_delegate_)); EXPECT_EQ("", GetCapturedStderr()); string code; EXPECT_TRUE(io_delegate_.GetWrittenContents("out/IFoo.java", &code)); EXPECT_THAT(code, HasSubstr("@Foo\n")); EXPECT_THAT(code, HasSubstr("@Bar\n")); } TEST_F(AidlTest, ApiDump) { io_delegate_.SetFileContents( "foo/bar/IFoo.aidl", "// comment\n" "package foo.bar;\n" "import foo.bar.Data;\n" "// commented /* @hide */\n" "interface IFoo {\n" " /* @hide applied \n" " @deprecated use foo2 */\n" " int foo(out int[] a, String b, boolean c, inout List d);\n" " int foo2(@utf8InCpp String x, inout List y);\n" " IFoo foo3(IFoo foo);\n" " void foo4(in int[2][3] fixedArray);\n" " Data getData();\n" " // @hide not applied\n" " /** blahblah\n" " @deprecated\n" " reason why... */\n" " const int A = 1;\n" " // @deprecated tags in line comments are ignored\n" " const String STR = \"Hello\";\n" "}\n"); io_delegate_.SetFileContents("foo/bar/Data.aidl", "// comment\n" "package foo.bar;\n" "import foo.bar.IFoo;\n" "@JavaDerive(equals=true, toString=true)\n" "/* @hide*/\n" "parcelable Data {\n" " // @hide\n" " int x = 10;\n" " // @hide\n" " int y;\n" " /*@hide2*/\n" " IFoo foo;\n" " // Ignore @hide property in line comment\n" " @nullable String[] c;\n" "}\n"); io_delegate_.SetFileContents("api.aidl", ""); vector args = {"aidl", "--dumpapi", "--out=dump", "--include=.", "foo/bar/IFoo.aidl", "foo/bar/Data.aidl"}; Options options = Options::From(args); bool result = dump_api(options, io_delegate_); ASSERT_TRUE(result); string actual; EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/IFoo.aidl", &actual)); EXPECT_EQ(string("// comment\n").append(string(kPreamble)).append(R"(package foo.bar; interface IFoo { /** * @hide * @deprecated use foo2 */ int foo(out int[] a, String b, boolean c, inout List d); int foo2(@utf8InCpp String x, inout List y); foo.bar.IFoo foo3(foo.bar.IFoo foo); void foo4(in int[2][3] fixedArray); foo.bar.Data getData(); /** * @deprecated reason why... */ const int A = 1; const String STR = "Hello"; } )"), actual); EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/Data.aidl", &actual)); EXPECT_EQ(string("// comment\n").append(string(kPreamble)).append(R"(package foo.bar; /* @hide */ @JavaDerive(equals=true, toString=true) parcelable Data { int x = 10; int y; foo.bar.IFoo foo; @nullable String[] c; } )"), actual); } TEST_F(AidlTest, ApiDumpWithManualIds) { io_delegate_.SetFileContents( "foo/bar/IFoo.aidl", "package foo.bar;\n" "interface IFoo {\n" " int foo() = 1;\n" " int bar() = 2;\n" " int baz() = 10;\n" "}\n"); vector args = {"aidl", "-I . ", "--dumpapi", "-o dump", "foo/bar/IFoo.aidl"}; Options options = Options::From(args); bool result = dump_api(options, io_delegate_); ASSERT_TRUE(result); string actual; EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/IFoo.aidl", &actual)); EXPECT_EQ(actual, string(kPreamble).append(R"(package foo.bar; interface IFoo { int foo() = 1; int bar() = 2; int baz() = 10; } )")); } TEST_F(AidlTest, ApiDumpWithManualIdsOnlyOnSomeMethods) { const string expected_stderr = "ERROR: foo/bar/IFoo.aidl:4.8-12: You must either assign id's to all methods or to none of " "them.\n"; io_delegate_.SetFileContents( "foo/bar/IFoo.aidl", "package foo.bar;\n" "interface IFoo {\n" " int foo() = 1;\n" " int bar();\n" " int baz() = 10;\n" "}\n"); vector args = {"aidl", "-I . ", "--dumpapi", "-o dump", "foo/bar/IFoo.aidl"}; Options options = Options::From(args); CaptureStderr(); EXPECT_FALSE(dump_api(options, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTest, ApiDumpConstWithAnnotation) { io_delegate_.SetFileContents("foo/bar/IFoo.aidl", "package foo.bar;\n" "interface IFoo {\n" " @utf8InCpp String foo();\n" " const @utf8InCpp String bar = \"bar\";\n" "}\n"); vector args = {"aidl", "-I . ", "--dumpapi", "-o dump", "foo/bar/IFoo.aidl"}; Options options = Options::From(args); CaptureStderr(); EXPECT_TRUE(dump_api(options, io_delegate_)); EXPECT_EQ("", GetCapturedStderr()); string actual; EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/IFoo.aidl", &actual)); EXPECT_EQ(string(kPreamble).append(R"(package foo.bar; interface IFoo { @utf8InCpp String foo(); const @utf8InCpp String bar = "bar"; } )"), actual); } TEST_F(AidlTest, ApiDumpWithEnums) { io_delegate_.SetFileContents("foo/bar/Enum.aidl", "package foo.bar;\n" "enum Enum {\n" " FOO,\n" " BAR = FOO + 1,\n" "}\n"); vector args = {"aidl", "--dumpapi", "-I . ", "-o dump", "foo/bar/Enum.aidl"}; Options options = Options::From(args); CaptureStderr(); EXPECT_TRUE(dump_api(options, io_delegate_)); EXPECT_EQ("", GetCapturedStderr()); string actual; EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/Enum.aidl", &actual)); EXPECT_EQ(string(kPreamble).append("package foo.bar;\n" "enum Enum {\n" " FOO,\n" " BAR = (FOO + 1) /* 1 */,\n" "}\n"), actual); } TEST_F(AidlTest, ApiDumpWithEnumDefaultValues) { io_delegate_.SetFileContents("foo/bar/Enum.aidl", "package foo.bar;\n" "enum Enum {\n" " FOO,\n" "}\n"); io_delegate_.SetFileContents("foo/bar/Foo.aidl", "package foo.bar;\n" "import foo.bar.Enum;\n" "parcelable Foo {\n" " Enum e = Enum.FOO;\n" " int n = Enum.FOO;\n" "}\n"); vector args = {"aidl", "--dumpapi", "-I . ", "-o dump", "foo/bar/Foo.aidl"}; Options options = Options::From(args); CaptureStderr(); EXPECT_TRUE(dump_api(options, io_delegate_)); EXPECT_EQ("", GetCapturedStderr()); string actual; EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/Foo.aidl", &actual)); EXPECT_EQ(string(kPreamble).append("package foo.bar;\n" "parcelable Foo {\n" " foo.bar.Enum e = foo.bar.Enum.FOO;\n" " int n = foo.bar.Enum.FOO /* 0 */;\n" "}\n"), actual); } TEST_F(AidlTest, ApiDumpWithGenerics) { io_delegate_.SetFileContents("foo/bar/Foo.aidl", "package foo.bar;\n" "parcelable Foo {\n" "}\n"); vector args = {"aidl", "--dumpapi", "-I . ", "-o dump", "foo/bar/Foo.aidl"}; Options options = Options::From(args); CaptureStderr(); EXPECT_TRUE(dump_api(options, io_delegate_)); EXPECT_EQ("", GetCapturedStderr()); string actual; EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/Foo.aidl", &actual)); EXPECT_EQ(string(kPreamble).append("package foo.bar;\n" "parcelable Foo {\n" "}\n"), actual); } TEST_F(AidlTest, ImportedDocumentHasDuplicateDefinitions) { io_delegate_.SetFileContents("IFoo.aidl", "interface IFoo; interface IFoo;\n"); io_delegate_.SetFileContents("Bar.aidl", "enum Bar { CONST = IFoo.NONE }\n"); vector args = {"aidl", "--dumpapi", "-I.", "-o out", "Bar.aidl"}; Options options = Options::From(args); CaptureStderr(); EXPECT_FALSE(dump_api(options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("Can't find NONE in IFoo")); } TEST_F(AidlTest, CheckNumGenericTypeSecifier) { const string expected_list_stderr = "ERROR: p/IFoo.aidl:1.37-41: List can only have one type parameter, but got: " "'List'\n"; const string expected_map_stderr = "ERROR: p/IFoo.aidl:1.37-40: Map must have 0 or 2 type parameters, but got 'Map'\n"; Options options = Options::From("aidl -I . p/IFoo.aidl IFoo.java"); io_delegate_.SetFileContents(options.InputFiles().front(), "package p; interface IFoo {" "void foo(List a);}"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_EQ(expected_list_stderr, GetCapturedStderr()); io_delegate_.SetFileContents(options.InputFiles().front(), "package p; interface IFoo {" "void foo(Map a);}"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_EQ(expected_map_stderr, GetCapturedStderr()); } TEST_F(AidlTest, CheckTypeParameterInMapType) { const string expected_stderr = "ERROR: p/IFoo.aidl:1.28-31: The type of key in map must be String, but it is 'p.Bar'\n"; Options options = Options::From("aidl -I . p/IFoo.aidl"); io_delegate_.SetFileContents("p/Bar.aidl", "package p; parcelable Bar { String s; }"); io_delegate_.SetFileContents("p/IFoo.aidl", "package p; interface IFoo {" "Map foo();}"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); io_delegate_.SetFileContents("p/IFoo.aidl", "package p; interface IFoo {" "Map foo();}"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); io_delegate_.SetFileContents("p/IFoo.aidl", "package p; interface IFoo {" "Map foo();}"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); io_delegate_.SetFileContents("p/IFoo.aidl", "package p; interface IFoo {" "Map foo();}"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); } TEST_F(AidlTest, WrongGenericType) { const string expected_stderr = "ERROR: p/IFoo.aidl:1.28-34: String is not a generic type.\n"; Options options = Options::From("aidl -I . p/IFoo.aidl IFoo.java"); io_delegate_.SetFileContents(options.InputFiles().front(), "package p; interface IFoo {" "String foo(); }"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTest, UserDefinedUnstructuredGenericParcelableType) { Options optionsForParcelable = Options::From("aidl -I . p/Bar.aidl"); io_delegate_.SetFileContents("p/Bar.aidl", "package p; parcelable Bar;"); CaptureStderr(); EXPECT_FALSE(compile_aidl(optionsForParcelable, io_delegate_)); EXPECT_EQ("ERROR: p/Bar.aidl:1.22-26: Every type parameter should be unique.\n", GetCapturedStderr()); Options options = Options::From("aidl -I . p/IFoo.aidl"); io_delegate_.SetFileContents("p/Bar.aidl", "package p; parcelable Bar;"); io_delegate_.SetFileContents("p/IFoo.aidl", "package p; interface IFoo {" "p.Bar foo();}"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("p.Bar is not a generic type")); io_delegate_.SetFileContents("p/Bar.aidl", "package p; parcelable Bar;"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("p.Bar must have 1 type parameters, but got 2")); io_delegate_.SetFileContents("p/Bar.aidl", "package p; parcelable Bar;"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); io_delegate_.SetFileContents("p/IFoo.aidl", "package p; interface IFoo {" "p.Bar foo();}"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); io_delegate_.SetFileContents("p/IFoo.aidl", "package p; interface IFoo {" "p.Bar foo();}"); io_delegate_.SetFileContents("p/IFoo.aidl", "package p; interface IFoo {" "p.Bar foo();}"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); } TEST_F(AidlTest, FailOnMultipleTypesInSingleFile) { std::vector rawOptions{"aidl --lang=java -I . -o out foo/bar/Foo.aidl", "aidl --lang=cpp -I . -o out -h out/include foo/bar/Foo.aidl", "aidl --lang=rust -I . -o out foo/bar/Foo.aidl"}; for (const auto& rawOption : rawOptions) { string expected_stderr = "ERROR: foo/bar/Foo.aidl:3.1-10: You must declare only one type per file.\n"; Options options = Options::From(rawOption); io_delegate_.SetFileContents(options.InputFiles().front(), "package foo.bar;\n" "interface IFoo1 { int foo(); }\n" "interface IFoo2 { int foo(); }\n" "parcelable Data1 { int a; int b;}\n" "parcelable Data2 { int a; int b;}\n"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); io_delegate_.SetFileContents(options.InputFiles().front(), "package foo.bar;\n" "interface IFoo1 { int foo(); }\n" "interface IFoo2 { int foo(); }\n"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); expected_stderr = "ERROR: foo/bar/Foo.aidl:3.11-17: You must declare only one type per file.\n"; io_delegate_.SetFileContents(options.InputFiles().front(), "package foo.bar;\n" "parcelable Data1 { int a; int b;}\n" "parcelable Data2 { int a; int b;}\n"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } } TEST_P(AidlTest, FailParseOnEmptyFile) { const string contents = ""; const string expected_stderr = "ERROR: a/IFoo.aidl:1.1-1: syntax error, unexpected $end\n"; const string expected_stderr_newbison = "ERROR: a/IFoo.aidl:1.1-1: syntax error, unexpected end of file\n"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", contents, typenames_, GetLanguage())); EXPECT_THAT(GetCapturedStderr(), testing::AnyOf(testing::Eq(expected_stderr), testing::Eq(expected_stderr_newbison))); } TEST_F(AidlTest, MultipleInputFiles) { Options options = Options::From( "aidl --lang=java -o out -I . foo/bar/IFoo.aidl foo/bar/Data.aidl"); io_delegate_.SetFileContents(options.InputFiles().at(0), "package foo.bar;\n" "import foo.bar.Data;\n" "interface IFoo { Data getData(); }\n"); io_delegate_.SetFileContents(options.InputFiles().at(1), "package foo.bar;\n" "import foo.bar.IFoo;\n" "parcelable Data { IFoo foo; }\n"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); string content; for (const auto file : { "out/foo/bar/IFoo.java", "out/foo/bar/Data.java"}) { content.clear(); EXPECT_TRUE(io_delegate_.GetWrittenContents(file, &content)); EXPECT_FALSE(content.empty()); } } TEST_F(AidlTest, MultipleInputFilesCpp) { Options options = Options::From( "aidl --lang=cpp -I . -o out -h out/include " "-I . foo/bar/IFoo.aidl foo/bar/Data.aidl"); io_delegate_.SetFileContents(options.InputFiles().at(0), "package foo.bar;\n" "import foo.bar.Data;\n" "interface IFoo { Data getData(); }\n"); io_delegate_.SetFileContents(options.InputFiles().at(1), "package foo.bar;\n" "import foo.bar.IFoo;\n" "parcelable Data { IFoo foo; }\n"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); string content; for (const auto file : { "out/foo/bar/IFoo.cpp", "out/foo/bar/Data.cpp", "out/include/foo/bar/IFoo.h", "out/include/foo/bar/Data.h", "out/include/foo/bar/BpFoo.h", "out/include/foo/bar/BpData.h", "out/include/foo/bar/BnFoo.h", "out/include/foo/bar/BnData.h"}) { content.clear(); EXPECT_TRUE(io_delegate_.GetWrittenContents(file, &content)); EXPECT_FALSE(content.empty()); } } TEST_F(AidlTest, MultipleInputFilesRust) { Options options = Options::From("aidl --lang=rust -o out -I . foo/bar/IFoo.aidl foo/bar/Data.aidl"); io_delegate_.SetFileContents(options.InputFiles().at(0), "package foo.bar;\n" "import foo.bar.Data;\n" "interface IFoo { Data getData(); }\n"); io_delegate_.SetFileContents(options.InputFiles().at(1), "package foo.bar;\n" "import foo.bar.IFoo;\n" "parcelable Data { IFoo foo; }\n"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); string content; for (const auto file : {"out/foo/bar/IFoo.rs", "out/foo/bar/Data.rs"}) { content.clear(); EXPECT_TRUE(io_delegate_.GetWrittenContents(file, &content)); EXPECT_FALSE(content.empty()); } } TEST_F(AidlTest, ConflictWithMetaTransactionGetVersion) { const string expected_stderr = "ERROR: p/IFoo.aidl:1.31-51: method getInterfaceVersion() is reserved for internal use.\n"; Options options = Options::From("aidl --lang=java -I . -o place/for/output p/IFoo.aidl"); // int getInterfaceVersion() is one of the meta transactions io_delegate_.SetFileContents(options.InputFiles().front(), "package p; interface IFoo {" "int getInterfaceVersion(); }"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTest, ConflictWithSimilarMetaTransaction) { // boolean getInterfaceVersion() is not a meta transaction, but should be // prevented because return type is not part of a method signature const string expected_stderr = "ERROR: p/IFoo.aidl:1.35-55: method getInterfaceVersion() is reserved for internal use.\n"; Options options = Options::From("aidl --lang=java -I . -o place/for/output p/IFoo.aidl"); io_delegate_.SetFileContents(options.InputFiles().front(), "package p; interface IFoo {" "boolean getInterfaceVersion(); }"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTest, ConflictWithMetaTransactionGetName) { // this is another reserved name const string expected_stderr = "ERROR: p/IFoo.aidl:1.34-53: method getTransactionName(int) is reserved for internal use.\n"; Options options = Options::From("aidl --lang=java -I . -o place/for/output p/IFoo.aidl"); io_delegate_.SetFileContents(options.InputFiles().front(), "package p; interface IFoo {" "String getTransactionName(int code); }"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); // this is not a meta interface method as it differs type arguments io_delegate_.SetFileContents(options.InputFiles().front(), "package p; interface IFoo {" "String getTransactionName(); }"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); } TEST_F(AidlTest, CheckApiForEquality) { CaptureStderr(); Options options = Options::From("aidl --checkapi=equal old new"); io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p; interface IFoo{ @utf8InCpp @nullable String foo();}"); io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p; interface IFoo{ @utf8InCpp String foo();}"); EXPECT_FALSE(::android::aidl::check_api(options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("+ @utf8InCpp String foo();")); } TEST_F(AidlTest, DifferentOrderAnnotationsInCheckAPI) { Options options = Options::From("aidl --checkapi old new"); io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p; interface IFoo{ @utf8InCpp @nullable String foo();}"); io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p; interface IFoo{ @nullable @utf8InCpp String foo();}"); EXPECT_TRUE(::android::aidl::check_api(options, io_delegate_)); } TEST_F(AidlTest, JavaPassthroughAnnotationAddedInCheckApi) { Options options = Options::From("aidl --checkapi old new"); io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p; interface IFoo{}"); io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p; @JavaPassthrough(annotation=\"@foo\") interface IFoo{}"); EXPECT_TRUE(::android::aidl::check_api(options, io_delegate_)); } TEST_F(AidlTest, SuccessOnIdenticalApiDumps) { Options options = Options::From("aidl --checkapi old new"); io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p; interface IFoo{ void foo();}"); io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p; interface IFoo{ void foo();}"); EXPECT_TRUE(::android::aidl::check_api(options, io_delegate_)); } TEST_F(AidlTest, CheckApi_EnumFieldsWithDefaultValues) { Options options = Options::From("aidl --checkapi old new"); const string foo_definition = "package p; parcelable Foo{ p.Enum e = p.Enum.FOO; }"; const string enum_definition = "package p; enum Enum { FOO }"; io_delegate_.SetFileContents("old/p/Foo.aidl", foo_definition); io_delegate_.SetFileContents("old/p/Enum.aidl", enum_definition); io_delegate_.SetFileContents("new/p/Foo.aidl", foo_definition); io_delegate_.SetFileContents("new/p/Enum.aidl", enum_definition); EXPECT_TRUE(::android::aidl::check_api(options, io_delegate_)); } TEST_F(AidlTest, CheckApi_EnumFieldsFromImported) { Options options = Options::From("aidl --checkapi old new -I import"); io_delegate_.SetFileContents("old/p/Foo.aidl", "package p; parcelable Foo{ other.Enum e; }"); io_delegate_.SetFileContents("new/p/Foo.aidl", "package p; parcelable Foo{ other.Enum e = other.Enum.FOO; }"); io_delegate_.SetFileContents("import/other/Enum.aidl", "package other; enum Enum { FOO }"); EXPECT_TRUE(::android::aidl::check_api(options, io_delegate_)); } TEST_F(AidlTest, CheckApiEqual_EnumFieldsWithDefaultValues) { Options options = Options::From("aidl --checkapi=equal old new"); const string foo_definition = "package p; parcelable Foo{ p.Enum e = p.Enum.FOO; }"; const string enum_definition = "package p; enum Enum { FOO }"; io_delegate_.SetFileContents("old/p/Foo.aidl", foo_definition); io_delegate_.SetFileContents("old/p/Enum.aidl", enum_definition); io_delegate_.SetFileContents("new/p/Foo.aidl", foo_definition); io_delegate_.SetFileContents("new/p/Enum.aidl", enum_definition); CaptureStderr(); EXPECT_TRUE(::android::aidl::check_api(options, io_delegate_)); EXPECT_EQ("", GetCapturedStderr()); } class AidlTestCompatibleChanges : public AidlTest { protected: Options options_ = Options::From("aidl --checkapi old new"); }; TEST_F(AidlTestCompatibleChanges, NewType) { io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p;" "interface IFoo {" " void foo(int a);" "}"); io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p;" "interface IFoo {" " void foo(int a);" "}"); io_delegate_.SetFileContents("new/p/IBar.aidl", "package p;" "interface IBar {" " void bar();" "}"); EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_)); } TEST_F(AidlTestCompatibleChanges, NewMethod) { io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p;" "interface IFoo {" " void foo(int a);" "}"); io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p;" "interface IFoo {" " void foo(int a);" " void bar();" " void baz(in List arg);" "}"); EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_)); } TEST_F(AidlTestCompatibleChanges, NewField) { io_delegate_.SetFileContents("old/p/Data.aidl", "package p;" "parcelable Data {" " int foo;" "}"); io_delegate_.SetFileContents("new/p/Data.aidl", "package p;" "parcelable Data {" " int foo;" " int bar = 0;" " @nullable List list;" "}"); EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_)); } TEST_F(AidlTestCompatibleChanges, NewField2) { io_delegate_.SetFileContents("old/p/Data.aidl", "package p;" "parcelable Data {" "}"); io_delegate_.SetFileContents("new/p/Data.aidl", "package p;" "parcelable Data {" " int foo = 0;" "}"); EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_)); } TEST_F(AidlTestCompatibleChanges, NewEnumerator) { io_delegate_.SetFileContents("old/p/Enum.aidl", "package p;" "enum Enum {" " FOO = 1," "}"); io_delegate_.SetFileContents("new/p/Enum.aidl", "package p;" "enum Enum {" " FOO = 1," " BAR = 2," "}"); EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_)); } TEST_F(AidlTestCompatibleChanges, ReorderedEnumerator) { io_delegate_.SetFileContents("old/p/Enum.aidl", "package p;" "enum Enum {" " FOO = 1," " BAR = 2," "}"); io_delegate_.SetFileContents("new/p/Enum.aidl", "package p;" "enum Enum {" " BAR = 2," " FOO = 1," "}"); EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_)); } TEST_F(AidlTestCompatibleChanges, NewUnionField) { io_delegate_.SetFileContents("old/p/Union.aidl", "package p;" "union Union {" " String foo;" "}"); io_delegate_.SetFileContents("new/p/Union.aidl", "package p;" "union Union {" " String foo;" " int num;" "}"); EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_)); } TEST_F(AidlTestCompatibleChanges, NewPackage) { io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p;" "interface IFoo {" " void foo(int a);" "}"); io_delegate_.SetFileContents("old/p/Data.aidl", "package p;" "parcelable Data {" " int foo;" "}"); io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p;" "interface IFoo {" " void foo(int a);" "}"); io_delegate_.SetFileContents("new/p/Data.aidl", "package p;" "parcelable Data {" " int foo;" "}"); io_delegate_.SetFileContents("new/q/IFoo.aidl", "package q;" "interface IFoo {" " void foo(int a);" "}"); io_delegate_.SetFileContents("new/q/Data.aidl", "package q;" "parcelable Data {" " int foo;" "}"); EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_)); } TEST_F(AidlTestCompatibleChanges, ArgNameChange) { io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p;" "interface IFoo {" " void foo(int a);" "}"); io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p;" "interface IFoo {" " void foo(int b);" "}"); EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_)); } TEST_F(AidlTestCompatibleChanges, AddedConstValue) { io_delegate_.SetFileContents("old/p/I.aidl", "package p; interface I {" "const int A = 1; }"); io_delegate_.SetFileContents("new/p/I.aidl", "package p ; interface I {" "const int A = 1; const int B = 2;}"); EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_)); } TEST_F(AidlTestCompatibleChanges, ChangedConstValueOrder) { io_delegate_.SetFileContents("old/p/I.aidl", "package p; interface I {" "const int A = 1; const int B = 2;}"); io_delegate_.SetFileContents("new/p/I.aidl", "package p ; interface I {" "const int B = 2; const int A = 1;}"); EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_)); } TEST_F(AidlTestCompatibleChanges, ReorderedAnnatations) { io_delegate_.SetFileContents("old/p/Foo.aidl", "package p;" "@JavaPassthrough(annotation=\"Alice\")" "@JavaPassthrough(annotation=\"Bob\")" "parcelable Foo {}"); io_delegate_.SetFileContents("new/p/Foo.aidl", "package p;" "@JavaPassthrough(annotation=\"Bob\")" "@JavaPassthrough(annotation=\"Alice\")" "parcelable Foo {}"); EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_)); } TEST_F(AidlTestCompatibleChanges, OkayToDeprecate) { io_delegate_.SetFileContents("old/p/Foo.aidl", "package p;" "parcelable Foo {}"); io_delegate_.SetFileContents("new/p/Foo.aidl", "package p;" "@JavaPassthrough(annotation=\"@Deprecated\")" "parcelable Foo {}"); EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_)); } TEST_F(AidlTestCompatibleChanges, NewFieldOfNewType) { io_delegate_.SetFileContents("old/p/Data.aidl", "package p;" "parcelable Data {" " int num;" "}"); io_delegate_.SetFileContents( "new/p/Data.aidl", "package p;" "parcelable Data {" " int num;" " p.Enum e;" // this is considered as valid since 0(enum default) is valid for "Enum" type "}"); io_delegate_.SetFileContents("new/p/Enum.aidl", "package p;" "enum Enum {" " FOO = 0," " BAR = 1," "}"); EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_)); } TEST_F(AidlTestCompatibleChanges, CompatibleExplicitDefaults) { io_delegate_.SetFileContents("old/p/Data.aidl", "package p;\n" "parcelable Data {\n" " p.Enum e;\n" "}"); io_delegate_.SetFileContents("old/p/Enum.aidl", "package p;\n" "enum Enum {\n" " FOO = 0,\n" " BAR = 1,\n" "}"); io_delegate_.SetFileContents("new/p/Data.aidl", "package p;\n" "parcelable Data {\n" " p.Enum e = p.Enum.FOO;\n" "}"); io_delegate_.SetFileContents("new/p/Enum.aidl", "package p;\n" "enum Enum {\n" " FOO = 0,\n" " BAR = 1,\n" "}"); EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_)); } TEST_F(AidlTestCompatibleChanges, NewNestedTypes) { io_delegate_.SetFileContents("old/p/Data.aidl", "package p;\n" "parcelable Data {\n" " int n;\n" "}"); io_delegate_.SetFileContents("new/p/Data.aidl", "package p;\n" "parcelable Data {\n" " enum NewEnum { N = 3 }\n" " int n;\n" " NewEnum e = NewEnum.N;\n" "}"); EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_)); } TEST_F(AidlTestCompatibleChanges, NewJavaSuppressLint) { io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p;" "interface IFoo {" " void foo(int a);" "}"); io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p;" "@JavaSuppressLint({\"NewApi\"})" "interface IFoo {" " void foo(int a);" "}"); EXPECT_TRUE(::android::aidl::check_api(options_, io_delegate_)); } class AidlTestIncompatibleChanges : public AidlTest { protected: Options options_ = Options::From("aidl --checkapi old new"); }; TEST_F(AidlTestIncompatibleChanges, RemovedType) { const string expected_stderr = "ERROR: old/p/IFoo.aidl:1.11-20: Removed type: p.IFoo\n"; io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p;" "interface IFoo {" " void foo(in String[] str);" " void bar(@utf8InCpp String str);" "}"); CaptureStderr(); EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTestIncompatibleChanges, RemovedMethod) { const string expected_stderr = "ERROR: old/p/IFoo.aidl:1.61-65: Removed or changed method: p.IFoo.bar(String)\n"; io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p;" "interface IFoo {" " void foo(in String[] str);" " void bar(@utf8InCpp String str);" "}"); io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p;" "interface IFoo {" " void foo(in String[] str);" "}"); CaptureStderr(); EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTestIncompatibleChanges, UntypedListInInterface) { const string expected_stderr = "ERROR: new/p/IFoo.aidl:1.61-65: " "Encountered an untyped List or Map. The use of untyped List/Map is " "prohibited because it is not guaranteed that the objects in the list are recognizable in " "the receiving side. Consider switching to an array or a generic List/Map.\n" "ERROR: new/p/IFoo.aidl: Failed to read.\n"; io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p;" "interface IFoo {" " void foo(in String[] str);" "}"); io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p;" "interface IFoo {" " void foo(in String[] str);" " void bar(in List arg);" "}"); CaptureStderr(); EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTestCompatibleChanges, UntypedListInParcelable) { const string expected_stderr = "ERROR: new/p/Data.aidl:1.54-59: " "Encountered an untyped List or Map. The use of untyped List/Map is " "prohibited because it is not guaranteed that the objects in the list are recognizable in " "the receiving side. Consider switching to an array or a generic List/Map.\n" "ERROR: new/p/Data.aidl: Failed to read.\n"; io_delegate_.SetFileContents("old/p/Data.aidl", "package p;" "parcelable Data {" " int foo;" "}"); io_delegate_.SetFileContents("new/p/Data.aidl", "package p;" "parcelable Data {" " int foo;" " @nullable List list;" "}"); CaptureStderr(); EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTestIncompatibleChanges, RemovedField) { const string expected_stderr = "ERROR: new/p/Data.aidl:1.21-26: Number of fields in p.Data is reduced from 2 to 1.\n"; io_delegate_.SetFileContents("old/p/Data.aidl", "package p;" "parcelable Data {" " int foo;" " int bar;" "}"); io_delegate_.SetFileContents("new/p/Data.aidl", "package p;" "parcelable Data {" " int foo;" "}"); CaptureStderr(); EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTestIncompatibleChanges, NewFieldWithNoDefault) { const string expected_stderr = "ERROR: new/p/Data.aidl:1.46-50: Field 'str' does not have a useful default in some " "backends. Please either provide a default value for this field or mark the field as " "@nullable. This value or a null value will be used automatically when an old version of " "this parcelable is sent to a process which understands a new version of this parcelable. In " "order to make sure your code continues to be backwards compatible, make sure the default or " "null value does not cause a semantic change to this parcelable.\n"; io_delegate_.SetFileContents("old/p/Data.aidl", "package p;" "parcelable Data {" " int num;" "}"); io_delegate_.SetFileContents("new/p/Data.aidl", "package p;" "parcelable Data {" " int num;" " String str;" "}"); CaptureStderr(); EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTestIncompatibleChanges, NewFieldWithNonZeroEnum) { const string expected_stderr = "ERROR: new/p/Data.aidl:1.46-48: Field 'e' of enum 'Enum' can't be initialized as '0'. " "Please make sure 'Enum' has '0' as a valid value.\n"; io_delegate_.SetFileContents("old/p/Data.aidl", "package p;" "parcelable Data {" " int num;" "}"); io_delegate_.SetFileContents("new/p/Data.aidl", "package p;" "parcelable Data {" " int num;" " p.Enum e;" "}"); io_delegate_.SetFileContents("new/p/Enum.aidl", "package p;" "enum Enum {" " FOO = 1," " BAR = 2," "}"); CaptureStderr(); EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTestIncompatibleChanges, RemovedEnumerator) { const string expected_stderr = "ERROR: new/p/Enum.aidl:1.15-20: Removed enumerator from p.Enum: FOO\n"; io_delegate_.SetFileContents("old/p/Enum.aidl", "package p;" "enum Enum {" " FOO = 1," " BAR = 2," "}"); io_delegate_.SetFileContents("new/p/Enum.aidl", "package p;" "enum Enum {" " BAR = 2," "}"); CaptureStderr(); EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTestIncompatibleChanges, RemovedUnionField) { const string expected_stderr = "ERROR: new/p/Union.aidl:1.16-22: Number of fields in p.Union is reduced from 2 to 1.\n"; io_delegate_.SetFileContents("old/p/Union.aidl", "package p;" "union Union {" " String str;" " int num;" "}"); io_delegate_.SetFileContents("new/p/Union.aidl", "package p;" "union Union {" " String str;" "}"); CaptureStderr(); EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTestIncompatibleChanges, RenamedMethod) { const string expected_stderr = "ERROR: old/p/IFoo.aidl:1.61-65: Removed or changed method: p.IFoo.bar(String)\n"; io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p;" "interface IFoo {" " void foo(in String[] str);" " void bar(@utf8InCpp String str);" "}"); io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p;" "interface IFoo {" " void foo(in String[] str);" " void bar2(@utf8InCpp String str);" "}"); CaptureStderr(); EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTestIncompatibleChanges, RenamedType) { const string expected_stderr = "ERROR: old/p/IFoo.aidl:1.11-20: Removed type: p.IFoo\n"; io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p;" "interface IFoo {" " void foo(in String[] str);" " void bar(@utf8InCpp String str);" "}"); io_delegate_.SetFileContents("new/p/IFoo2.aidl", "package p;" "interface IFoo2 {" " void foo(in String[] str);" " void bar(@utf8InCpp String str);" "}"); CaptureStderr(); EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTestIncompatibleChanges, ChangedEnumerator) { const string expected_stderr = "ERROR: new/p/Enum.aidl:1.15-20: Changed enumerator value: p.Enum::FOO from 1 to 3.\n"; io_delegate_.SetFileContents("old/p/Enum.aidl", "package p;" "enum Enum {" " FOO = 1," " BAR = 2," "}"); io_delegate_.SetFileContents("new/p/Enum.aidl", "package p;" "enum Enum {" " FOO = 3," " BAR = 2," "}"); CaptureStderr(); EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTestIncompatibleChanges, ReorderedMethod) { const string expected_stderr = "ERROR: new/p/IFoo.aidl:1.67-71: Transaction ID changed: p.IFoo.foo(String[]) is changed " "from 0 to 1.\n" "ERROR: new/p/IFoo.aidl:1.33-37: Transaction ID changed: p.IFoo.bar(String) is changed from " "1 to 0.\n"; io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p;" "interface IFoo {" " void foo(in String[] str);" " void bar(@utf8InCpp String str);" "}"); io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p;" "interface IFoo {" " void bar(@utf8InCpp String str);" " void foo(in String[] str);" "}"); CaptureStderr(); EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTestIncompatibleChanges, ReorderedField) { const string expected_stderr = "ERROR: new/p/Data.aidl:1.33-37: Reordered bar from 1 to 0.\n" "ERROR: new/p/Data.aidl:1.43-47: Reordered foo from 0 to 1.\n"; io_delegate_.SetFileContents("old/p/Data.aidl", "package p;" "parcelable Data {" " int foo;" " int bar;" "}"); io_delegate_.SetFileContents("new/p/Data.aidl", "package p;" "parcelable Data {" " int bar;" " int foo;" "}"); CaptureStderr(); EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTestIncompatibleChanges, ChangedDirectionSpecifier) { const string expected_stderr = "ERROR: new/p/IFoo.aidl:1.33-37: Direction changed: in to out.\n"; io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p;" "interface IFoo {" " void foo(in String[] str);" " void bar(@utf8InCpp String str);" "}"); io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p;" "interface IFoo {" " void foo(out String[] str);" " void bar(@utf8InCpp String str);" "}"); CaptureStderr(); EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTestIncompatibleChanges, AddedAnnotation) { const string expected_stderr = "ERROR: new/p/IFoo.aidl:1.51-58: Changed annotations: (empty) to @utf8InCpp\n"; io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p;" "interface IFoo {" " void foo(in String[] str);" " void bar(@utf8InCpp String str);" "}"); io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p;" "interface IFoo {" " void foo(in @utf8InCpp String[] str);" " void bar(@utf8InCpp String str);" "}"); CaptureStderr(); EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTestIncompatibleChanges, RemovedAnnotation) { const string expected_stderr = "ERROR: new/p/IFoo.aidl:1.66-72: Changed annotations: @utf8InCpp to (empty)\n"; io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p;" "interface IFoo {" " void foo(in String[] str);" " void bar(@utf8InCpp String str);" "}"); io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p;" "interface IFoo {" " void foo(in String[] str);" " void bar(String str);" "}"); CaptureStderr(); EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTestIncompatibleChanges, ChangedFixedSizeArraySize) { const string expected_stderr = "ERROR: new/p/Data.aidl:1.28-33: Type changed: int[8] to int[9].\n"; io_delegate_.SetFileContents("old/p/Data.aidl", "package p;" "parcelable Data {" " int[8] bar;" "}"); io_delegate_.SetFileContents("new/p/Data.aidl", "package p;" "parcelable Data {" " int[9] bar;" "}"); CaptureStderr(); EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTestIncompatibleChanges, ChangedAnnatationParams) { // this is also the test for backing type remaining the same const string expected_stderr = "ERROR: new/p/Foo.aidl:1.36-40: Changed annotations: @Backing(type=\"int\") " "to @Backing(type=\"long\")\n"; io_delegate_.SetFileContents("old/p/Foo.aidl", "package p;" "@Backing(type=\"int\")" "enum Foo {A}"); io_delegate_.SetFileContents("new/p/Foo.aidl", "package p;" "@Backing(type=\"long\")" "enum Foo {A}"); CaptureStderr(); EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTestIncompatibleChanges, AddedParcelableAnnotation) { const string expected_stderr = "ERROR: new/p/Foo.aidl:1.32-36: Changed annotations: (empty) to @FixedSize\n"; io_delegate_.SetFileContents("old/p/Foo.aidl", "package p;" "parcelable Foo {" " int A;" "}"); io_delegate_.SetFileContents("new/p/Foo.aidl", "package p;" "@FixedSize parcelable Foo {" " int A;" "}"); CaptureStderr(); EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTestIncompatibleChanges, RemovedParcelableAnnotation) { const string expected_stderr = "ERROR: new/p/Foo.aidl:1.21-25: Changed annotations: @FixedSize to (empty)\n"; io_delegate_.SetFileContents("old/p/Foo.aidl", "package p;" "@FixedSize parcelable Foo {" " int A;" "}"); io_delegate_.SetFileContents("new/p/Foo.aidl", "package p;" "parcelable Foo {" " int A;" "}"); CaptureStderr(); EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTestIncompatibleChanges, RemovedPackage) { const string expected_stderr = "ERROR: old/q/IFoo.aidl:1.11-21: Removed type: q.IFoo\n"; io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p; interface IFoo{}"); io_delegate_.SetFileContents("old/q/IFoo.aidl", "package q; interface IFoo{}"); io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p; interface IFoo{}"); CaptureStderr(); EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTestIncompatibleChanges, ChangedDefaultValue) { const string expected_stderr = "ERROR: new/p/D.aidl:1.30-32: Changed default value: 1 to 2.\n"; io_delegate_.SetFileContents("old/p/D.aidl", "package p; parcelable D { int a = 1; }"); io_delegate_.SetFileContents("new/p/D.aidl", "package p; parcelable D { int a = 2; }"); CaptureStderr(); EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTestIncompatibleChanges, RemovedConstValue) { const string expected_stderr = "ERROR: old/p/I.aidl:1.51-53: Removed constant declaration: p.I.B\n"; io_delegate_.SetFileContents("old/p/I.aidl", "package p; interface I {" "const int A = 1; const int B = 2;}"); io_delegate_.SetFileContents("new/p/I.aidl", "package p; interface I { const int A = 1; }"); CaptureStderr(); EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTestIncompatibleChanges, ChangedConstValue) { const string expected_stderr = "ERROR: new/p/I.aidl:1.11-21: Changed constant value: p.I.A from 1 to 2.\n"; io_delegate_.SetFileContents("old/p/I.aidl", "package p; interface I { const int A = 1; }"); io_delegate_.SetFileContents("new/p/I.aidl", "package p; interface I { const int A = 2; }"); CaptureStderr(); EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTestIncompatibleChanges, FixedSizeAddedField) { const string expected_stderr = "ERROR: new/p/Foo.aidl:1.33-37: Number of fields in p.Foo is changed from 1 to 2. " "This is an incompatible change for FixedSize types.\n"; io_delegate_.SetFileContents("old/p/Foo.aidl", "package p; @FixedSize parcelable Foo { int A = 1; }"); io_delegate_.SetFileContents("new/p/Foo.aidl", "package p; @FixedSize parcelable Foo { int A = 1; int B = 2; }"); CaptureStderr(); EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTestIncompatibleChanges, UidRangeParcelAddedField) { const string expected_stderr = "ERROR: new/android/net/UidRangeParcel.aidl:1.32-47: Number of fields in " "android.net.UidRangeParcel is changed from 1 to 2. " "But it is forbidden because of legacy support.\n"; io_delegate_.SetFileContents("old/android/net/UidRangeParcel.aidl", "package android.net; parcelable UidRangeParcel { int A = 1; }"); io_delegate_.SetFileContents( "new/android/net/UidRangeParcel.aidl", "package android.net; parcelable UidRangeParcel { int A = 1; int B = 2; }"); CaptureStderr(); EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTestIncompatibleChanges, FixedSizeRemovedField) { const string expected_stderr = "ERROR: new/p/Foo.aidl:1.33-37: Number of fields in p.Foo is reduced from 2 to 1.\n"; io_delegate_.SetFileContents("old/p/Foo.aidl", "package p; @FixedSize parcelable Foo { int A = 1; int B = 1; }"); io_delegate_.SetFileContents("new/p/Foo.aidl", "package p; @FixedSize parcelable Foo { int A = 1; }"); CaptureStderr(); EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTestIncompatibleChanges, IncompatibleChangesInNestedType) { const string expected_stderr = "ERROR: new/p/Foo.aidl:1.33-37: Number of fields in p.Foo is reduced from 2 to 1.\n"; io_delegate_.SetFileContents("old/p/Foo.aidl", "package p;\n" "parcelable Foo {\n" " interface IBar {\n" " void foo();" " }\n" "}"); io_delegate_.SetFileContents("new/p/Foo.aidl", "package p;\n" "parcelable Foo {\n" " interface IBar {\n" " void foo(int n);" // incompatible: signature changed " }\n" "}"); CaptureStderr(); EXPECT_FALSE(::android::aidl::check_api(options_, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("Removed or changed method: p.Foo.IBar.foo()")); } TEST_P(AidlTest, RejectNonFixedSizeFromFixedSize) { const string expected_stderr = "ERROR: Foo.aidl:2.8-10: The @FixedSize parcelable 'Foo' has a non-fixed size field named " "a.\n" "ERROR: Foo.aidl:3.6-8: The @FixedSize parcelable 'Foo' has a non-fixed size field named b.\n" "ERROR: Foo.aidl:4.9-11: The @FixedSize parcelable 'Foo' has a non-fixed size field named " "c.\n" "ERROR: Foo.aidl:5.23-25: The @FixedSize parcelable 'Foo' has a non-fixed size field named " "d.\n" "ERROR: Foo.aidl:6.10-12: The @FixedSize parcelable 'Foo' has a non-fixed size field named " "e.\n" "ERROR: Foo.aidl:7.15-17: The @FixedSize parcelable 'Foo' has a non-fixed size field named " "f.\n" "ERROR: Foo.aidl:9.23-33: The @FixedSize parcelable 'Foo' has a non-fixed size field named " "nullable1.\n" "ERROR: Foo.aidl:10.34-44: The @FixedSize parcelable 'Foo' has a non-fixed size field named " "nullable2.\n"; io_delegate_.SetFileContents("Foo.aidl", "@FixedSize parcelable Foo {\n" " int[] a;\n" " Bar b;\n" " String c;\n" " ParcelFileDescriptor d;\n" " IBinder e;\n" " List f;\n" " int isFixedSize;\n" " @nullable OtherFixed nullable1;\n" " @nullable(heap=true) OtherFixed nullable2;\n" " float[16] floats;\n" "}"); io_delegate_.SetFileContents("Bar.aidl", "parcelable Bar { int a; }"); io_delegate_.SetFileContents("OtherFixed.aidl", "@FixedSize parcelable OtherFixed { int a; }"); Options options = Options::From("aidl Foo.aidl -I . --lang=" + to_string(GetLanguage())); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_P(AidlTest, RejectNonFixedSizeFromFixedSize_Union) { const string expected_stderr = "ERROR: Foo.aidl:2.8-10: The @FixedSize parcelable 'Foo' has a non-fixed size field named " "a.\n" "ERROR: Foo.aidl:3.6-8: The @FixedSize parcelable 'Foo' has a non-fixed size field named b.\n" "ERROR: Foo.aidl:4.9-11: The @FixedSize parcelable 'Foo' has a non-fixed size field named " "c.\n" "ERROR: Foo.aidl:5.23-25: The @FixedSize parcelable 'Foo' has a non-fixed size field named " "d.\n" "ERROR: Foo.aidl:6.10-12: The @FixedSize parcelable 'Foo' has a non-fixed size field named " "e.\n" "ERROR: Foo.aidl:7.15-17: The @FixedSize parcelable 'Foo' has a non-fixed size field named " "f.\n" "ERROR: Foo.aidl:9.23-33: The @FixedSize parcelable 'Foo' has a non-fixed size field named " "nullable1.\n" "ERROR: Foo.aidl:10.34-44: The @FixedSize parcelable 'Foo' has a non-fixed size field named " "nullable2.\n"; io_delegate_.SetFileContents("Foo.aidl", "@FixedSize union Foo {\n" " int[] a = {};\n" " Bar b;\n" " String c;\n" " ParcelFileDescriptor d;\n" " IBinder e;\n" " List f;\n" " int isFixedSize;\n" " @nullable OtherFixed nullable1;\n" " @nullable(heap=true) OtherFixed nullable2;\n" " float[16] floats;\n" "}"); io_delegate_.SetFileContents("Bar.aidl", "parcelable Bar { int a; }"); io_delegate_.SetFileContents("OtherFixed.aidl", "@FixedSize parcelable OtherFixed { int a; }"); Options options = Options::From("aidl Foo.aidl -I . --lang=" + to_string(GetLanguage())); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_P(AidlTest, AcceptFixedSizeFromFixedSize) { const string expected_stderr = ""; io_delegate_.SetFileContents("Foo.aidl", "@FixedSize parcelable Foo { int a; Bar b; }"); io_delegate_.SetFileContents("Bar.aidl", "@FixedSize parcelable Bar { Val c; }"); io_delegate_.SetFileContents("Val.aidl", "enum Val { A, B, }"); Options options = Options::From("aidl Foo.aidl -I . --lang=" + to_string(GetLanguage())); CaptureStderr(); EXPECT_TRUE(compile_aidl(options, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTest, RejectAmbiguousImports) { const string expected_stderr = "ERROR: p/IFoo.aidl: Duplicate files found for q.IBar from:\n" "dir1/q/IBar.aidl\n" "dir2/q/IBar.aidl\n"; Options options = Options::From("aidl --lang=java -o out -I . -I dir1 -I dir2 p/IFoo.aidl"); io_delegate_.SetFileContents("p/IFoo.aidl", "package p; import q.IBar; interface IFoo{}"); io_delegate_.SetFileContents("dir1/q/IBar.aidl", "package q; interface IBar{}"); io_delegate_.SetFileContents("dir2/q/IBar.aidl", "package q; interface IBar{}"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTest, HandleManualIdAssignments) { const string expected_stderr = "ERROR: new/p/IFoo.aidl:1.32-36: Transaction ID changed: p.IFoo.foo() is changed from 10 to " "11.\n"; Options options = Options::From("aidl --checkapi old new"); io_delegate_.SetFileContents("old/p/IFoo.aidl", "package p; interface IFoo{ void foo() = 10;}"); io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p; interface IFoo{ void foo() = 10;}"); EXPECT_TRUE(::android::aidl::check_api(options, io_delegate_)); io_delegate_.SetFileContents("new/p/IFoo.aidl", "package p; interface IFoo{ void foo() = 11;}"); CaptureStderr(); EXPECT_FALSE(::android::aidl::check_api(options, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_P(AidlTest, ParcelFileDescriptorIsBuiltinType) { Options options = Options::From("aidl -I . --lang=" + to_string(GetLanguage()) + " -h out -o out p/IFoo.aidl"); // use without import io_delegate_.SetFileContents("p/IFoo.aidl", "package p; interface IFoo{ void foo(in ParcelFileDescriptor fd);}"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); // capture output files map outputs = io_delegate_.OutputFiles(); // use without import but with full name io_delegate_.SetFileContents( "p/IFoo.aidl", "package p; interface IFoo{ void foo(in android.os.ParcelFileDescriptor fd);}"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); // output files should be the same EXPECT_EQ(outputs, io_delegate_.OutputFiles()); // use with import (as before) io_delegate_.SetFileContents("p/IFoo.aidl", "package p;" "import android.os.ParcelFileDescriptor;" "interface IFoo{" " void foo(in ParcelFileDescriptor fd);" "}"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); // output files should be the same EXPECT_EQ(outputs, io_delegate_.OutputFiles()); } TEST_P(AidlTest, RejectsOutputParcelFileDescriptor) { Options options = Options::From("aidl p/IFoo.aidl -I . --lang=" + to_string(GetLanguage())); CaptureStderr(); io_delegate_.SetFileContents("p/IFoo.aidl", "package p;" "interface IFoo{" " void foo(out ParcelFileDescriptor fd);" "}"); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("can't be an out parameter")); } TEST_P(AidlTest, RejectsArgumentDirectionNotSpecified) { Options options = Options::From("aidl p/IFoo.aidl -I . --lang=" + to_string(GetLanguage())); CaptureStderr(); io_delegate_.SetFileContents("p/IFoo.aidl", "package p;" "interface IFoo{" " void foo(ParcelFileDescriptor fd);" "}"); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("ParcelFileDescriptor can be an in or inout parameter.")); } TEST_F(AidlTest, ManualIds) { Options options = Options::From("aidl --lang=java -I . -o out IFoo.aidl"); io_delegate_.SetFileContents("IFoo.aidl", "interface IFoo {\n" " void foo() = 0;\n" " void bar() = 1;\n" "}"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); } TEST_F(AidlTest, ManualIdsWithMetaTransactions) { Options options = Options::From("aidl --lang=java -I . --version 10 -o out IFoo.aidl"); io_delegate_.SetFileContents("IFoo.aidl", "interface IFoo {\n" " void foo() = 0;\n" " void bar() = 1;\n" "}"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); } TEST_F(AidlTest, FailOnDuplicatedIds) { const string expected_stderr = "ERROR: IFoo.aidl:3.7-11: Found duplicate method id (3) for method bar\n"; Options options = Options::From("aidl --lang=java -I . --version 10 -o out IFoo.aidl"); io_delegate_.SetFileContents("IFoo.aidl", "interface IFoo {\n" " void foo() = 3;\n" " void bar() = 3;\n" "}"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTest, FailOnOutOfRangeIds) { // 16777115 is kLastMetaMethodId + 1 const string expected_stderr = "ERROR: IFoo.aidl:3.7-11: Found out of bounds id (16777115) for method bar. " "Value for id must be between 0 and 16777114 inclusive.\n"; Options options = Options::From("aidl --lang=java -I . --version 10 -o out IFoo.aidl"); io_delegate_.SetFileContents("IFoo.aidl", "interface IFoo {\n" " void foo() = 3;\n" " void bar() = 16777115;\n" "}"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTest, FailOnPartiallyAssignedIds) { const string expected_stderr = "ERROR: IFoo.aidl:3.7-11: You must either assign id's to all methods or to none of them.\n"; Options options = Options::From("aidl --lang=java -I . --version 10 -o out IFoo.aidl"); io_delegate_.SetFileContents("IFoo.aidl", "interface IFoo {\n" " void foo() = 3;\n" " void bar();\n" "}"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTest, AssignedIds) { CaptureStderr(); EXPECT_NE(nullptr, Parse("IFoo.aidl", "interface IFoo {\n" " void foo();\n" " void bar();\n" " interface INested {\n" " void foo();\n" " void bar();\n" " }\n" "}", typenames_, Options::Language::JAVA)); EXPECT_EQ("", GetCapturedStderr()); auto foo = typenames_.ResolveTypename("IFoo").defined_type; ASSERT_EQ(2u, foo->GetMethods().size()); EXPECT_EQ(0, foo->GetMethods()[0]->GetId()); EXPECT_EQ(1, foo->GetMethods()[1]->GetId()); auto nested = typenames_.ResolveTypename("IFoo.INested").defined_type; ASSERT_EQ(2u, nested->GetMethods().size()); EXPECT_EQ(0, nested->GetMethods()[0]->GetId()); EXPECT_EQ(1, nested->GetMethods()[1]->GetId()); } TEST_F(AidlTest, AllowDuplicatedImportPaths) { Options options = Options::From("aidl --lang=java -I . -I dir -I dir IFoo.aidl"); io_delegate_.SetFileContents("dir/IBar.aidl", "interface IBar{}"); io_delegate_.SetFileContents("IFoo.aidl", "import IBar; interface IFoo{}"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); } TEST_F(AidlTest, UnusedImportDoesNotContributeInclude) { io_delegate_.SetFileContents("a/b/IFoo.aidl", "package a.b;\n" "import a.b.IBar;\n" "import a.b.IQux;\n" "interface IFoo { IQux foo(); }\n"); io_delegate_.SetFileContents("a/b/IBar.aidl", "package a.b; interface IBar { void foo(); }"); io_delegate_.SetFileContents("a/b/IQux.aidl", "package a.b; interface IQux { void foo(); }"); Options options = Options::From("aidl --lang=ndk a/b/IFoo.aidl -I . -o out -h out/include"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); string output; EXPECT_TRUE(io_delegate_.GetWrittenContents("out/include/aidl/a/b/IFoo.h", &output)); // IBar was imported but wasn't used. include is not expected. EXPECT_THAT(output, Not(testing::HasSubstr("#include "))); // IBar was imported and used. include is expected. EXPECT_THAT(output, (testing::HasSubstr("#include "))); } TEST_F(AidlTest, BasePathAsImportPath) { Options options = Options::From("aidl --lang=java -I some -I other some/dir/pkg/name/IFoo.aidl"); io_delegate_.SetFileContents("some/dir/pkg/name/IFoo.aidl", "package pkg.name; interface IFoo { void foo(); }"); const string expected_stderr = "ERROR: some/dir/pkg/name/IFoo.aidl:1.18-28: directory some/dir/ is not found in any of " "the import paths:\n - other/\n - some/\n"; CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTest, ParseJavaPassthroughAnnotation) { io_delegate_.SetFileContents("a/IFoo.aidl", R"--(package a; import a.MyEnum; @JavaPassthrough(annotation="@com.android.Alice(arg=com.android.Alice.Value.A)") @JavaPassthrough(annotation="@com.android.AliceTwo") interface IFoo { @JavaPassthrough(annotation="@com.android.Bob") void foo(@JavaPassthrough(annotation="@com.android.Cat") int x, MyEnum y); const @JavaPassthrough(annotation="@com.android.David") int A = 3; })--"); // JavaPassthrough should work with other types as well (e.g. enum) io_delegate_.SetFileContents("a/MyEnum.aidl", R"--(package a; @JavaPassthrough(annotation="@com.android.Alice(arg=com.android.Alice.Value.A)") @JavaPassthrough(annotation="@com.android.AliceTwo") @Backing(type="byte") enum MyEnum { a, b, c })--"); Options java_options = Options::From("aidl -I . --lang=java -o out a/IFoo.aidl a/MyEnum.aidl"); EXPECT_TRUE(compile_aidl(java_options, io_delegate_)); string java_out; EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/IFoo.java", &java_out)); // type-decl-level annotations with newline at the end EXPECT_THAT(java_out, testing::HasSubstr("@com.android.Alice(arg=com.android.Alice.Value.A)\n")); EXPECT_THAT(java_out, testing::HasSubstr("@com.android.AliceTwo\n")); // member-decl-level annotations with newline at the end EXPECT_THAT(java_out, testing::HasSubstr("@com.android.Bob\n")); EXPECT_THAT(java_out, testing::HasSubstr("@com.android.David\n")); // inline annotations with space at the end EXPECT_THAT(java_out, testing::HasSubstr("@com.android.Cat ")); EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/MyEnum.java", &java_out)); // type-decl-level annotations with newline at the end EXPECT_THAT(java_out, testing::HasSubstr("@com.android.Alice(arg=com.android.Alice.Value.A)\n")); EXPECT_THAT(java_out, testing::HasSubstr("@com.android.AliceTwo\n")); // Other backends shouldn't be bothered Options cpp_options = Options::From("aidl -I . --lang=cpp -o out -h out a/IFoo.aidl a/MyEnum.aidl"); EXPECT_TRUE(compile_aidl(cpp_options, io_delegate_)); Options ndk_options = Options::From("aidl -I . --lang=ndk -o out -h out a/IFoo.aidl a/MyEnum.aidl"); EXPECT_TRUE(compile_aidl(ndk_options, io_delegate_)); Options rust_options = Options::From("aidl -I . --lang=rust -o out a/IFoo.aidl a/MyEnum.aidl"); EXPECT_TRUE(compile_aidl(rust_options, io_delegate_)); } TEST_F(AidlTest, ParseRustDerive) { io_delegate_.SetFileContents("a/Foo.aidl", R"(package a; @RustDerive(Clone=true, Copy=false) parcelable Foo { int a; })"); Options rust_options = Options::From("aidl -I . --lang=rust -o out a/Foo.aidl"); EXPECT_TRUE(compile_aidl(rust_options, io_delegate_)); string rust_out; EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/Foo.rs", &rust_out)); EXPECT_THAT(rust_out, testing::HasSubstr("#[derive(Debug, Clone)]")); // Other backends shouldn't be bothered Options cpp_options = Options::From("aidl --lang=cpp -I . -o out -h out a/Foo.aidl"); EXPECT_TRUE(compile_aidl(cpp_options, io_delegate_)); Options ndk_options = Options::From("aidl --lang=ndk -I . -o out -h out a/Foo.aidl"); EXPECT_TRUE(compile_aidl(ndk_options, io_delegate_)); Options java_options = Options::From("aidl --lang=java -I . -o out a/Foo.aidl"); EXPECT_TRUE(compile_aidl(java_options, io_delegate_)); } TEST_P(AidlTest, TypesShouldHaveRustDerive) { CaptureStderr(); string code = "@RustDerive(PartialEq=true)\n" "parcelable Foo {\n" " parcelable Bar {}\n" " Bar bar;\n" "}"; EXPECT_EQ(nullptr, Parse("Foo.aidl", code, typenames_, GetLanguage(), nullptr, {})); EXPECT_THAT( GetCapturedStderr(), testing::HasSubstr("Field bar of type with @RustDerive PartialEq also needs to derive this")); } TEST_F(AidlTest, EmptyEnforceAnnotation) { io_delegate_.SetFileContents("a/IFoo.aidl", R"(package a; interface IFoo { @EnforcePermission() void Protected(); })"); Options options = Options::From("aidl --lang=java -I . -o out a/IFoo.aidl"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("Unable to parse @EnforcePermission annotation")); } TEST_F(AidlTest, InterfaceEnforceCondition) { io_delegate_.SetFileContents("a/IFoo.aidl", R"(package a; @EnforcePermission("INTERNET") interface IFoo { void Protected(); })"); Options options = Options::From("aidl --lang=java -I . -o out a/IFoo.aidl"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); } TEST_F(AidlTest, EnforceConditionAny) { io_delegate_.SetFileContents("a/IFoo.aidl", R"(package a; interface IFoo { @EnforcePermission(anyOf={"INTERNET", "READ_PHONE_STATE"}) void Protected(); })"); Options options = Options::From("aidl --lang=java -I . -o out a/IFoo.aidl"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); } TEST_F(AidlTest, EnforceConditionAll) { io_delegate_.SetFileContents("a/IFoo.aidl", R"(package a; interface IFoo { @EnforcePermission(allOf={"INTERNET", "READ_PHONE_STATE"}) void Protected(); })"); Options options = Options::From("aidl --lang=java -I . -o out a/IFoo.aidl"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); } TEST_F(AidlTest, InterfaceAndMethodEnforceCondition) { io_delegate_.SetFileContents("a/IFoo.aidl", R"(package a; @EnforcePermission("INTERNET") interface IFoo { @EnforcePermission("SYSTEM_UID") void Protected(); })"); Options options = Options::From("aidl --lang=java -I . -o out a/IFoo.aidl"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("The interface IFoo uses a permission annotation but " "the method Protected is also annotated")); } TEST_F(AidlTest, NoPermissionInterfaceEnforceMethod) { io_delegate_.SetFileContents("a/IFoo.aidl", R"(package a; @RequiresNoPermission interface IFoo { @EnforcePermission("INTERNET") void Protected(); })"); Options options = Options::From("aidl --lang=java -I . -o out a/IFoo.aidl"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("The interface IFoo uses a permission annotation but " "the method Protected is also annotated")); } TEST_F(AidlTest, ManualPermissionInterfaceEnforceMethod) { io_delegate_.SetFileContents("a/IFoo.aidl", R"(package a; @PermissionManuallyEnforced interface IFoo { @EnforcePermission("INTERNET") void Protected(); })"); Options options = Options::From("aidl --lang=java -I . -o out a/IFoo.aidl"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("The interface IFoo uses a permission annotation but " "the method Protected is also annotated")); } TEST_F(AidlTest, EnforceInterfaceNoPermissionsMethod) { io_delegate_.SetFileContents("a/IFoo.aidl", R"(package a; @EnforcePermission("INTERNET") interface IFoo { @RequiresNoPermission void Protected(); })"); Options options = Options::From("aidl --lang=java -I . -o out a/IFoo.aidl"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("The interface IFoo uses a permission annotation but " "the method Protected is also annotated")); } TEST_F(AidlTest, EnforceInterfaceManualPermissionMethod) { io_delegate_.SetFileContents("a/IFoo.aidl", R"(package a; @EnforcePermission("INTERNET") interface IFoo { @PermissionManuallyEnforced void Protected(); })"); Options options = Options::From("aidl --lang=java -I . -o out a/IFoo.aidl"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("The interface IFoo uses a permission annotation but " "the method Protected is also annotated")); } TEST_F(AidlTest, JavaSuppressLint) { io_delegate_.SetFileContents("a/IFoo.aidl", R"(package a; @JavaSuppressLint({"NewApi"}) interface IFoo { })"); Options options = Options::From("aidl --lang=java -I . -o out a/IFoo.aidl"); CaptureStderr(); EXPECT_TRUE(compile_aidl(options, io_delegate_)); EXPECT_EQ(GetCapturedStderr(), ""); string code; EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/IFoo.java", &code)); EXPECT_THAT(code, HasSubstr("@android.annotation.SuppressLint(value = {\"NewApi\"})")); } class AidlOutputPathTest : public AidlTest { protected: void SetUp() override { AidlTest::SetUp(); io_delegate_.SetFileContents("sub/dir/foo/bar/IFoo.aidl", "package foo.bar; interface IFoo {}"); } void Test(const Options& options, const std::string expected_output_path) { EXPECT_TRUE(compile_aidl(options, io_delegate_)); // check the existence EXPECT_TRUE(io_delegate_.GetWrittenContents(expected_output_path, nullptr)); } }; TEST_F(AidlOutputPathTest, OutDirWithNoOutputFile) { // / / .java Test(Options::From("aidl -I sub/dir -o out sub/dir/foo/bar/IFoo.aidl"), "out/foo/bar/IFoo.java"); } TEST_F(AidlOutputPathTest, OutDirWithOutputFile) { // when output file is explicitly set, it is always respected. -o option is // ignored. Test(Options::From("aidl -I sub/dir -o out sub/dir/foo/bar/IFoo.aidl output/IFoo.java"), "output/IFoo.java"); } TEST_F(AidlOutputPathTest, NoOutDirWithOutputFile) { Test(Options::From("aidl -I sub/dir -o out sub/dir/foo/bar/IFoo.aidl output/IFoo.java"), "output/IFoo.java"); } TEST_F(AidlOutputPathTest, NoOutDirWithNoOutputFile) { // output is the same as the input file except for the suffix Test(Options::From("aidl -I sub/dir sub/dir/foo/bar/IFoo.aidl"), "sub/dir/foo/bar/IFoo.java"); } TEST_P(AidlTest, PassOnValidUnsignedInt32Int) { EvaluateValidAssignment( R"(package a; interface IFoo { const int UINT32_VALUE = 2147483650u32; })", "", typenames_, GetLanguage()); } TEST_P(AidlTest, FailOnOutOfBoundsUInt32MaxConstInt) { AidlError error; const string expected_stderr = "ERROR: p/IFoo.aidl:3.59-73: Could not parse integer: 4294967300u32\n"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("p/IFoo.aidl", R"(package p; interface IFoo { const int uint32_max_oob = 4294967300u32; } )", typenames_, GetLanguage(), &error)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); EXPECT_EQ(AidlError::PARSE_ERROR, error); } TEST_P(AidlTest, PassOnValidUnsignedInt64Int) { EvaluateValidAssignment( R"(package a; interface IFoo { const long UINT64_VALUE = 18446744073709551615u64; })", "", typenames_, GetLanguage()); } TEST_P(AidlTest, FailOnOutOfBoundsUInt64MaxConstInt) { AidlError error; const string expected_stderr = "ERROR: p/IFoo.aidl:3.60-84: Could not parse integer: 18446744073709551620u64\n"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("p/IFoo.aidl", R"(package p; interface IFoo { const long uint64_max_oob = 18446744073709551620u64; } )", typenames_, GetLanguage(), &error)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); EXPECT_EQ(AidlError::PARSE_ERROR, error); } TEST_P(AidlTest, PassOnValidUnsignedInt32Hex) { EvaluateValidAssignment( R"(package a; interface IFoo { const int UINT32_VALUE = 0xffffffffu32; })", "", typenames_, GetLanguage()); } TEST_P(AidlTest, FailOnOutOfBoundsUInt32MaxConstHex) { AidlError error; const string expected_stderr = "ERROR: p/IFoo.aidl:3.59-74: Invalid type specifier for an int64 literal: int " "(0xfffffffffu32).\n"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("p/IFoo.aidl", R"(package p; interface IFoo { const int uint32_max_oob = 0xfffffffffu32; } )", typenames_, GetLanguage(), &error)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); EXPECT_EQ(AidlError::BAD_TYPE, error); } TEST_P(AidlTest, PassOnValidUnsignedInt64Hex) { EvaluateValidAssignment( R"(package a; interface IFoo { const int UINT64_VALUE = 0xffffffffffffffffu64; })", "", typenames_, GetLanguage()); } TEST_P(AidlTest, FailOnOutOfBoundsUInt64MaxConstHex) { AidlError error; const string expected_stderr = "ERROR: p/IFoo.aidl:3.59-82: Could not parse hexvalue: 0xfffffffffffffffffu64\n"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("p/IFoo.aidl", R"(package p; interface IFoo { const int uint64_max_oob = 0xfffffffffffffffffu64; } )", typenames_, GetLanguage(), &error)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); EXPECT_EQ(AidlError::PARSE_ERROR, error); } TEST_P(AidlTest, FailOnOutOfBoundsInt32MaxConstInt) { AidlError error; const string expected_stderr = "ERROR: p/IFoo.aidl:3.58-69: Invalid type specifier for an int64 literal: int " "(2147483650). Did you mean: 2147483650u32?\n"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("p/IFoo.aidl", R"(package p; interface IFoo { const int int32_max_oob = 2147483650; } )", typenames_, GetLanguage(), &error)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); EXPECT_EQ(AidlError::BAD_TYPE, error); } TEST_P(AidlTest, FailOnOutOfBoundsInt32MinConstInt) { AidlError error; const string expected_stderr = "ERROR: p/IFoo.aidl:3.58-60: Invalid type specifier for an int64 literal: int " "(-2147483650).\n"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("p/IFoo.aidl", R"(package p; interface IFoo { const int int32_min_oob = -2147483650; } )", typenames_, GetLanguage(), &error)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); EXPECT_EQ(AidlError::BAD_TYPE, error); } TEST_P(AidlTest, FailOnOutOfBoundsInt64MaxConstInt) { AidlError error; const string expected_stderr = "ERROR: p/IFoo.aidl:3.59-86: Could not parse integer: 21474836509999999999999999\n"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("p/IFoo.aidl", R"(package p; interface IFoo { const long int64_max_oob = 21474836509999999999999999; } )", typenames_, GetLanguage(), &error)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); EXPECT_EQ(AidlError::PARSE_ERROR, error); } TEST_P(AidlTest, FailOnOutOfBoundsInt64MinConstInt) { AidlError error; const string expected_stderr = "ERROR: p/IFoo.aidl:3.61-87: Could not parse integer: 21474836509999999999999999\n"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("p/IFoo.aidl", R"(package p; interface IFoo { const long int64_min_oob = -21474836509999999999999999; } )", typenames_, GetLanguage(), &error)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); EXPECT_EQ(AidlError::PARSE_ERROR, error); } TEST_P(AidlTest, FailOnOutOfBoundsAutofilledEnum) { AidlError error; const string expected_stderr = "ERROR: p/TestEnum.aidl:5.1-36: Invalid type specifier for an int32 literal: byte (FOO+1).\n" "ERROR: p/TestEnum.aidl:5.1-36: Enumerator type differs from enum backing type.\n"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("p/TestEnum.aidl", R"(package p; @Backing(type="byte") enum TestEnum { FOO = 127, BAR, } )", typenames_, GetLanguage(), &error)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); EXPECT_EQ(AidlError::BAD_TYPE, error); } TEST_P(AidlTest, FailOnUnsupportedBackingType) { AidlError error; const string expected_stderr = "ERROR: p/TestEnum.aidl:3.35-44: Invalid backing type: boolean. Backing type must be one of: " "byte, int, long\n"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("p/TestEnum.aidl", R"(package p; @Backing(type="boolean") enum TestEnum { FOO = 0, BAR = 1, } )", typenames_, GetLanguage(), &error)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); EXPECT_EQ(AidlError::BAD_TYPE, error); } TEST_P(AidlTest, UnsupportedBackingAnnotationParam) { AidlError error; const string expected_stderr = "ERROR: p/TestEnum.aidl:2.1-51: Parameter foo not supported for annotation Backing. It must " "be one of: type\n"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("p/TestEnum.aidl", R"(package p; @Backing(foo="byte") enum TestEnum { FOO = 1, BAR, } )", typenames_, GetLanguage(), &error)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); EXPECT_EQ(AidlError::BAD_TYPE, error); } TEST_P(AidlTest, BackingAnnotationRequireTypeParameter) { const string expected_stderr = "ERROR: Enum.aidl:1.1-9: Missing 'type' on @Backing.\n"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("Enum.aidl", "@Backing enum Enum { FOO }", typenames_, GetLanguage())); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTest, SupportJavaOnlyImmutableAnnotation) { io_delegate_.SetFileContents("Foo.aidl", "@JavaOnlyImmutable parcelable Foo { int a; Bar b; List c; " "Map d; Bar[] e; }"); io_delegate_.SetFileContents("Bar.aidl", "@JavaOnlyImmutable parcelable Bar { String a; }"); io_delegate_.SetFileContents("Baz.aidl", "@JavaOnlyImmutable @JavaOnlyStableParcelable parcelable Baz;"); Options options = Options::From("aidl --lang=java -I . Foo.aidl"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); } TEST_F(AidlTest, RejectMutableParcelableFromJavaOnlyImmutableParcelable) { io_delegate_.SetFileContents("Foo.aidl", "@JavaOnlyImmutable parcelable Foo { Bar bar; }"); io_delegate_.SetFileContents("Bar.aidl", "parcelable Bar { String a; }"); string expected_error = "ERROR: Foo.aidl:1.40-44: The @JavaOnlyImmutable 'Foo' has a non-immutable field " "named 'bar'.\n"; CaptureStderr(); Options options = Options::From("aidl --lang=java Foo.aidl -I ."); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_EQ(expected_error, GetCapturedStderr()); } TEST_F(AidlTest, JavaOnlyImmutableParcelableWithEnumFields) { io_delegate_.SetFileContents("Foo.aidl", "@JavaOnlyImmutable parcelable Foo { Bar bar; }"); io_delegate_.SetFileContents("Bar.aidl", "enum Bar { FOO }"); CaptureStderr(); Options options = Options::From("aidl --lang=java Foo.aidl -I ."); EXPECT_TRUE(compile_aidl(options, io_delegate_)); EXPECT_EQ("", GetCapturedStderr()); } TEST_F(AidlTest, RejectMutableParcelableFromJavaOnlyImmutableUnion) { io_delegate_.SetFileContents("Foo.aidl", "@JavaOnlyImmutable union Foo { Bar bar; }"); io_delegate_.SetFileContents("Bar.aidl", "parcelable Bar { String a; }"); string expected_error = "ERROR: Foo.aidl:1.35-39: The @JavaOnlyImmutable 'Foo' has a non-immutable field " "named 'bar'.\n"; CaptureStderr(); Options options = Options::From("aidl --lang=java Foo.aidl -I ."); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_EQ(expected_error, GetCapturedStderr()); } TEST_F(AidlTest, ImmutableParcelableCannotBeInOut) { io_delegate_.SetFileContents("Foo.aidl", "@JavaOnlyImmutable parcelable Foo { int a; }"); io_delegate_.SetFileContents("IBar.aidl", "interface IBar { void my(inout Foo foo); }"); string expected_error = "ERROR: IBar.aidl:1.35-39: 'foo' can't be an inout parameter because @JavaOnlyImmutable can " "only be an in parameter.\n"; CaptureStderr(); Options options = Options::From("aidl --lang=java IBar.aidl -I ."); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_EQ(expected_error, GetCapturedStderr()); } TEST_F(AidlTest, ImmutableParcelableCannotBeOut) { io_delegate_.SetFileContents("Foo.aidl", "@JavaOnlyImmutable parcelable Foo { int a; }"); io_delegate_.SetFileContents("IBar.aidl", "interface IBar { void my(out Foo foo); }"); string expected_error = "ERROR: IBar.aidl:1.33-37: 'foo' can't be an out parameter because @JavaOnlyImmutable can " "only be an in parameter.\n"; CaptureStderr(); Options options = Options::From("aidl --lang=java IBar.aidl -I ."); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_EQ(expected_error, GetCapturedStderr()); } TEST_F(AidlTest, ImmutableParcelableFieldNameRestriction) { io_delegate_.SetFileContents("Foo.aidl", "@JavaOnlyImmutable parcelable Foo { int a; int A; }"); Options options = Options::From("aidl -I . --lang=java Foo.aidl"); const string expected_stderr = "ERROR: Foo.aidl:1.47-49: 'Foo' has duplicate field name 'A' after capitalizing the first " "letter\n"; CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_P(AidlTest, UnionInUnion) { import_paths_.insert("."); io_delegate_.SetFileContents("Bar.aidl", "union Bar { int n = 42; long l; }"); CaptureStderr(); EXPECT_NE(nullptr, Parse("Foo.aidl", "union Foo { Bar b; int n; }", typenames_, GetLanguage())); EXPECT_THAT("", GetCapturedStderr()); } TEST_P(AidlTest, UnionRejectsEmptyDecl) { const string method = "package a; union Foo {}"; const string expected_stderr = "ERROR: a/Foo.aidl:1.17-21: The union 'Foo' has no fields.\n"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("a/Foo.aidl", method, typenames_, GetLanguage())); EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr(expected_stderr)); } TEST_P(AidlTest, UnionRejectsParcelableHolder) { const string method = "package a; union Foo { ParcelableHolder x; }"; const string expected_stderr = "ERROR: a/Foo.aidl:1.40-42: A union can't have a member of ParcelableHolder 'x'\n"; CaptureStderr(); EXPECT_EQ(nullptr, Parse("a/Foo.aidl", method, typenames_, GetLanguage())); EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr(expected_stderr)); } TEST_P(AidlTest, UnionRejectsFirstEnumWithNoDefaults) { import_paths_.insert("."); io_delegate_.SetFileContents("a/Enum.aidl", "package a; enum Enum { FOO, BAR }"); const string expected_err = "The union's first member should have a useful default value."; CaptureStderr(); EXPECT_EQ(nullptr, Parse("a/Foo.aidl", "package a; union Foo { a.Enum e; }", typenames_, GetLanguage())); EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr(expected_err)); } TEST_P(AidlTest, GenericStructuredParcelable) { io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo { int a; int A; }"); Options options = Options::From("aidl -I . Foo.aidl --lang=" + to_string(GetLanguage())); const string expected_stderr = ""; CaptureStderr(); EXPECT_TRUE(compile_aidl(options, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTest, GenericStructuredParcelableWithStringConstants_Cpp) { io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo { int a; const String s = \"\"; }"); Options options = Options::From("aidl Foo.aidl -I . --lang=" + to_string(Options::Language::CPP) + " -o out -h out"); const string expected_stderr = ""; CaptureStderr(); EXPECT_TRUE(compile_aidl(options, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); string code; EXPECT_TRUE(io_delegate_.GetWrittenContents("out/Foo.h", &code)); EXPECT_THAT(code, testing::HasSubstr(R"--(template const ::android::String16& Foo::s() { static const ::android::String16 value(::android::String16("")); return value; })--")); } TEST_F(AidlTest, GenericStructuredParcelableWithStringConstants_Ndk) { io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo { int a; const String s = \"\"; }"); Options options = Options::From("aidl Foo.aidl -I . --lang=" + to_string(Options::Language::NDK) + " -o out -h out"); const string expected_stderr = ""; CaptureStderr(); EXPECT_TRUE(compile_aidl(options, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); string code; EXPECT_TRUE(io_delegate_.GetWrittenContents("out/aidl/Foo.h", &code)); EXPECT_THAT(code, testing::HasSubstr(R"--(template const char* Foo::s = ""; )--")); } TEST_F(AidlTest, NestedTypeArgs) { io_delegate_.SetFileContents("a/Bar.aidl", "package a; parcelable Bar { }"); io_delegate_.SetFileContents("a/Baz.aidl", "package a; parcelable Baz { }"); io_delegate_.SetFileContents("a/Foo.aidl", "package a; import a.Bar; import a.Baz; parcelable Foo { " "Baz>[], Bar> barss; }"); Options options = Options::From("aidl a/Foo.aidl -I . -o out --lang=java"); const string expected_stderr = ""; CaptureStderr(); EXPECT_TRUE(compile_aidl(options, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); string code; EXPECT_TRUE(io_delegate_.GetWrittenContents("out/a/Foo.java", &code)); EXPECT_THAT(code, testing::HasSubstr( "a.Baz>[],a.Bar> barss;")); } TEST_F(AidlTest, AcceptMultiDimensionalFixedSizeArray) { io_delegate_.SetFileContents("a/Bar.aidl", "package a; parcelable Bar { String[2][3] a; }"); Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=ndk"); CaptureStderr(); EXPECT_TRUE(compile_aidl(options, io_delegate_)); EXPECT_EQ("", GetCapturedStderr()); } TEST_F(AidlTest, AcceptBinarySizeArray) { io_delegate_.SetFileContents( "a/Bar.aidl", "package a; parcelable Bar { const int CONST = 3; String[CONST + 1] a; }"); Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=ndk"); CaptureStderr(); EXPECT_TRUE(compile_aidl(options, io_delegate_)); EXPECT_EQ("", GetCapturedStderr()); } TEST_F(AidlTest, AcceptRefSizeArray) { io_delegate_.SetFileContents( "a/Bar.aidl", "package a; parcelable Bar { const int CONST = 3; String[CONST] a; }"); Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=ndk"); CaptureStderr(); EXPECT_TRUE(compile_aidl(options, io_delegate_)); EXPECT_EQ("", GetCapturedStderr()); } TEST_F(AidlTest, RejectArrayOfFixedSizeArray) { io_delegate_.SetFileContents("a/Bar.aidl", "package a; parcelable Bar { String[2][] a; }"); Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=java"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("Multi-dimensional arrays must be fixed size.")); } TEST_F(AidlTest, RejectFixedSizeArrayOfDynamicArray) { io_delegate_.SetFileContents("a/Bar.aidl", "package a; parcelable Bar { String[][3] a; }"); Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=java"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("Multi-dimensional arrays must be fixed size.")); } TEST_F(AidlTest, RejectArrayOfArray) { io_delegate_.SetFileContents("a/Bar.aidl", "package a; parcelable Bar { String[][] a; }"); Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=java"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("Multi-dimensional arrays must be fixed size.")); } TEST_F(AidlTest, RejectInvalidArraySize_Negative) { io_delegate_.SetFileContents("a/Bar.aidl", "package a; parcelable Bar { String[-1] a; }"); Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=java"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("Array size must be a positive number")); } TEST_F(AidlTest, RejectInvalidArraySize_WrongType) { io_delegate_.SetFileContents("a/Bar.aidl", "package a; parcelable Bar { String[\"3\"] a; }"); Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=java"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("Array size must be a positive number")); } TEST_F(AidlTest, DoubleGenericError) { io_delegate_.SetFileContents("a/Bar.aidl", "package a; parcelable Bar { List a; }"); Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=java"); const string expected_stderr = "ERROR: a/Bar.aidl:1.28-33: Can only specify one set of type parameters.\n"; CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_F(AidlTest, ArrayBeforeGenericError) { io_delegate_.SetFileContents("a/Bar.aidl", "package a; parcelable Bar { List[] a; }"); Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=java"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr("syntax error, unexpected '<'")); } TEST_F(AidlTest, NullableArraysAreNotSupported) { io_delegate_.SetFileContents("a/Bar.aidl", "package a; parcelable Bar { String @nullable [] a; }"); Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=java"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr("Annotations for arrays are not supported.")); } TEST_F(AidlTest, ListOfNullablesAreNotSupported) { io_delegate_.SetFileContents("a/Bar.aidl", "package a; parcelable Bar { List<@nullable String> a; }"); Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=java"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr("Annotations for type arguments are not supported.")); } TEST_F(AidlTest, DefaultShouldMatchWithFixedSizeArray) { io_delegate_.SetFileContents("a/Bar.aidl", "package a;\n" "parcelable Bar {\n" " int[2][3] a = {{1,2,3}, {4,5,6}};\n" "}"); Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=ndk"); CaptureStderr(); EXPECT_TRUE(compile_aidl(options, io_delegate_)); EXPECT_EQ("", GetCapturedStderr()); } TEST_F(AidlTest, FixedSizeArrayWithWrongTypeDefaultValue) { io_delegate_.SetFileContents("a/Bar.aidl", "package a;\n" "parcelable Bar {\n" " int[2][3] a = {{\"1\",\"2\",\"3\"}, {4,5,6}};\n" "}"); Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=java"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("Invalid type specifier for a literal string: int")); } TEST_F(AidlTest, FixedSizeArrayWithMoreElements) { io_delegate_.SetFileContents("a/Bar.aidl", "package a;\n" "parcelable Bar {\n" " int[2][3] a = {{1,2,3,4}, {4,5,6}};\n" "}"); Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=java"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("Expected an array of 3 elements, but found one with 4 elements")); } TEST_F(AidlTest, FixedSizeArrayWithFewerElements) { io_delegate_.SetFileContents("a/Bar.aidl", "package a;\n" "parcelable Bar {\n" " int[2][3] a = {};\n" "}"); Options options = Options::From("aidl a/Bar.aidl -I . -o out --lang=java"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("Expected an array of 2 elements, but found one with 0 elements")); } struct GenericAidlTest : ::testing::Test { FakeIoDelegate io_delegate_; void Compile(string cmd) { io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo { Bar> x; }"); io_delegate_.SetFileContents("Bar.aidl", "parcelable Bar { }"); io_delegate_.SetFileContents("Baz.aidl", "parcelable Baz { }"); io_delegate_.SetFileContents("Qux.aidl", "parcelable Qux { }"); Options options = Options::From(cmd); CaptureStderr(); EXPECT_TRUE(compile_aidl(options, io_delegate_)); EXPECT_EQ("", GetCapturedStderr()); } }; TEST_F(GenericAidlTest, ImportGenericParameterTypesCPP) { Compile("aidl Foo.aidl --lang=cpp -I . -o out -h out"); string code; EXPECT_TRUE(io_delegate_.GetWrittenContents("out/Foo.h", &code)); EXPECT_THAT(code, testing::HasSubstr("#include ")); EXPECT_THAT(code, testing::HasSubstr("#include ")); EXPECT_THAT(code, testing::HasSubstr("#include ")); } TEST_F(GenericAidlTest, ImportGenericParameterTypesNDK) { Compile("aidl Foo.aidl --lang=ndk -I . -o out -h out"); string code; EXPECT_TRUE(io_delegate_.GetWrittenContents("out/aidl/Foo.h", &code)); EXPECT_THAT(code, testing::HasSubstr("#include ")); EXPECT_THAT(code, testing::HasSubstr("#include ")); EXPECT_THAT(code, testing::HasSubstr("#include ")); } TEST_P(AidlTest, RejectGenericStructuredParcelabelRepeatedParam) { io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo { int a; int A; }"); Options options = Options::From("aidl Foo.aidl -I . --lang=" + to_string(GetLanguage())); const string expected_stderr = "ERROR: Foo.aidl:1.11-15: Every type parameter should be unique.\n"; CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_P(AidlTest, RejectGenericStructuredParcelableField) { io_delegate_.SetFileContents("Foo.aidl", "parcelable Foo { T a; int A; }"); Options options = Options::From("aidl Foo.aidl -I . --lang=" + to_string(GetLanguage())); const string expected_stderr = "ERROR: Foo.aidl: Couldn't find import for class T. Searched here:\n - ./\nERROR: " "Foo.aidl:1.22-24: Failed to resolve 'T'\n"; CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_EQ(expected_stderr, GetCapturedStderr()); } TEST_P(AidlTest, LongCommentWithinConstExpression) { io_delegate_.SetFileContents("Foo.aidl", "enum Foo { FOO = (1 << 1) /* comment */ | 0x0 }"); Options options = Options::From("aidl Foo.aidl -I . --lang=" + to_string(GetLanguage())); CaptureStderr(); EXPECT_TRUE(compile_aidl(options, io_delegate_)); EXPECT_EQ("", GetCapturedStderr()); } TEST_F(AidlTest, RejectUntypdeListAndMapInUnion) { io_delegate_.SetFileContents("a/Foo.aidl", "package a; union Foo { List l; Map m; }"); Options options = Options::From("aidl a/Foo.aidl -I . --lang=java -o out"); std::string expectedErr = "ERROR: a/Foo.aidl:1.28-30: " "Encountered an untyped List or Map. The use of untyped List/Map is " "prohibited because it is not guaranteed that the objects in the list are recognizable in " "the receiving side. Consider switching to an array or a generic List/Map.\n" "ERROR: a/Foo.aidl:1.35-37: " "Encountered an untyped List or Map. The use of untyped List/Map is " "prohibited because it is not guaranteed that the objects in the list are recognizable in " "the receiving side. Consider switching to an array or a generic List/Map.\n"; CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_EQ(expectedErr, GetCapturedStderr()); } TEST_F(AidlTest, RejectUntypdeListAndMapInUnstructuredParcelable) { io_delegate_.SetFileContents("a/Foo.aidl", "package a; parcelable Foo { List l; Map m; }"); Options options = Options::From("aidl a/Foo.aidl -I . --lang=java -o out"); std::string expectedErr = "ERROR: a/Foo.aidl:1.33-35: " "Encountered an untyped List or Map. The use of untyped List/Map is " "prohibited because it is not guaranteed that the objects in the list are recognizable in " "the receiving side. Consider switching to an array or a generic List/Map.\n" "ERROR: a/Foo.aidl:1.40-42: " "Encountered an untyped List or Map. The use of untyped List/Map is " "prohibited because it is not guaranteed that the objects in the list are recognizable in " "the receiving side. Consider switching to an array or a generic List/Map.\n"; CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_EQ(expectedErr, GetCapturedStderr()); } TEST_F(AidlTest, RejectNestedUntypedListAndMap) { io_delegate_.SetFileContents("a/Bar.aidl", "package a; parcelable Bar;"); io_delegate_.SetFileContents( "a/Foo.aidl", "package a; import a.Bar; parcelable Foo { Bar a; Bar b; }"); Options options = Options::From("aidl a/Foo.aidl -I . --lang=java -o out"); std::string expectedErr = "ERROR: a/Foo.aidl:1.52-54: " "Encountered an untyped List or Map. The use of untyped List/Map is " "prohibited because it is not guaranteed that the objects in the list are recognizable in " "the receiving side. Consider switching to an array or a generic List/Map.\n" "ERROR: a/Foo.aidl:1.64-66: " "Encountered an untyped List or Map. The use of untyped List/Map is " "prohibited because it is not guaranteed that the objects in the list are recognizable in " "the receiving side. Consider switching to an array or a generic List/Map.\n"; CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_EQ(expectedErr, GetCapturedStderr()); } TEST_F(AidlTest, EnumWithDefaults_Java) { io_delegate_.SetFileContents("a/p/Enum.aidl", "package p; enum Enum { FOO, BAR }"); io_delegate_.SetFileContents("a/p/Foo.aidl", R"( package p; import p.Enum; parcelable Foo { Enum e = Enum.BAR; })"); CaptureStderr(); auto options = Options::From("aidl -I a --lang java -o out a/p/Foo.aidl"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); auto err = GetCapturedStderr(); EXPECT_EQ("", err); string code; EXPECT_TRUE(io_delegate_.GetWrittenContents("out/p/Foo.java", &code)); EXPECT_THAT(code, testing::HasSubstr("byte e = p.Enum.BAR")); } TEST_F(AidlTest, EnumWithDefaults_Cpp) { io_delegate_.SetFileContents("a/p/Enum.aidl", "package p; enum Enum { FOO, BAR }"); io_delegate_.SetFileContents("a/p/Foo.aidl", R"( package p; import p.Enum; parcelable Foo { Enum e = Enum.BAR; })"); CaptureStderr(); auto options = Options::From("aidl -I a --lang cpp -o out -h out a/p/Foo.aidl"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); auto err = GetCapturedStderr(); EXPECT_EQ("", err); string code; EXPECT_TRUE(io_delegate_.GetWrittenContents("out/p/Foo.h", &code)); EXPECT_THAT(code, testing::HasSubstr("::p::Enum e = ::p::Enum::BAR;")); } TEST_F(AidlTest, EnumWithDefaults_Ndk) { io_delegate_.SetFileContents("a/p/Enum.aidl", "package p; enum Enum { FOO, BAR }"); io_delegate_.SetFileContents("a/p/Foo.aidl", R"( package p; import p.Enum; parcelable Foo { Enum e = Enum.BAR; })"); CaptureStderr(); auto options = Options::From("aidl -I a --lang ndk -o out -h out a/p/Foo.aidl"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); auto err = GetCapturedStderr(); EXPECT_EQ("", err); string code; EXPECT_TRUE(io_delegate_.GetWrittenContents("out/aidl/p/Foo.h", &code)); EXPECT_THAT(code, testing::HasSubstr("::aidl::p::Enum e = ::aidl::p::Enum::BAR;")); } TEST_F(AidlTest, EnumWithDefaults_Rust) { io_delegate_.SetFileContents("a/p/Enum.aidl", "package p; enum Enum { FOO, BAR }"); io_delegate_.SetFileContents("a/p/Foo.aidl", R"( package p; import p.Enum; parcelable Foo { int n = 42; Enum e = Enum.BAR; })"); CaptureStderr(); auto options = Options::From("aidl -I a --lang rust -o out -h out a/p/Foo.aidl"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); auto err = GetCapturedStderr(); EXPECT_EQ("", err); string code; EXPECT_TRUE(io_delegate_.GetWrittenContents("out/p/Foo.rs", &code)); EXPECT_THAT(code, testing::HasSubstr(R"( fn default() -> Self { Self { r#n: 42, r#e: crate::mangled::_1_p_4_Enum::BAR, } })")); } TEST_P(AidlTest, EnumeratorIsConstantValue_DefaultValue) { import_paths_.insert("a"); io_delegate_.SetFileContents("a/p/Enum.aidl", "package p; enum Enum { FOO = 1, BAR = 2}"); CaptureStderr(); const AidlDefinedType* type = Parse("a/p/Foo.aidl", R"( package p; import p.Enum; parcelable Foo { int e = Enum.FOO | Enum.BAR; })", typenames_, GetLanguage()); auto err = GetCapturedStderr(); EXPECT_EQ("", err); EXPECT_TRUE(type); const auto& fields = type->AsStructuredParcelable()->GetFields(); EXPECT_EQ("int e = 3", fields[0]->ToString()); } TEST_F(AidlTest, EnumeratorIsConstantValue_CanDefineOtherEnumerator) { CaptureStderr(); const AidlDefinedType* type = Parse("a/p/Foo.aidl", R"( package a.p; @Backing(type="int") enum Foo { STANDARD_SHIFT = 16, STANDARD_BT709 = 1 << STANDARD_SHIFT, STANDARD_BT601_625 = 2 << STANDARD_SHIFT, } )", typenames_, Options::Language::JAVA); auto err = GetCapturedStderr(); EXPECT_EQ("", err); ASSERT_NE(type, nullptr); const auto& enum_type = type->AsEnumDeclaration(); string code; auto writer = CodeWriter::ForString(&code); DumpVisitor visitor(*writer, /*inline_constants=*/true); visitor.Visit(*enum_type); writer->Close(); EXPECT_EQ(R"--(@Backing(type="int") enum Foo { STANDARD_SHIFT = 16, STANDARD_BT709 = 65536, STANDARD_BT601_625 = 131072, } )--", code); } TEST_F(AidlTest, DumpApiWithConstantReferences) { io_delegate_.SetFileContents("foo/bar/Foo.aidl", R"( package foo.bar; import foo.bar.Bar; import foo.bar.Enum; parcelable Foo { int n = Bar.A + 1; int[] ns = {1, Bar.A, Bar.B + 1}; Enum e = Enum.A; Enum[] es = {Enum.A, Enum.B}; } )"); io_delegate_.SetFileContents("foo/bar/Bar.aidl", R"( package foo.bar; parcelable Bar { const int A = 1; const int B = A + 1; } )"); io_delegate_.SetFileContents("foo/bar/Enum.aidl", R"( package foo.bar; enum Enum { A, B = A + 2, } )"); vector args = {"aidl", "--dumpapi", "--out=dump", "--include=.", "foo/bar/Foo.aidl", "foo/bar/Bar.aidl", "foo/bar/Enum.aidl"}; ASSERT_TRUE(dump_api(Options::From(args), io_delegate_)); string actual; EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/Foo.aidl", &actual)); EXPECT_EQ(string(kPreamble).append(R"(package foo.bar; parcelable Foo { int n = (foo.bar.Bar.A + 1) /* 2 */; int[] ns = {1, foo.bar.Bar.A /* 1 */, (foo.bar.Bar.B + 1) /* 3 */}; foo.bar.Enum e = foo.bar.Enum.A; foo.bar.Enum[] es = {foo.bar.Enum.A, foo.bar.Enum.B}; } )"), actual); EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/Bar.aidl", &actual)); EXPECT_EQ(string(kPreamble).append(R"(package foo.bar; parcelable Bar { const int A = 1; const int B = (A + 1) /* 2 */; } )"), actual); EXPECT_TRUE(io_delegate_.GetWrittenContents("dump/foo/bar/Enum.aidl", &actual)); EXPECT_EQ(string(kPreamble).append(R"(package foo.bar; enum Enum { A, B = (A + 2) /* 2 */, } )"), actual); } TEST_F(AidlTest, EnumDefaultShouldBeEnumerators) { io_delegate_.SetFileContents("a/p/Enum.aidl", "package p; enum Enum { FOO = 1, BAR = 2}"); io_delegate_.SetFileContents("a/p/Foo.aidl", R"( package p; import p.Enum; parcelable Foo { Enum e = Enum.FOO | Enum.BAR; })"); CaptureStderr(); auto options = Options::From("aidl -I a --lang java -o out -h out a/p/Foo.aidl"); EXPECT_FALSE(compile_aidl(options, io_delegate_)); auto err = GetCapturedStderr(); EXPECT_EQ("ERROR: a/p/Foo.aidl:5.11-20: Invalid value (Enum.FOO|Enum.BAR) for enum p.Enum\n", err); } TEST_F(AidlTest, EnumDefaultShouldBeEnumerators_RejectsNumericValue) { io_delegate_.SetFileContents("a/p/Enum.aidl", "package p; enum Enum { FOO = 1, BAR = 2}"); io_delegate_.SetFileContents("a/p/Foo.aidl", R"( package p; import p.Enum; parcelable Foo { Enum e = 1; })"); CaptureStderr(); auto options = Options::From("aidl -I a --lang java -o out -h out a/p/Foo.aidl"); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("Invalid value (1) for enum p.Enum")); } TEST_P(AidlTest, DefaultWithEmptyArray) { io_delegate_.SetFileContents("a/p/Foo.aidl", "package p; parcelable Foo { p.Bar[] bars = {}; }"); io_delegate_.SetFileContents("a/p/Bar.aidl", "package p; parcelable Bar { }"); CaptureStderr(); auto options = Options::From("aidl -I a --lang " + to_string(GetLanguage()) + " -o out -h out a/p/Foo.aidl"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); auto err = GetCapturedStderr(); EXPECT_EQ("", err); } TEST_P(AidlTest, RejectRefsInAnnotation) { io_delegate_.SetFileContents("a/p/IFoo.aidl", "package p; interface IFoo {\n" " const String ANNOTATION = \"@Annotation\";\n" " @JavaPassthrough(annotation=ANNOTATION) void foo();\n" "}"); CaptureStderr(); auto options = Options::From("aidl -I a --lang " + to_string(GetLanguage()) + " -o out -h out a/p/IFoo.aidl"); EXPECT_FALSE(compile_aidl(options, io_delegate_)); auto err = GetCapturedStderr(); EXPECT_EQ( "ERROR: a/p/IFoo.aidl:3.31-41: Value must be a constant expression but contains reference to " "ANNOTATION.\n", err); } TEST_F(AidlTest, DefaultWithEnumValues) { io_delegate_.SetFileContents( "a/p/Foo.aidl", "package p; import p.Bar; parcelable Foo { Bar[] bars = { Bar.FOO, Bar.FOO }; }"); io_delegate_.SetFileContents("a/p/Bar.aidl", "package p; enum Bar { FOO, BAR }"); CaptureStderr(); auto options = Options::From("aidl -I a --lang ndk -o out -h out a/p/Foo.aidl"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); auto err = GetCapturedStderr(); EXPECT_EQ("", err); string code; EXPECT_TRUE(io_delegate_.GetWrittenContents("out/aidl/p/Foo.h", &code)); EXPECT_THAT( code, testing::HasSubstr( "std::vector<::aidl::p::Bar> bars = {::aidl::p::Bar::FOO, ::aidl::p::Bar::FOO};")); } TEST_F(AidlTest, RejectsCircularReferencingEnumerators) { io_delegate_.SetFileContents("a/p/Foo.aidl", "package p; enum Foo { A = B, B }"); CaptureStderr(); auto options = Options::From("aidl -I a --lang ndk -o out -h out a/p/Foo.aidl"); EXPECT_FALSE(compile_aidl(options, io_delegate_)); auto err = GetCapturedStderr(); EXPECT_EQ("ERROR: a/p/Foo.aidl:1.26-28: Found a circular reference: B -> A -> B\n", err); } TEST_F(AidlTest, RejectsCircularReferencingConsts) { io_delegate_.SetFileContents("a/p/Foo.aidl", "package p; parcelable Foo { const int A = A + 1; }"); CaptureStderr(); auto options = Options::From("aidl -I a --lang ndk -o out -h out a/p/Foo.aidl"); EXPECT_FALSE(compile_aidl(options, io_delegate_)); auto err = GetCapturedStderr(); EXPECT_EQ("ERROR: a/p/Foo.aidl:1.42-44: Found a circular reference: A -> A\n", err); } TEST_F(AidlTest, RecursiveReferences) { io_delegate_.SetFileContents("a/p/Foo.aidl", "package p; parcelable Foo { const int A = p.Bar.A + 1; }"); io_delegate_.SetFileContents("a/p/Bar.aidl", "package p; parcelable Bar { const int A = p.Baz.A + 1; }"); io_delegate_.SetFileContents("a/p/Baz.aidl", "package p; parcelable Baz { const int A = 1; }"); CaptureStderr(); auto options = Options::From("aidl -I a --lang ndk -o out -h out a/p/Foo.aidl"); EXPECT_TRUE(compile_aidl(options, io_delegate_)); EXPECT_EQ("", GetCapturedStderr()); } TEST_P(AidlTest, CircularReferenceWithFullyQualified) { io_delegate_.SetFileContents("Foo.aidl", "enum Foo { A = Foo.A }"); auto options = Options::From("aidl --lang " + to_string(GetLanguage()) + " -I . -o out -h out Foo.aidl"); const string err = "ERROR: Foo.aidl:1.15-21: Found a circular reference: Foo.A -> Foo.A\n"; CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_EQ(err, GetCapturedStderr()); } TEST_P(AidlTest, ConstRefsCanPointToTheSameValue) { io_delegate_.SetFileContents("Foo.aidl", "enum Foo { A = 0 }"); // this demonstrates the case that "Foo.A" const-ref node is visited twice by B and C. io_delegate_.SetFileContents("Bar.aidl", "enum Bar { A = Foo.A, B = A, C = A }"); auto options = Options::From("aidl --lang " + to_string(GetLanguage()) + " -I . -o out -h out Bar.aidl"); CaptureStderr(); EXPECT_TRUE(compile_aidl(options, io_delegate_)); EXPECT_EQ("", GetCapturedStderr()); } TEST_P(AidlTest, UnknownConstReference) { io_delegate_.SetFileContents("Foo.aidl", " parcelable Foo { int field = UNKNOWN_REF; }"); auto options = Options::From("aidl -I . --lang " + to_string(GetLanguage()) + " -o out -h out Foo.aidl"); const string err = "ERROR: Foo.aidl:1.30-42: Can't find UNKNOWN_REF in Foo\n" "ERROR: Foo.aidl:1.30-42: Unknown reference 'UNKNOWN_REF'\n"; CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_EQ(err, GetCapturedStderr()); } TEST_P(AidlTest, JavaCompatibleBuiltinTypes) { string contents = R"( import android.os.IBinder; import android.os.IInterface; interface IFoo {} )"; EXPECT_NE(nullptr, Parse("IFoo.aidl", contents, typenames_, GetLanguage())); } TEST_P(AidlTest, WarningInterfaceName) { io_delegate_.SetFileContents("p/Foo.aidl", "package p; interface Foo {}"); auto options = Options::From("aidl -I . --lang " + to_string(GetLanguage()) + " -Winterface-name -o out -h out p/Foo.aidl"); CaptureStderr(); EXPECT_TRUE(compile_aidl(options, io_delegate_)); EXPECT_EQ( "WARNING: p/Foo.aidl:1.11-21: Interface names should start with I. [-Winterface-name]\n", GetCapturedStderr()); } TEST_P(AidlTest, ErrorInterfaceName) { io_delegate_.SetFileContents("p/Foo.aidl", "package p; interface Foo {}"); auto options = Options::From("aidl -I . --lang " + to_string(GetLanguage()) + " -Winterface-name -Werror -o out -h out p/Foo.aidl"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_EQ("ERROR: p/Foo.aidl:1.11-21: Interface names should start with I. [-Winterface-name]\n", GetCapturedStderr()); } TEST_F(AidlTest, RejectsIncorrectOutputFilePathOnLegacyCppInput) { const std::string input_file = "base/p/q/IFoo.aidl"; const std::string header_dir = "out/"; const std::string output_file = "out/base/p/q/IFoo.cpp"; io_delegate_.SetFileContents(input_file, "package p.q; interface IFoo {}"); auto options = Options::From({"aidl-cpp", "-I base", input_file, header_dir, output_file}); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_THAT( GetCapturedStderr(), testing::StartsWith( "ERROR: base/p/q/IFoo.aidl:1.13-23: Output file is expected to be at out/p/q/IFoo.cpp, " "but is out/base/p/q/IFoo.cpp.")); } TEST_F(AidlTest, FormatCommentsForJava) { using android::aidl::FormatCommentsForJava; struct TestCase { vector comments; string formatted; }; vector testcases = { {{}, ""}, {{{"// line comments\n"}}, "// line comments\n"}, {{{"// @hide \n"}}, "// @hide \n"}, // Transform the last block comment as Javadoc. {{{"/*\n" " * Hello, world!\n" " */"}}, "/** Hello, world! */\n"}, {{{"/* @hide */"}}, "/** @hide */\n"}, {{{"/**\n" " @param foo ...\n" "*/"}}, "/** @param foo ... */\n"}, {{{"/* @hide */"}, {"/* @hide */"}}, "/* @hide */\n/** @hide */\n"}, {{{"/* @deprecated first */"}, {"/* @deprecated second */"}}, "/* @deprecated first */\n/** @deprecated second */\n"}, {{{"/* @deprecated */"}, {"/** @param foo */"}}, "/* @deprecated */\n/** @param foo */\n"}, // Line comments are printed as they are {{{"/* @deprecated */"}, {"// line comments\n"}}, "/* @deprecated */\n// line comments\n"}, }; for (const auto& [input, formatted] : testcases) { EXPECT_EQ(formatted, FormatCommentsForJava(input)); } } TEST_F(AidlTest, SuppressWarningsIsNotForArgs) { io_delegate_.SetFileContents( "IFoo.aidl", "interface IFoo {\n" " void foo(in @SuppressWarnings(value={\"inout-parameter\"}) int x);\n" "}"); auto options = Options::From("aidl -I . --lang=java IFoo.aidl"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("@SuppressWarnings is not available")); } TEST_F(AidlTest, VoidCantBeUsedInMethodParameterType) { io_delegate_.SetFileContents("p/IFoo.aidl", "package p; interface IFoo{ void j(void n);}"); auto options = Options::From("aidl -I . --lang=java -o out p/IFoo.aidl"); CaptureStderr(); EXPECT_FALSE(compile_aidl(options, io_delegate_)); EXPECT_THAT(GetCapturedStderr(), HasSubstr("'void' is an invalid type for the parameter 'n'")); } TEST_F(AidlTest, InterfaceVectorIsAvailableAfterTiramisu) { io_delegate_.SetFileContents("p/IFoo.aidl", "package p;\n" "interface IFoo{\n" " void foo(in IFoo[] n);\n" " void bar(in List n);\n" "}"); CaptureStderr(); EXPECT_FALSE( compile_aidl(Options::From("aidl -I . --lang=java --min_sdk_version 30 -o out p/IFoo.aidl"), io_delegate_)); auto captured_stderr = GetCapturedStderr(); EXPECT_THAT(captured_stderr, HasSubstr("Array of interfaces is available since")); EXPECT_THAT(captured_stderr, HasSubstr("List of interfaces is available since")); CaptureStderr(); EXPECT_TRUE(compile_aidl( Options::From("aidl -I . --lang=java --min_sdk_version Tiramisu -o out p/IFoo.aidl"), io_delegate_)); EXPECT_EQ(GetCapturedStderr(), ""); } TEST_F(AidlTest, RustNameOf_PfdFixedArray) { auto pfd = typenames_.MakeResolvedType(AIDL_LOCATION_HERE, "ParcelFileDescriptor", false); ASSERT_TRUE(pfd->MakeArray(FixedSizeArray{ std::unique_ptr(AidlConstantValue::Integral(AIDL_LOCATION_HERE, "2"))})); ASSERT_TRUE(pfd->MakeArray(FixedSizeArray{ std::unique_ptr(AidlConstantValue::Integral(AIDL_LOCATION_HERE, "3"))})); EXPECT_EQ( rust::RustNameOf(*pfd, typenames_, rust::StorageMode::PARCELABLE_FIELD, rust::Lifetime::NONE), "[[Option; 3]; 2]"); EXPECT_EQ( rust::RustNameOf(*pfd, typenames_, rust::StorageMode::DEFAULT_VALUE, rust::Lifetime::NONE), "[[Option; 3]; 2]"); EXPECT_EQ( rust::RustNameOf(*pfd, typenames_, rust::StorageMode::IN_ARGUMENT, rust::Lifetime::NONE), "&[[binder::ParcelFileDescriptor; 3]; 2]"); EXPECT_EQ(rust::RustNameOf(*pfd, typenames_, rust::StorageMode::VALUE, rust::Lifetime::NONE), "[[binder::ParcelFileDescriptor; 3]; 2]"); } TEST_F(AidlTest, RustNameOf_PfdDynamicArray) { auto pfd = typenames_.MakeResolvedType(AIDL_LOCATION_HERE, "ParcelFileDescriptor", true); EXPECT_EQ( rust::RustNameOf(*pfd, typenames_, rust::StorageMode::PARCELABLE_FIELD, rust::Lifetime::NONE), "Vec"); EXPECT_EQ( rust::RustNameOf(*pfd, typenames_, rust::StorageMode::DEFAULT_VALUE, rust::Lifetime::NONE), "Vec>"); // we use UNSIZED_ARGUMENT mode for input argument of dynamic array EXPECT_EQ( rust::RustNameOf(*pfd, typenames_, rust::StorageMode::UNSIZED_ARGUMENT, rust::Lifetime::NONE), "&[binder::ParcelFileDescriptor]"); EXPECT_EQ(rust::RustNameOf(*pfd, typenames_, rust::StorageMode::VALUE, rust::Lifetime::NONE), "Vec"); } struct TypeParam { string kind; string literal; }; const TypeParam kTypeParams[] = { {"primitive", "int"}, {"primitiveArray", "int[]"}, {"primitiveFixedArray", "int[3]"}, {"String", "String"}, {"StringArray", "String[]"}, {"IBinder", "IBinder"}, {"ParcelFileDescriptor", "ParcelFileDescriptor"}, {"parcelable", "a.Foo"}, {"enum", "a.Enum"}, {"union", "a.Union"}, {"interface", "a.IBar"}, }; struct ExpectedResult { string expected_error; string expected_error_for_nullable; }; const std::map kListSupportExpectations = { {"cpp_primitive", {"A generic type cannot", "A generic type cannot"}}, {"java_primitive", {"A generic type cannot", "A generic type cannot"}}, {"ndk_primitive", {"A generic type cannot", "A generic type cannot"}}, {"rust_primitive", {"A generic type cannot", "A generic type cannot"}}, {"cpp_primitiveArray", {"List of arrays is not supported", "List of arrays is not supported"}}, {"java_primitiveArray", {"List of arrays is not supported", "List of arrays is not supported"}}, {"ndk_primitiveArray", {"List of arrays is not supported", "List of arrays is not supported"}}, {"rust_primitiveArray", {"List of arrays is not supported", "List of arrays is not supported"}}, {"cpp_primitiveFixedArray", {"List of arrays is not supported", "List of arrays is not supported"}}, {"java_primitiveFixedArray", {"List of arrays is not supported", "List of arrays is not supported"}}, {"ndk_primitiveFixedArray", {"List of arrays is not supported", "List of arrays is not supported"}}, {"rust_primitiveFixedArray", {"List of arrays is not supported", "List of arrays is not supported"}}, {"cpp_String", {"", ""}}, {"java_String", {"", ""}}, {"ndk_String", {"", ""}}, {"rust_String", {"", ""}}, {"cpp_StringArray", {"List of arrays is not supported", "List of arrays is not supported"}}, {"java_StringArray", {"List of arrays is not supported", "List of arrays is not supported"}}, {"ndk_StringArray", {"List of arrays is not supported", "List of arrays is not supported"}}, {"rust_StringArray", {"List of arrays is not supported", "List of arrays is not supported"}}, {"cpp_IBinder", {"", ""}}, {"java_IBinder", {"", ""}}, {"ndk_IBinder", {"", ""}}, {"rust_IBinder", {"", ""}}, {"cpp_ParcelFileDescriptor", {"", ""}}, {"java_ParcelFileDescriptor", {"", ""}}, {"ndk_ParcelFileDescriptor", {"", ""}}, {"rust_ParcelFileDescriptor", {"", ""}}, {"cpp_interface", {"", ""}}, {"java_interface", {"", ""}}, {"ndk_interface", {"", ""}}, {"rust_interface", {"", ""}}, {"cpp_parcelable", {"", ""}}, {"java_parcelable", {"", ""}}, {"ndk_parcelable", {"", ""}}, {"rust_parcelable", {"", ""}}, {"cpp_enum", {"A generic type cannot", "A generic type cannot"}}, {"java_enum", {"A generic type cannot", "A generic type cannot"}}, {"ndk_enum", {"A generic type cannot", "A generic type cannot"}}, {"rust_enum", {"A generic type cannot", "A generic type cannot"}}, {"cpp_union", {"", ""}}, {"java_union", {"", ""}}, {"ndk_union", {"", ""}}, {"rust_union", {"", ""}}, }; const std::map kArraySupportExpectations = { {"cpp_primitive", {"", ""}}, {"java_primitive", {"", ""}}, {"ndk_primitive", {"", ""}}, {"rust_primitive", {"", ""}}, {"cpp_primitiveArray", {"Multi-dimensional arrays must be fixed size.", "Multi-dimensional arrays must be fixed size."}}, {"java_primitiveArray", {"Multi-dimensional arrays must be fixed size.", "Multi-dimensional arrays must be fixed size."}}, {"ndk_primitiveArray", {"Multi-dimensional arrays must be fixed size.", "Multi-dimensional arrays must be fixed size."}}, {"rust_primitiveArray", {"Multi-dimensional arrays must be fixed size.", "Multi-dimensional arrays must be fixed size."}}, {"cpp_primitiveFixedArray", {"Multi-dimensional arrays must be fixed size.", "Multi-dimensional arrays must be fixed size."}}, {"java_primitiveFixedArray", {"Multi-dimensional arrays must be fixed size.", "Multi-dimensional arrays must be fixed size."}}, {"ndk_primitiveFixedArray", {"Multi-dimensional arrays must be fixed size.", "Multi-dimensional arrays must be fixed size."}}, {"rust_primitiveFixedArray", {"Multi-dimensional arrays must be fixed size.", "Multi-dimensional arrays must be fixed size."}}, {"cpp_String", {"", ""}}, {"java_String", {"", ""}}, {"ndk_String", {"", ""}}, {"rust_String", {"", ""}}, {"cpp_StringArray", {"Multi-dimensional arrays must be fixed size.", "Multi-dimensional arrays must be fixed size."}}, {"java_StringArray", {"Multi-dimensional arrays must be fixed size.", "Multi-dimensional arrays must be fixed size."}}, {"ndk_StringArray", {"Multi-dimensional arrays must be fixed size.", "Multi-dimensional arrays must be fixed size."}}, {"rust_StringArray", {"Multi-dimensional arrays must be fixed size.", "Multi-dimensional arrays must be fixed size."}}, {"cpp_IBinder", {"", ""}}, {"java_IBinder", {"", ""}}, {"ndk_IBinder", {"", ""}}, {"rust_IBinder", {"", ""}}, {"cpp_ParcelFileDescriptor", {"", ""}}, {"java_ParcelFileDescriptor", {"", ""}}, {"ndk_ParcelFileDescriptor", {"", ""}}, {"rust_ParcelFileDescriptor", {"", ""}}, {"cpp_interface", {"", ""}}, {"java_interface", {"", ""}}, {"ndk_interface", {"", ""}}, {"rust_interface", {"", ""}}, {"cpp_parcelable", {"", ""}}, {"java_parcelable", {"", ""}}, {"ndk_parcelable", {"", ""}}, {"rust_parcelable", {"", ""}}, {"cpp_enum", {"", ""}}, {"java_enum", {"", ""}}, {"ndk_enum", {"", ""}}, {"rust_enum", {"", ""}}, {"cpp_union", {"", ""}}, {"java_union", {"", ""}}, {"ndk_union", {"", ""}}, {"rust_union", {"", ""}}, }; const std::map kFieldSupportExpectations = { {"cpp_primitive", {"", "cannot get nullable annotation"}}, {"java_primitive", {"", "cannot get nullable annotation"}}, {"ndk_primitive", {"", "cannot get nullable annotation"}}, {"rust_primitive", {"", "cannot get nullable annotation"}}, {"cpp_primitiveArray", {"", ""}}, {"java_primitiveArray", {"", ""}}, {"ndk_primitiveArray", {"", ""}}, {"rust_primitiveArray", {"", ""}}, {"cpp_primitiveFixedArray", {"", ""}}, {"java_primitiveFixedArray", {"", ""}}, {"ndk_primitiveFixedArray", {"", ""}}, {"rust_primitiveFixedArray", {"", ""}}, {"cpp_String", {"", ""}}, {"java_String", {"", ""}}, {"ndk_String", {"", ""}}, {"rust_String", {"", ""}}, {"cpp_StringArray", {"", ""}}, {"java_StringArray", {"", ""}}, {"ndk_StringArray", {"", ""}}, {"rust_StringArray", {"", ""}}, {"cpp_IBinder", {"", ""}}, {"java_IBinder", {"", ""}}, {"ndk_IBinder", {"", ""}}, {"rust_IBinder", {"", ""}}, {"cpp_ParcelFileDescriptor", {"", ""}}, {"java_ParcelFileDescriptor", {"", ""}}, {"ndk_ParcelFileDescriptor", {"", ""}}, {"rust_ParcelFileDescriptor", {"", ""}}, {"cpp_interface", {"", ""}}, {"java_interface", {"", ""}}, {"ndk_interface", {"", ""}}, {"rust_interface", {"", ""}}, {"cpp_parcelable", {"", ""}}, {"java_parcelable", {"", ""}}, {"ndk_parcelable", {"", ""}}, {"rust_parcelable", {"", ""}}, {"cpp_enum", {"", "cannot get nullable annotation"}}, {"java_enum", {"", "cannot get nullable annotation"}}, {"ndk_enum", {"", "cannot get nullable annotation"}}, {"rust_enum", {"", "cannot get nullable annotation"}}, {"cpp_union", {"", ""}}, {"java_union", {"", ""}}, {"ndk_union", {"", ""}}, {"rust_union", {"", ""}}, }; class AidlTypeParamTest : public testing::TestWithParam> { public: void Run(const std::string& generic_type_decl, const std::map& expectations) { const auto& param = GetParam(); const auto& lang = to_string(std::get<0>(param)); const auto& kind = std::get<1>(param).kind; const bool nullable = std::get<2>(param); FakeIoDelegate io; io.SetFileContents("a/IBar.aidl", "package a; interface IBar { }"); io.SetFileContents("a/Enum.aidl", "package a; enum Enum { A }"); io.SetFileContents("a/Union.aidl", "package a; union Union { int a; }"); io.SetFileContents("a/Foo.aidl", "package a; parcelable Foo { int a; }"); std::string decl = fmt::format(fmt::runtime(generic_type_decl), std::get<1>(param).literal); if (nullable) { decl = "@nullable " + decl; } io.SetFileContents("a/Target.aidl", "package a; parcelable Target { " + decl + " f; }"); const auto options = Options::From(fmt::format( "aidl -I . --min_sdk_version current --lang={} a/Target.aidl -o out -h out", lang)); CaptureStderr(); compile_aidl(options, io); auto it = expectations.find(lang + "_" + kind); ASSERT_TRUE(it != expectations.end()) << "missing expectation for " << lang << "_" << kind; const string err = GetCapturedStderr(); const string expected_error = nullable ? it->second.expected_error_for_nullable : it->second.expected_error; if (expected_error.empty()) { EXPECT_EQ("", err); } else { EXPECT_THAT(err, testing::HasSubstr(expected_error)); } } }; INSTANTIATE_TEST_SUITE_P( AidlTestSuite, AidlTypeParamTest, testing::Combine(testing::Values(Options::Language::CPP, Options::Language::JAVA, Options::Language::NDK, Options::Language::RUST), testing::ValuesIn(kTypeParams), testing::Values(true, false)), [](const testing::TestParamInfo>& info) { string name = to_string(std::get<0>(info.param)) + "_" + std::get<1>(info.param).kind; if (std::get<2>(info.param)) { name += "_nullable"; } return name; }); TEST_P(AidlTypeParamTest, ListSupportedTypes) { Run("List<{}>", kListSupportExpectations); } TEST_P(AidlTypeParamTest, ArraySupportedTypes) { Run("{}[]", kArraySupportExpectations); } TEST_P(AidlTypeParamTest, ParcelableFieldTypes) { Run("{}", kFieldSupportExpectations); } } // namespace aidl } // namespace android ./PaxHeaders.X/analyzer_0100644 0000000 0000000 00000000034 15172120304 014203 xustar000000000 0000000 28 mtime=1776853188.3080000 analyzer/0040755 0000000 0000000 00000000000 15172120304 011430 5ustar000000000 0000000 ./PaxHeaders.X/analyzer_Analyzer.cpp0100644 0000000 0000000 00000000034 15172120304 016472 xustar000000000 0000000 28 mtime=1776853188.3080000 analyzer/Analyzer.cpp0100644 0000000 0000000 00000003265 15172120304 013724 0ustar000000000 0000000 /* * Copyright (C) 2022 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 "include/Analyzer.h" using std::unique_ptr; using std::unordered_map; namespace android { namespace aidl { using analyzeFn = android::status_t (*)(uint32_t _aidl_code, const android::Parcel& _aidl_data, const android::Parcel& _aidl_reply); Analyzer::Analyzer(const std::string& package, const std::string& interface, analyzeFn function) : mPackageName(package), mInterfaceName(interface), mAnalyzeFunction(function) {} const std::string& Analyzer::getPackageName() const { return mPackageName; } const std::string& Analyzer::getInterfaceName() const { return mInterfaceName; } const analyzeFn& Analyzer::getAnalyzeFunction() const { return mAnalyzeFunction; } unordered_map>& Analyzer::getAnalyzers() { static unordered_map> gAnalyzers; return gAnalyzers; } void Analyzer::installAnalyzer(std::unique_ptr install) { getAnalyzers().insert_or_assign(install->getPackageName(), std::move(install)); } } // namespace aidl } // namespace android ./PaxHeaders.X/analyzer_analyzerMain.cpp0100644 0000000 0000000 00000000034 15172120304 017337 xustar000000000 0000000 28 mtime=1776853188.3080000 analyzer/analyzerMain.cpp0100644 0000000 0000000 00000035306 15172120304 014572 0ustar000000000 0000000 /* * Copyright (C) 2022 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 #include #include #include #include #include #include #include #include #include #include "include/Analyzer.h" using android::IBinder; using android::NO_ERROR; using android::sp; using android::status_t; using android::String16; using android::String8; using android::aidl::Analyzer; using android::base::unique_fd; using android::binder::debug::RecordedTransaction; using std::string; namespace { static std::atomic_uint gCtrlCCount = 0; static constexpr unsigned kCtrlCLimit = 3; static const char kStandardRecordingPath[] = "/data/local/recordings/"; string getRecordingPath(const string& serviceName) { // Service names may contain '/', replace them with '.' to avoid interpreting as path string filename = serviceName; std::replace(filename.begin(), filename.end(), '/', '.'); return kStandardRecordingPath + filename; } status_t startRecording(const string& serviceName) { sp binder = android::defaultServiceManager()->checkService(String16(serviceName.c_str())); if (binder == nullptr) { return android::BAD_VALUE; } auto filePath = getRecordingPath(serviceName); if (auto mkdir_return = mkdir(kStandardRecordingPath, 0666); mkdir_return != 0 && errno != EEXIST) { std::cout << "Failed to create recordings directory.\n"; return android::NO_ERROR; } int openFlags = O_WRONLY | O_CREAT | O_APPEND | O_CLOEXEC | O_BINARY; unique_fd fd(open(filePath.c_str(), openFlags, 0666)); if (!fd.ok()) { std::cout << "Failed to open file for recording with error: " << strerror(errno) << '\n'; return android::BAD_VALUE; } // TODO (b/245804633): this still requires setenforce 0, but nothing above does if (status_t err = binder->remoteBinder()->startRecordingBinder(fd); err != android::NO_ERROR) { auto checkSE = std::ifstream("/sys/fs/selinux/enforce"); bool recommendSetenforce = false; if ((checkSE.rdstate() & std::ifstream::failbit) != 0) { std::cout << "Failed to determine selinux state."; recommendSetenforce = true; } else { char seState = checkSE.get(); if (checkSE.good()) { if (seState == '1') { std::cout << "SELinux must be permissive."; recommendSetenforce = true; } else if (seState == '0') { std::cout << "SELinux is permissive. Failing for some other reason.\n"; } } else { std::cout << "Failed to determine SELinux state."; recommendSetenforce = true; } } if (recommendSetenforce) { std::cout << " Try running:\n\n setenforce 0\n\n"; } std::cout << "Failed to start recording with error: " << android::statusToString(err) << '\n'; return err; } else { std::cout << "Recording started successfully.\n"; return android::NO_ERROR; } } status_t stopRecording(const string& serviceName) { sp binder = android::defaultServiceManager()->checkService(String16(serviceName.c_str())); if (binder == nullptr) { return android::BAD_VALUE; } if (status_t err = binder->remoteBinder()->stopRecordingBinder(); err != NO_ERROR) { std::cout << "Failed to stop recording with error: " << err << '\n'; return err; } std::cout << "Recording stopped successfully.\n"; return NO_ERROR; } void printTransaction(const RecordedTransaction& transaction) { auto& analyzers = Analyzer::getAnalyzers(); auto analyzer = analyzers.find(transaction.getInterfaceName()); if (analyzer != analyzers.end()) { (analyzer->second) ->getAnalyzeFunction()(transaction.getCode(), transaction.getDataParcel(), transaction.getReplyParcel()); } else { std::cout << "No analyzer:"; std::cout << " interface: " << transaction.getInterfaceName() << "\n"; std::cout << " code: " << transaction.getCode() << "\n"; std::cout << " data: " << transaction.getDataParcel().dataSize() << " bytes\n"; std::cout << " reply: " << transaction.getReplyParcel().dataSize() << " bytes\n"; } std::cout << " status: " << transaction.getReturnedStatus() << "\n\n"; } status_t inspectRecording(const string& path) { auto& analyzers = Analyzer::getAnalyzers(); unique_fd fd(open(path.c_str(), O_RDONLY)); if (!fd.ok()) { std::cout << "Failed to open recording file with error: " << strerror(errno) << '\n'; return android::BAD_VALUE; } int i = 1; while (auto transaction = RecordedTransaction::fromFile(fd)) { std::cout << "Transaction " << i << ":\n"; printTransaction(transaction.value()); i++; } return NO_ERROR; } void incrementCtrlCCount(int signum) { if (++gCtrlCCount > kCtrlCLimit) { std::cout << "Ctrl+C multiple times, but could not quit application. If recording still running, you " "might stop it manually.\n"; exit(signum); } } status_t listenToFile(const string& serviceName) { auto filePath = getRecordingPath(serviceName); unique_fd listenFd(open(filePath.c_str(), O_RDONLY)); if (!listenFd.ok()) { std::cout << "Failed to open listening file with error: " << strerror(errno) << '\n'; return android::BAD_VALUE; } auto& analyzers = Analyzer::getAnalyzers(); signal(SIGINT, incrementCtrlCCount); std::cout << "Starting to listen:\n"; int i = 1; while (gCtrlCCount == 0) { auto transaction = RecordedTransaction::fromFile(listenFd); if (!transaction) { sleep(1); continue; } std::cout << "Transaction " << i << ":\n"; printTransaction(transaction.value()); i++; } return NO_ERROR; } status_t replayFile(const sp& binder, const string& path) { auto& analyzers = Analyzer::getAnalyzers(); unique_fd fd(open(path.c_str(), O_RDONLY)); if (!fd.ok()) { std::cout << "Failed to open recording file with error: " << strerror(errno) << '\n'; return android::BAD_VALUE; } int failureCount = 0; int i = 1; while (auto transaction = RecordedTransaction::fromFile(fd)) { std::cout << "Replaying Transaction " << i << ":\n"; printTransaction(transaction.value()); android::Parcel send, reply; send.setData(transaction->getDataParcel().data(), transaction->getDataParcel().dataSize()); android::status_t status = binder->remoteBinder()->transact(transaction->getCode(), send, &reply, transaction->getFlags()); if (status != transaction->getReturnedStatus()) { std::cout << "Failure: Expected status " << transaction->getReturnedStatus() << " but received status " << status << "\n\n"; failureCount++; } else { std::cout << "Transaction replayed correctly." << "\n\n"; } i++; } std::cout << i << " transactions replayed.\n"; if (failureCount > 0) { std::cout << failureCount << " transactions had unexpected status. See logs for details.\n"; return android::UNKNOWN_ERROR; } else { return NO_ERROR; } } status_t listAvailableInterfaces(int, char**) { auto& analyzers = Analyzer::getAnalyzers(); std::cout << "Available Interfaces (" << analyzers.size() << "):\n"; for (auto a = analyzers.begin(); a != analyzers.end(); a++) { std::cout << " " << a->second->getInterfaceName() << '\n'; } return NO_ERROR; } struct AnalyzerCommand { std::function command; std::string overview; std::string compactArguments; std::string helpDetail; }; status_t helpCommandEntryPoint(int argc, char* argv[]); const AnalyzerCommand helpCommand = {helpCommandEntryPoint, "Show help information.", "", ""}; const AnalyzerCommand listCommand = {listAvailableInterfaces, "Prints a list of available interfaces.", "", ""}; status_t startRecordingAllBinders() { auto services = android::defaultServiceManager()->listServices(); for (auto service : services) { std::string serviceName = String8(service.c_str()).c_str(); // Print failed service name. Don't exit early because it would leave the previous successful // services recording. if (status_t result = startRecording(serviceName); result != NO_ERROR) { std::cout << "Failed to start binder recording on service : " << service << std::endl; } } return NO_ERROR; } status_t startCommandEntryPoint(int argc, char* argv[]) { if (argc != 3) { helpCommandEntryPoint(argc, argv); return android::BAD_VALUE; } string startOption = argv[2]; if (startOption == "--all") { return startRecordingAllBinders(); } return startRecording(startOption); } const AnalyzerCommand startCommand = {startCommandEntryPoint, "Start recording Binder transactions from a given service. " "Use --all to start recoding all binders.", ", --all", " \tService to record. See 'dumpsys -l'"}; status_t stopRecordingAllBinders() { auto services = android::defaultServiceManager()->listServices(); for (auto service : services) { std::string serviceName = String8(service.c_str()).c_str(); // Print failed service name. Don't exit early because it would leave the other recordings on. if (status_t result = stopRecording(serviceName); result != NO_ERROR) { std::cout << "Failed to stop binder recording on service : " << service << std::endl; } } return NO_ERROR; } status_t stopCommandEntryPoint(int argc, char* argv[]) { if (argc != 3) { helpCommandEntryPoint(argc, argv); return android::BAD_VALUE; } string stopOption = argv[2]; if (stopOption == "--all") { stopRecordingAllBinders(); } return stopRecording(stopOption); } const AnalyzerCommand stopCommand = { stopCommandEntryPoint, "Stops recording Binder transactions from a given process. (See 'start') Use --all to stop " "recoding all binders", ", --all", " \tService to stop recording; argument to previous 'start' command."}; status_t inspectCommandEntryPoint(int argc, char* argv[]) { if (argc != 3) { helpCommandEntryPoint(argc, argv); return android::BAD_VALUE; } std::string path = kStandardRecordingPath + string(argv[2]); return inspectRecording(path); } const AnalyzerCommand inspectCommand = { inspectCommandEntryPoint, "Writes the binder transactions in to stdout in a human-friendly format.", "", " \tA recording in /data/local/recordings/, and the name of the service"}; status_t listenCommandEntryPoint(int argc, char* argv[]) { if (argc != 3) { helpCommandEntryPoint(argc, argv); return android::BAD_VALUE; } string serviceName = argv[2]; if (status_t startErr = startRecording(serviceName); startErr != NO_ERROR) { return startErr; } status_t listenStatus = listenToFile(serviceName); if (status_t stopErr = stopRecording(serviceName); stopErr != NO_ERROR) { return stopErr; } return listenStatus; } const AnalyzerCommand listenCommand = { listenCommandEntryPoint, "Starts recording binder transactions in and writes transactions to " "stdout.", "", " \t?\n"}; int replayFunction(int argc, char* argv[]) { if (argc != 4) { return helpCommandEntryPoint(argc, argv); } sp binder = android::defaultServiceManager()->checkService(String16(argv[2])); std::string path = kStandardRecordingPath + string(argv[3]); return replayFile(binder, path); } const AnalyzerCommand replayCommand = { replayFunction, "No overview", " ", " \t?\n" " \tThe name of a file in /data/local/recordings/"}; auto& commands = *new std::map{ {"start", startCommand}, {"stop", stopCommand}, {"inspect", inspectCommand}, {"listen", listenCommand}, {"replay", replayCommand}, {"help", helpCommand}}; void printGeneralHelp(std::string& toolName) { std::cout << "USAGE: " << toolName << " []\n\n"; std::cout << "COMMANDS:\n"; // Display overview this many characters from the start of a line. // Subtract the length of the command name to calculate padding. const size_t commandOverviewDisplayAlignment = 12; for (const auto& command : commands) { if (command.first == "help") { continue; } std::cout << " " << command.first << std::string(commandOverviewDisplayAlignment - command.first.length(), ' ') << command.second.overview << "\n"; } std::cout << "\n See '" << toolName << " help ' for detailed help.\n"; } status_t helpCommandEntryPoint(int argc, char* argv[]) { std::string toolName = argv[0]; if (argc < 2) { printGeneralHelp(toolName); return 0; } std::string commandName = argv[1]; if (commandName == "help") { if (argc < 3) { printGeneralHelp(toolName); return 0; } commandName = argv[2]; } else { commandName = argv[1]; } auto command = commands.find(commandName); if (command == commands.end()) { std::cout << "Unrecognized command: " << commandName << "\n"; printGeneralHelp(toolName); return -1; } std::cout << "OVERVIEW: " << command->second.overview << "\n\n"; std::cout << "USAGE: " << toolName << " " << commandName << " " << command->second.compactArguments << "\n\n"; std::cout << "ARGUMENTS:\n" << command->second.helpDetail << "\n"; return 0; } } // namespace int main(int argc, char* argv[]) { std::string toolName = argv[0]; auto& analyzers = Analyzer::getAnalyzers(); if (analyzers.size() >= 1) { commands["list"] = listCommand; } if (argc < 2 || (argc >= 2 && ((strcmp(argv[1], "--help") == 0) || (strcmp(argv[1], "-h") == 0)))) { // General help printGeneralHelp(toolName); return 0; } auto command = commands.find(argv[1]); if (command == commands.end()) { std::cout << "Unrecognized command: " << argv[1] << "\n"; printGeneralHelp(toolName); return -1; } return command->second.command(argc, argv); } ./PaxHeaders.X/analyzer_include_0100644 0000000 0000000 00000000034 15172120304 015706 xustar000000000 0000000 28 mtime=1776853188.3090000 analyzer/include/0040755 0000000 0000000 00000000000 15172120304 013053 5ustar000000000 0000000 ./PaxHeaders.X/analyzer_include_Analyzer.h0100644 0000000 0000000 00000000034 15172120304 017642 xustar000000000 0000000 28 mtime=1776853188.3090000 analyzer/include/Analyzer.h0100644 0000000 0000000 00000002730 15172120304 015010 0ustar000000000 0000000 /* * Copyright (C) 2022 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. */ #pragma once #include #include using std::unique_ptr; using std::unordered_map; using analyzeFn = android::status_t (*)(uint32_t _aidl_code, const android::Parcel& _aidl_data, const android::Parcel& _aidl_reply); namespace android { namespace aidl { class Analyzer { public: Analyzer(const std::string& package, const std::string& interface, analyzeFn function); const std::string& getPackageName() const; const std::string& getInterfaceName() const; const analyzeFn& getAnalyzeFunction() const; static unordered_map>& getAnalyzers(); static void installAnalyzer(std::unique_ptr install); private: std::string mPackageName; std::string mInterfaceName; analyzeFn mAnalyzeFunction; }; } // namespace aidl } // namespace android ./PaxHeaders.X/ast_java.cpp0100644 0000000 0000000 00000000034 15172120304 014570 xustar000000000 0000000 28 mtime=1776853188.3090000 ast_java.cpp0100644 0000000 0000000 00000026560 15172120304 012105 0ustar000000000 0000000 /* * Copyright (C) 2015, 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 "ast_java.h" #include "code_writer.h" using std::vector; using std::string; template struct overloaded : Ts... { using Ts::operator()...; }; template overloaded(Ts...)->overloaded; namespace android { namespace aidl { namespace java { std::string AstNode::ToString() { std::string str; Write(CodeWriter::ForString(&str).get()); return str; } void WriteComment(CodeWriter* to, const std::string& comment) { to->Write("%s", comment.c_str()); if (!comment.empty() && comment.back() != '\n') to->Write("\n"); } void WriteModifiers(CodeWriter* to, int mod, int mask) { int m = mod & mask; if (m & OVERRIDE) { to->Write("@Override "); } if ((m & SCOPE_MASK) == PUBLIC) { to->Write("public "); } else if ((m & SCOPE_MASK) == PRIVATE) { to->Write("private "); } else if ((m & SCOPE_MASK) == PROTECTED) { to->Write("protected "); } if (m & STATIC) { to->Write("static "); } if (m & FINAL) { to->Write("final "); } if (m & ABSTRACT) { to->Write("abstract "); } } void WriteArgumentList(CodeWriter* to, const vector>& arguments) { size_t N = arguments.size(); for (size_t i = 0; i < N; i++) { arguments[i]->Write(to); if (i != N - 1) { to->Write(", "); } } } Field::Field(int m, std::shared_ptr v) : ClassElement(), modifiers(m), variable(v) {} void Field::Write(CodeWriter* to) const { WriteComment(to, comment); for (const auto& a : this->annotations) { to->Write("%s\n", a.c_str()); } WriteModifiers(to, this->modifiers, SCOPE_MASK | STATIC | FINAL | OVERRIDE); this->variable->WriteDeclaration(to); if (this->value.length() != 0) { to->Write(" = %s", this->value.c_str()); } to->Write(";\n"); } LiteralExpression::LiteralExpression(const string& v) : value(v) {} void LiteralExpression::Write(CodeWriter* to) const { to->Write("%s", this->value.c_str()); } StringLiteralExpression::StringLiteralExpression(const string& v) : value(v) {} void StringLiteralExpression::Write(CodeWriter* to) const { to->Write("\"%s\"", this->value.c_str()); } Variable::Variable(const string& t, const string& n) : type(t), name(n) {} void Variable::WriteDeclaration(CodeWriter* to) const { for (const auto& a : this->annotations) { to->Write("%s ", a.c_str()); } to->Write("%s %s", this->type.c_str(), this->name.c_str()); } void Variable::Write(CodeWriter* to) const { to->Write("%s", name.c_str()); } FieldVariable::FieldVariable(std::shared_ptr o, const string& n) : receiver(o), name(n) {} FieldVariable::FieldVariable(const string& c, const string& n) : receiver(c), name(n) {} void FieldVariable::Write(CodeWriter* to) const { visit( overloaded{[&](std::shared_ptr e) { e->Write(to); }, [&](const std::string& s) { to->Write("%s", s.c_str()); }, [](std::monostate) {}}, this->receiver); to->Write(".%s", name.c_str()); } LiteralStatement::LiteralStatement(const std::string& value) : value_(value) {} void LiteralStatement::Write(CodeWriter* to) const { to->Write("%s", value_.c_str()); } void StatementBlock::Write(CodeWriter* to) const { to->Write("{\n"); to->Indent(); int N = this->statements.size(); for (int i = 0; i < N; i++) { this->statements[i]->Write(to); } to->Dedent(); to->Write("}\n"); } void StatementBlock::Add(std::shared_ptr statement) { this->statements.push_back(statement); } void StatementBlock::Add(std::shared_ptr expression) { this->statements.push_back(std::make_shared(expression)); } ExpressionStatement::ExpressionStatement(std::shared_ptr e) : expression(e) {} void ExpressionStatement::Write(CodeWriter* to) const { this->expression->Write(to); to->Write(";\n"); } Assignment::Assignment(std::shared_ptr l, std::shared_ptr r) : lvalue(l), rvalue(r) {} Assignment::Assignment(std::shared_ptr l, std::shared_ptr r, string c) : lvalue(l), rvalue(r), cast(c) {} void Assignment::Write(CodeWriter* to) const { this->lvalue->Write(to); to->Write(" = "); if (this->cast) { to->Write("(%s)", this->cast->c_str()); } this->rvalue->Write(to); } MethodCall::MethodCall(const string& n) : name(n) {} MethodCall::MethodCall(const string& n, const std::vector>& args) : name(n), arguments(args) {} MethodCall::MethodCall(std::shared_ptr o, const string& n) : receiver(o), name(n) {} MethodCall::MethodCall(const std::string& t, const string& n) : receiver(t), name(n) {} MethodCall::MethodCall(std::shared_ptr o, const string& n, const std::vector>& args) : receiver(o), name(n), arguments(args) {} MethodCall::MethodCall(const std::string& t, const string& n, const std::vector>& args) : receiver(t), name(n), arguments(args) {} void MethodCall::Write(CodeWriter* to) const { visit( overloaded{[&](std::shared_ptr e) { e->Write(to); to->Write("."); }, [&](const std::string& s) { to->Write("%s.", s.c_str()); }, [](std::monostate) {}}, this->receiver); to->Write("%s(", this->name.c_str()); WriteArgumentList(to, this->arguments); to->Write(")"); } Comparison::Comparison(std::shared_ptr l, const string& o, std::shared_ptr r) : lvalue(l), op(o), rvalue(r) {} void Comparison::Write(CodeWriter* to) const { to->Write("("); this->lvalue->Write(to); to->Write("%s", this->op.c_str()); this->rvalue->Write(to); to->Write(")"); } NewExpression::NewExpression(const std::string& n) : instantiableName(n) {} NewExpression::NewExpression(const std::string& n, const std::vector>& args) : instantiableName(n), arguments(args) {} void NewExpression::Write(CodeWriter* to) const { to->Write("new %s(", this->instantiableName.c_str()); WriteArgumentList(to, this->arguments); to->Write(")"); } Cast::Cast(const std::string& t, std::shared_ptr e) : type(t), expression(e) {} void Cast::Write(CodeWriter* to) const { to->Write("((%s)", this->type.c_str()); expression->Write(to); to->Write(")"); } VariableDeclaration::VariableDeclaration(std::shared_ptr l, std::shared_ptr r) : lvalue(l), rvalue(r) {} VariableDeclaration::VariableDeclaration(std::shared_ptr l) : lvalue(l) {} void VariableDeclaration::Write(CodeWriter* to) const { this->lvalue->WriteDeclaration(to); if (this->rvalue != nullptr) { to->Write(" = "); this->rvalue->Write(to); } to->Write(";\n"); } void IfStatement::Write(CodeWriter* to) const { if (this->expression != nullptr) { to->Write("if ("); this->expression->Write(to); to->Write(") "); } this->statements->Write(to); if (this->elseif != nullptr) { to->Write("else "); this->elseif->Write(to); } } ReturnStatement::ReturnStatement(std::shared_ptr e) : expression(e) {} void ReturnStatement::Write(CodeWriter* to) const { to->Write("return "); this->expression->Write(to); to->Write(";\n"); } void BreakStatement::Write(CodeWriter* to) const { to->Write("break;\n"); } void TryStatement::Write(CodeWriter* to) const { to->Write("try "); this->statements->Write(to); } void FinallyStatement::Write(CodeWriter* to) const { to->Write("finally "); this->statements->Write(to); } Case::Case(const string& c) { cases.push_back(c); } void Case::Write(CodeWriter* to) const { int N = this->cases.size(); if (N > 0) { for (int i = 0; i < N; i++) { string s = this->cases[i]; if (s.length() != 0) { to->Write("case %s:\n", s.c_str()); } else { to->Write("default:\n"); } } } else { to->Write("default:\n"); } statements->Write(to); } SwitchStatement::SwitchStatement(std::shared_ptr e) : expression(e) {} void SwitchStatement::Write(CodeWriter* to) const { to->Write("switch ("); this->expression->Write(to); to->Write(")\n{\n"); to->Indent(); int N = this->cases.size(); for (int i = 0; i < N; i++) { this->cases[i]->Write(to); } to->Dedent(); to->Write("}\n"); } void Method::Write(CodeWriter* to) const { size_t N, i; WriteComment(to, comment); for (const auto& a : this->annotations) { to->Write("%s\n", a.c_str()); } WriteModifiers(to, this->modifiers, SCOPE_MASK | STATIC | ABSTRACT | FINAL | OVERRIDE); if (this->returnType) { to->Write("%s ", this->returnType->c_str()); } to->Write("%s(", this->name.c_str()); N = this->parameters.size(); for (i = 0; i < N; i++) { this->parameters[i]->WriteDeclaration(to); if (i != N - 1) { to->Write(", "); } } to->Write(")"); N = this->exceptions.size(); for (i = 0; i < N; i++) { if (i == 0) { to->Write(" throws "); } else { to->Write(", "); } to->Write("%s", this->exceptions[i].c_str()); } if (this->statements == nullptr) { to->Write(";\n"); } else { to->Write("\n"); this->statements->Write(to); } } void LiteralClassElement::Write(CodeWriter* to) const { to->Write("%s", element.c_str()); } void Class::Write(CodeWriter* to) const { size_t N, i; WriteComment(to, comment); for (const auto& a : this->annotations) { to->Write("%s\n", a.c_str()); } WriteModifiers(to, this->modifiers, ALL_MODIFIERS); if (this->what == Class::CLASS) { to->Write("class "); } else { to->Write("interface "); } string name = this->type; size_t pos = name.rfind('.'); if (pos != string::npos) { name = name.c_str() + pos + 1; } to->Write("%s", name.c_str()); if (this->extends) { to->Write(" extends %s", this->extends->c_str()); } N = this->interfaces.size(); if (N != 0) { if (this->what == Class::CLASS) { to->Write(" implements"); } else { to->Write(" extends"); } for (i = 0; i < N; i++) { to->Write(" %s", this->interfaces[i].c_str()); } } to->Write("\n"); to->Write("{\n"); to->Indent(); N = this->elements.size(); for (i = 0; i < N; i++) { this->elements[i]->Write(to); } to->Dedent(); to->Write("}\n"); } std::shared_ptr NULL_VALUE = std::make_shared("null"); std::shared_ptr THIS_VALUE = std::make_shared("this"); std::shared_ptr SUPER_VALUE = std::make_shared("super"); std::shared_ptr TRUE_VALUE = std::make_shared("true"); std::shared_ptr FALSE_VALUE = std::make_shared("false"); } // namespace java } // namespace aidl } // namespace android ./PaxHeaders.X/ast_java.h0100644 0000000 0000000 00000000034 15172120304 014235 xustar000000000 0000000 28 mtime=1776853188.3090000 ast_java.h0100644 0000000 0000000 00000023402 15172120304 011542 0ustar000000000 0000000 /* * Copyright (C) 2015, 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. */ #pragma once #include #include #include #include #include #include #include enum { PACKAGE_PRIVATE = 0x00000000, PUBLIC = 0x00000001, PRIVATE = 0x00000002, PROTECTED = 0x00000003, SCOPE_MASK = 0x00000003, STATIC = 0x00000010, FINAL = 0x00000020, ABSTRACT = 0x00000040, OVERRIDE = 0x00000100, ALL_MODIFIERS = 0xffffffff }; namespace android { namespace aidl { class CodeWriter; } // namespace aidl } // namespace android namespace android { namespace aidl { namespace java { // Write the modifiers that are set in both mod and mask void WriteModifiers(CodeWriter* to, int mod, int mask); struct AstNode { AstNode() = default; virtual ~AstNode() = default; virtual void Write(CodeWriter* to) const = 0; std::string ToString(); }; struct ClassElement : public AstNode { ClassElement() = default; virtual ~ClassElement() = default; }; struct Expression : public AstNode { virtual ~Expression() = default; }; struct LiteralExpression : public Expression { std::string value; explicit LiteralExpression(const std::string& value); virtual ~LiteralExpression() = default; void Write(CodeWriter* to) const override; }; struct StringLiteralExpression : public Expression { std::string value; explicit StringLiteralExpression(const std::string& value); virtual ~StringLiteralExpression() = default; void Write(CodeWriter* to) const override; }; struct Variable : public Expression { std::vector annotations; const std::string type; std::string name; Variable() = default; Variable(const std::string& type, const std::string& name); virtual ~Variable() = default; void WriteDeclaration(CodeWriter* to) const; void Write(CodeWriter* to) const; }; struct FieldVariable : public Expression { std::variant, std::string> receiver; std::string name; FieldVariable(std::shared_ptr object, const std::string& name); FieldVariable(const std::string& clazz, const std::string& name); virtual ~FieldVariable() = default; void Write(CodeWriter* to) const; }; struct Field : public ClassElement { std::string comment; std::vector annotations; int modifiers = 0; std::shared_ptr variable = nullptr; std::string value; Field() = default; Field(int modifiers, std::shared_ptr variable); virtual ~Field() = default; void Write(CodeWriter* to) const override; }; struct Statement : public AstNode { virtual ~Statement() = default; }; struct LiteralStatement : public Statement { public: LiteralStatement(const std::string& value); virtual ~LiteralStatement() = default; void Write(CodeWriter* to) const override; private: const std::string value_; }; struct StatementBlock : public Statement { std::vector> statements; StatementBlock() = default; virtual ~StatementBlock() = default; void Write(CodeWriter* to) const override; void Add(std::shared_ptr statement); void Add(std::shared_ptr expression); }; struct ExpressionStatement : public Statement { std::shared_ptr expression; explicit ExpressionStatement(std::shared_ptr expression); virtual ~ExpressionStatement() = default; void Write(CodeWriter* to) const override; }; struct Assignment : public Expression { std::shared_ptr lvalue; std::shared_ptr rvalue; std::optional cast = std::nullopt; Assignment(std::shared_ptr lvalue, std::shared_ptr rvalue); Assignment(std::shared_ptr lvalue, std::shared_ptr rvalue, std::string cast); virtual ~Assignment() = default; void Write(CodeWriter* to) const override; }; struct MethodCall : public Expression { std::variant, std::string> receiver; std::string name; std::vector> arguments; std::vector exceptions; explicit MethodCall(const std::string& name); MethodCall(const std::string& name, const std::vector>& args); MethodCall(std::shared_ptr obj, const std::string& name); MethodCall(const std::string& clazz, const std::string& name); MethodCall(std::shared_ptr obj, const std::string& name, const std::vector>& args); MethodCall(const std::string&, const std::string& name, const std::vector>& args); virtual ~MethodCall() = default; void Write(CodeWriter* to) const override; }; struct Comparison : public Expression { std::shared_ptr lvalue; std::string op; std::shared_ptr rvalue; Comparison(std::shared_ptr lvalue, const std::string& op, std::shared_ptr rvalue); virtual ~Comparison() = default; void Write(CodeWriter* to) const override; }; struct NewExpression : public Expression { const std::string instantiableName; std::vector> arguments; explicit NewExpression(const std::string& name); NewExpression(const std::string& name, const std::vector>& args); virtual ~NewExpression() = default; void Write(CodeWriter* to) const override; }; struct Cast : public Expression { const std::string type; std::shared_ptr expression = nullptr; Cast() = default; Cast(const std::string& type, std::shared_ptr expression); virtual ~Cast() = default; void Write(CodeWriter* to) const override; }; struct VariableDeclaration : public Statement { std::shared_ptr lvalue = nullptr; std::shared_ptr rvalue = nullptr; explicit VariableDeclaration(std::shared_ptr lvalue); VariableDeclaration(std::shared_ptr lvalue, std::shared_ptr rvalue); virtual ~VariableDeclaration() = default; void Write(CodeWriter* to) const override; }; struct IfStatement : public Statement { std::shared_ptr expression = nullptr; std::shared_ptr statements = std::make_shared(); std::shared_ptr elseif = nullptr; IfStatement() = default; virtual ~IfStatement() = default; void Write(CodeWriter* to) const override; }; struct ReturnStatement : public Statement { std::shared_ptr expression; explicit ReturnStatement(std::shared_ptr expression); virtual ~ReturnStatement() = default; void Write(CodeWriter* to) const override; }; struct BreakStatement : public Statement { BreakStatement() = default; virtual ~BreakStatement() = default; void Write(CodeWriter* to) const override; }; struct TryStatement : public Statement { std::shared_ptr statements = std::make_shared(); TryStatement() = default; virtual ~TryStatement() = default; void Write(CodeWriter* to) const override; }; struct FinallyStatement : public Statement { std::shared_ptr statements = std::make_shared(); FinallyStatement() = default; virtual ~FinallyStatement() = default; void Write(CodeWriter* to) const override; }; struct Case : public AstNode { std::vector cases; std::shared_ptr statements = std::make_shared(); Case() = default; explicit Case(const std::string& c); virtual ~Case() = default; void Write(CodeWriter* to) const override; }; struct SwitchStatement : public Statement { std::shared_ptr expression; std::vector> cases; explicit SwitchStatement(std::shared_ptr expression); virtual ~SwitchStatement() = default; void Write(CodeWriter* to) const override; }; struct Method : public ClassElement { std::string comment; std::vector annotations; int modifiers = 0; std::optional returnType = std::nullopt; // nullopt means constructor std::string name; std::vector> parameters; std::vector exceptions; std::shared_ptr statements = nullptr; Method() = default; virtual ~Method() = default; void Write(CodeWriter* to) const override; }; struct LiteralClassElement : public ClassElement { std::string element; LiteralClassElement(std::string e) : element(e) {} virtual ~LiteralClassElement() = default; void Write(CodeWriter* to) const override; }; struct Class : public ClassElement { enum { CLASS, INTERFACE }; std::string comment; std::vector annotations; int modifiers = 0; int what = CLASS; // CLASS or INTERFACE std::string type; std::optional extends = std::nullopt; std::vector interfaces; std::vector> elements; Class() = default; virtual ~Class() = default; void Write(CodeWriter* to) const override; }; extern std::shared_ptr NULL_VALUE; extern std::shared_ptr THIS_VALUE; extern std::shared_ptr SUPER_VALUE; extern std::shared_ptr TRUE_VALUE; extern std::shared_ptr FALSE_VALUE; } // namespace java } // namespace aidl } // namespace android ./PaxHeaders.X/ast_java_unittest.cpp0100644 0000000 0000000 00000000034 15172120304 016527 xustar000000000 0000000 28 mtime=1776853188.3100000 ast_java_unittest.cpp0100644 0000000 0000000 00000003157 15172120304 014041 0ustar000000000 0000000 /* * Copyright (C) 2015, 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 #include #include "ast_java.h" #include "code_writer.h" using std::string; namespace android { namespace aidl { namespace java { namespace { const char kExpectedClassOutput[] = R"(// class comment final class TestClass extends SuperClass { } )"; } // namespace TEST(AstJavaTests, GeneratesClass) { Class a_class; a_class.comment = "// class comment"; a_class.modifiers = FINAL; a_class.what = Class::CLASS; a_class.type = "TestClass"; a_class.extends = "SuperClass"; string actual_output; a_class.Write(CodeWriter::ForString(&actual_output).get()); EXPECT_EQ(string(kExpectedClassOutput), actual_output); } TEST(AstJavaTests, ToString) { std::string literal = "public void foo() {}"; LiteralClassElement ce(literal); std::string actual = ce.ToString(); EXPECT_EQ(literal, actual); std::string written; ce.Write(CodeWriter::ForString(&written).get()); EXPECT_EQ(literal, written); } } // namespace java } // namespace aidl } // namespace android ./PaxHeaders.X/build_0100644 0000000 0000000 00000000034 15172120304 013455 xustar000000000 0000000 28 mtime=1776853188.3100000 build/0040755 0000000 0000000 00000000000 15172120304 010702 5ustar000000000 0000000 ./PaxHeaders.X/build_Android.bp0100644 0000000 0000000 00000000034 15172120304 015356 xustar000000000 0000000 28 mtime=1776853188.3120000 build/Android.bp0100644 0000000 0000000 00000024510 15172120304 012604 0ustar000000000 0000000 // Copyright (C) 2018 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package { // See: http://go/android-license-faq // A large-scale-change added 'default_applicable_licenses' to import // all of the 'license_kinds' from "system_tools_aidl_license" // to get the below license kinds: // SPDX-license-identifier-Apache-2.0 default_applicable_licenses: ["system_tools_aidl_license"], } bootstrap_go_package { name: "aidl-soong-rules", pkgPath: "android/soong/aidl", deps: [ "blueprint", "soong", "soong-android", "soong-aidl-library", "soong-cc", "soong-genrule", "soong-phony", "soong-java", "soong-rust", ], srcs: [ "aidl_interface.go", "properties.go", "aidl_api.go", "aidl_gen_rule.go", "aidl_interface_backends.go", "aidl_interface_defaults.go", "aidl_interface_metadata_singleton.go", "aidl_rust_source_provider.go", "aidl_utils.go", ], testSrcs: [ "aidl_test.go", ], pluginFor: ["soong_build"], } aidl_interfaces_metadata { name: "aidl_metadata_json", visibility: ["//system/tools/aidl:__subpackages__"], } // These configurations are inherited by all aidl-gen modules // TODO(b/146436251): default isn't applied because the module is created // in PreArchMutators, when import behavior becomes explicit, the logic can // be moved back to LoadHook, and then default can be applied as well. cc_defaults { name: "aidl-cpp-module-defaults", target: { darwin: { enabled: false, }, }, } java_defaults { name: "aidl-java-module-defaults", } rust_defaults { name: "aidl-rust-module-defaults", } // Tests filegroup { name: "aidl-test-filegroup", srcs: [ "tests_1/some_package/IFoo.aidl", "tests_1/some_package/Thing.aidl", "tests_1/some_package/sub_package/*.aidl", ], } aidl_interface { name: "test-piece-1", local_include_dir: "tests_1", vendor_available: true, product_available: true, double_loadable: true, host_supported: true, flags: ["-Werror"], srcs: [ "tests_1/some_package/IFoo.aidl", "tests_1/some_package/Thing.aidl", "tests_1/some_package/sub_package/*.aidl", // testing glob w/o filegroup ], versions: [ "1", "2", "3", "4", ], backend: { rust: { enabled: true, }, }, } aidl_interface { name: "test-piece-ndk-sdk-29", local_include_dir: "tests_1", flags: ["-Werror"], srcs: [ "tests_1/some_package/IFoo.aidl", "tests_1/some_package/Thing.aidl", "tests_1/some_package/sub_package/*.aidl", // testing glob w/o filegroup ], unstable: true, backend: { rust: { enabled: true, }, ndk: { sdk_version: "29", cflags: ["-U__ANDROID_UNAVAILABLE_SYMBOLS_ARE_WEAK__"], ldflags: ["-Wl,-z,max-page-size=65536"], }, }, } aidl_interface { name: "test-piece-ndk-sdk-30", local_include_dir: "tests_1", flags: ["-Werror"], srcs: [ "tests_1/some_package/IFoo.aidl", "tests_1/some_package/Thing.aidl", "tests_1/some_package/sub_package/*.aidl", // testing glob w/o filegroup ], unstable: true, backend: { rust: { enabled: true, }, ndk: { sdk_version: "30", cflags: ["-U__ANDROID_UNAVAILABLE_SYMBOLS_ARE_WEAK__"], }, }, } aidl_interface { name: "test-piece-ndk-sdk-31", local_include_dir: "tests_1", flags: ["-Werror"], srcs: [ "tests_1/some_package/IFoo.aidl", "tests_1/some_package/Thing.aidl", "tests_1/some_package/sub_package/*.aidl", // testing glob w/o filegroup ], unstable: true, backend: { rust: { enabled: true, }, ndk: { sdk_version: "31", cflags: ["-U__ANDROID_UNAVAILABLE_SYMBOLS_ARE_WEAK__"], }, }, } aidl_interface { name: "test-piece-ndk-sdk-32", local_include_dir: "tests_1", flags: ["-Werror"], srcs: [ "tests_1/some_package/IFoo.aidl", "tests_1/some_package/Thing.aidl", "tests_1/some_package/sub_package/*.aidl", // testing glob w/o filegroup ], unstable: true, backend: { rust: { enabled: true, }, ndk: { sdk_version: "32", cflags: ["-U__ANDROID_UNAVAILABLE_SYMBOLS_ARE_WEAK__"], }, }, } aidl_interface { name: "test-piece-ndk-sdk-33", local_include_dir: "tests_1", flags: ["-Werror"], srcs: [ "tests_1/some_package/IFoo.aidl", "tests_1/some_package/Thing.aidl", "tests_1/some_package/sub_package/*.aidl", // testing glob w/o filegroup ], unstable: true, backend: { rust: { enabled: true, }, ndk: { sdk_version: "33", cflags: ["-U__ANDROID_UNAVAILABLE_SYMBOLS_ARE_WEAK__"], }, }, } aidl_interface { name: "tests-vintf", local_include_dir: "tests_vintf", srcs: ["tests_vintf/vintf/IFoo.aidl"], stability: "vintf", vendor_available: true, backend: { rust: { enabled: true, }, ndk: { sdk_version: "31", }, java: { sdk_version: "system_current", }, }, versions_with_info: [ { version: "1", imports: [], }, ], } aidl_interface { name: "test-piece-2", local_include_dir: "tests_1", flags: ["-Werror"], srcs: [ "tests_1/INoPackage.aidl", "tests_1/some_package/IBar.aidl", ], imports: [ "test-piece-1-V3", ], backend: { rust: { enabled: true, }, java: { platform_apis: true, }, }, gen_trace: true, versions_with_info: [ { version: "1", imports: ["test-piece-1-V3"], }, ], } aidl_interface { name: "test-piece-3", local_include_dir: "tests_1", flags: ["-Werror"], srcs: [ "tests_1/other_package/Enum.aidl", "tests_1/other_package/IBaz.aidl", ], imports: [ "test-piece-2-V1", ], backend: { rust: { enabled: true, }, java: { platform_apis: true, gen_trace: true, }, }, gen_trace: true, versions_with_info: [ { version: "1", imports: ["test-piece-2-V1"], }, { version: "2", imports: ["test-piece-2-V1"], }, ], frozen: true, } cc_test_library { name: "client-using-test-piece-3", srcs: ["client-using-test-piece-3.cpp"], shared_libs: ["test-piece-3-V2-cpp"], } aidl_interface { name: "test-piece-4", local_include_dir: "tests_2", flags: ["-Werror"], srcs: [ "tests_2/another_package/IFaz.aidl", ], imports: [ "test-piece-1-V3", ], backend: { rust: { enabled: true, }, java: { platform_apis: true, }, }, gen_trace: true, versions: ["1"], dumpapi: { no_license: true, }, } aidl_interface { name: "test-root-package", flags: ["-Werror"], srcs: [ "test_package/IBaz.aidl", ], imports: [ "test-piece-2-V1", ], backend: { rust: { enabled: true, }, java: { platform_apis: true, }, }, gen_trace: true, versions: [ "1", "2", "3", ], } aidl_interface { name: "test-piece-5", unstable: true, local_include_dir: "tests_3", flags: ["-Werror"], srcs: [ "tests_3/EmptyParcelable.aidl", "tests_3/IEmptyInterface.aidl", ], } aidl_interface { name: "test-piece-6", unstable: true, local_include_dir: "tests_6", flags: ["-Werror"], srcs: [ "tests_6/test6/Bar.aidl", "tests_6/test6/Foo.aidl", ], } aidl_interface { name: "tests-unfrozen-vendor", owner: "google", local_include_dir: "tests_unfrozen_vendor", srcs: ["tests_unfrozen_vendor/vendor/IFoo.aidl"], vendor_available: true, backend: { rust: { enabled: true, }, }, frozen: false, always_use_unfrozen: true, versions_with_info: [ { version: "1", imports: [], }, ], } cc_library { name: "build_test_aidl_always_use_unfrozen", srcs: ["test_unfrozen_iface.cpp"], shared_libs: [ "tests-unfrozen-vendor-V2-cpp", ], } // These test that a parcel imported from A->B->C will have the required dependencies to link in // all backends (C++ backends need to link direclty against the constructor of the parcelable // in order to work) aidl_interface { name: "tests_transitive_parcel.a", flags: ["-Werror"], srcs: ["tests_transitive_parcel/a/*.aidl"], imports: [ "tests_transitive_parcel.b", "tests_transitive_parcel.c", ], unstable: true, backend: { rust: { enabled: true, }, }, } aidl_interface { name: "tests_transitive_parcel.b", flags: ["-Werror"], srcs: ["tests_transitive_parcel/b/*.aidl"], imports: ["tests_transitive_parcel.c"], unstable: true, backend: { rust: { enabled: true, }, }, } aidl_interface { name: "tests_transitive_parcel.c", flags: ["-Werror"], srcs: ["tests_transitive_parcel/c/*.aidl"], unstable: true, backend: { rust: { enabled: true, }, }, } sh_binary { name: "aidl_hash_gen", src: "hash_gen.sh", host_supported: true, } ./PaxHeaders.X/build_OWNERS0100644 0000000 0000000 00000000034 15172120304 014413 xustar000000000 0000000 28 mtime=1776853188.3130000 build/OWNERS0100644 0000000 0000000 00000000045 15172120304 011636 0ustar000000000 0000000 include platform/build/soong:/OWNERS ./PaxHeaders.X/build_aidl_api.go0100644 0000000 0000000 00000000034 15172120304 015544 xustar000000000 0000000 28 mtime=1776853188.3160000 build/aidl_api.go0100644 0000000 0000000 00000073325 15172120304 013002 0ustar000000000 0000000 // Copyright (C) 2021 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. package aidl import ( "android/soong/aidl_library" "android/soong/android" "reflect" "fmt" "io" "path/filepath" "strconv" "strings" "github.com/google/blueprint" "github.com/google/blueprint/proptools" ) var ( aidlDumpApiRule = pctx.StaticRule("aidlDumpApiRule", blueprint.RuleParams{ Command: `rm -rf "${outDir}" && mkdir -p "${outDir}" && ` + `${aidlCmd} --dumpapi ${imports} ${optionalFlags} --out ${outDir} ${in} && ` + `${aidlHashGen} ${outDir} ${latestVersion} ${hashFile}`, CommandDeps: []string{"${aidlCmd}", "${aidlHashGen}"}, }, "optionalFlags", "imports", "outDir", "hashFile", "latestVersion") aidlCheckApiRule = pctx.StaticRule("aidlCheckApiRule", blueprint.RuleParams{ Command: `(${aidlCmd} ${optionalFlags} --checkapi=${checkApiLevel} ${imports} ${old} ${new} && touch ${out}) || ` + `(cat ${messageFile} && exit 1)`, CommandDeps: []string{"${aidlCmd}"}, Description: "AIDL CHECK API: ${new} against ${old}", }, "optionalFlags", "imports", "old", "new", "messageFile", "checkApiLevel") aidlVerifyHashRule = pctx.StaticRule("aidlVerifyHashRule", blueprint.RuleParams{ Command: `if [ $$(cd '${apiDir}' && { find ./ -name "*.aidl" -print0 | LC_ALL=C sort -z | xargs -0 sha1sum && echo ${version}; } | sha1sum | cut -d " " -f 1) = $$(tail -1 '${hashFile}') ]; then ` + `touch ${out}; else cat '${messageFile}' && exit 1; fi`, Description: "Verify ${apiDir} files have not been modified", }, "apiDir", "version", "messageFile", "hashFile") ) type aidlApiProperties struct { BaseName string Srcs []string `android:"path"` AidlRoot string // base directory for the input aidl file Stability *string Unstable *bool Imports []string Headers []string Versions []string Dumpapi DumpApiProperties Frozen *bool } type aidlApi struct { android.ModuleBase properties aidlApiProperties // for triggering api check for version X against version X-1 checkApiTimestamps android.WritablePaths // for triggering updating current API updateApiTimestamp android.WritablePath // for triggering check that files have not been modified checkHashTimestamps android.WritablePaths // for triggering freezing API as the new version freezeApiTimestamp android.WritablePath // for checking for active development on unfrozen version hasDevelopment android.WritablePath } func (m *aidlApi) apiDir() string { return filepath.Join(aidlApiDir, m.properties.BaseName) } // `m -freeze-api` will freeze ToT as this version func (m *aidlApi) nextVersion() string { return nextVersion(m.properties.Versions) } func (m *aidlApi) hasVersion() bool { return len(m.properties.Versions) > 0 } func (m *aidlApi) latestVersion() string { if !m.hasVersion() { return "0" } return m.properties.Versions[len(m.properties.Versions)-1] } func (m *aidlApi) isFrozen() bool { return proptools.Bool(m.properties.Frozen) } // in order to keep original behavior for certain operations, we may want to // check if frozen is set. func (m *aidlApi) isExplicitlyUnFrozen() bool { return m.properties.Frozen != nil && !proptools.Bool(m.properties.Frozen) } type apiDump struct { version string dir android.Path files android.Paths hashFile android.OptionalPath } func (m *aidlApi) getImports(ctx android.ModuleContext, version string) map[string]string { iface := ctx.GetDirectDepWithTag(m.properties.BaseName, interfaceDep).(*aidlInterface) return iface.getImports(version) } func (m *aidlApi) createApiDumpFromSource(ctx android.ModuleContext) apiDump { srcs, imports := getPaths(ctx, m.properties.Srcs, m.properties.AidlRoot) if ctx.Failed() { return apiDump{} } // dumpapi uses imports for ToT("") version deps := getDeps(ctx, m.getImports(ctx, m.nextVersion())) imports = append(imports, deps.imports...) var apiDir android.WritablePath var apiFiles android.WritablePaths var hashFile android.WritablePath apiDir = android.PathForModuleOut(ctx, "dump") for _, src := range srcs { outFile := android.PathForModuleOut(ctx, "dump", src.Rel()) apiFiles = append(apiFiles, outFile) } hashFile = android.PathForModuleOut(ctx, "dump", ".hash") var optionalFlags []string if !proptools.Bool(m.properties.Unstable) { optionalFlags = append(optionalFlags, "--structured") } if m.properties.Stability != nil { optionalFlags = append(optionalFlags, "--stability", *m.properties.Stability) } if proptools.Bool(m.properties.Dumpapi.No_license) { optionalFlags = append(optionalFlags, "--no_license") } optionalFlags = append(optionalFlags, wrap("-p", deps.preprocessed.Strings(), "")...) version := nextVersion(m.properties.Versions) ctx.Build(pctx, android.BuildParams{ Rule: aidlDumpApiRule, Outputs: append(apiFiles, hashFile), Inputs: srcs, Implicits: deps.preprocessed, Args: map[string]string{ "optionalFlags": strings.Join(optionalFlags, " "), "imports": strings.Join(wrap("-I", imports, ""), " "), "outDir": apiDir.String(), "hashFile": hashFile.String(), "latestVersion": versionForHashGen(version), }, }) return apiDump{version, apiDir, apiFiles.Paths(), android.OptionalPathForPath(hashFile)} } func wrapWithDiffCheckIfElse(m *aidlApi, rb *android.RuleBuilder, writer func(*android.RuleBuilderCommand), elseBlock func(*android.RuleBuilderCommand)) { rbc := rb.Command() rbc.Text("if [ \"$(cat ").Input(m.hasDevelopment).Text(")\" = \"1\" ]; then") writer(rbc) rbc.Text("; else") elseBlock(rbc) rbc.Text("; fi") } func wrapWithDiffCheckIf(m *aidlApi, rb *android.RuleBuilder, writer func(*android.RuleBuilderCommand), needToWrap bool) { rbc := rb.Command() if needToWrap { rbc.Text("if [ \"$(cat ").Input(m.hasDevelopment).Text(")\" = \"1\" ]; then") } writer(rbc) if needToWrap { rbc.Text("; fi") } } // Migrate `versions` into `version_with_info`, and then append a version if it isn't nil func (m *aidlApi) migrateAndAppendVersion(ctx android.ModuleContext, rb *android.RuleBuilder, version *string, transitive bool) { isFreezingApi := version != nil // Remove `versions` property which is deprecated. wrapWithDiffCheckIf(m, rb, func(rbc *android.RuleBuilderCommand) { rbc.BuiltTool("bpmodify"). Text("-w -m " + m.properties.BaseName). Text("-parameter versions -remove-property"). Text(android.PathForModuleSrc(ctx, "Android.bp").String()) }, isFreezingApi) var iface *aidlInterface ctx.VisitDirectDeps(func(dep android.Module) { switch ctx.OtherModuleDependencyTag(dep).(type) { case interfaceDepTag: iface = dep.(*aidlInterface) } }) if iface == nil { ctx.ModuleErrorf("aidl_interface %s doesn't exist", m.properties.BaseName) return } var versions []string if len(iface.properties.Versions_with_info) == 0 { versions = append(versions, iface.getVersions()...) } if isFreezingApi { versions = append(versions, *version) } for _, v := range versions { importIfaces := make(map[string]*aidlInterface) ctx.VisitDirectDeps(func(dep android.Module) { if _, ok := ctx.OtherModuleDependencyTag(dep).(importInterfaceDepTag); ok { other := dep.(*aidlInterface) importIfaces[other.BaseModuleName()] = other } }) imports := make([]string, 0, len(iface.getImportsForVersion(v))) needTransitiveFreeze := isFreezingApi && v == *version && transitive if needTransitiveFreeze { importApis := make(map[string]*aidlApi) ctx.WalkDeps(func(child android.Module, parent android.Module) bool { if api, ok := child.(*aidlApi); ok { moduleName := strings.TrimSuffix(api.Name(), aidlApiSuffix) if _, ok := importIfaces[moduleName]; ok { importApis[moduleName] = api return false } } return true }) wrapWithDiffCheckIf(m, rb, func(rbc *android.RuleBuilderCommand) { rbc.BuiltTool("bpmodify"). Text("-w -m " + m.properties.BaseName). Text("-parameter versions_with_info -add-literal '"). Text(fmt.Sprintf(`{version: "%s", imports: [`, v)) for _, im := range iface.getImportsForVersion(v) { moduleName, version := parseModuleWithVersion(im) // Invoke an imported interface's freeze-api only if it depends on ToT version explicitly or implicitly. if version == importIfaces[moduleName].nextVersion() || !hasVersionSuffix(im) { rb.Command().Text(fmt.Sprintf(`echo "Call %s-freeze-api because %s depends on %s."`, moduleName, m.properties.BaseName, moduleName)) rbc.Implicit(importApis[moduleName].freezeApiTimestamp) } if hasVersionSuffix(im) { rbc.Text(fmt.Sprintf(`"%s",`, im)) } else { rbc.Text("\"" + im + "-V'" + `$(if [ "$(cat `). Input(importApis[im].hasDevelopment). Text(`)" = "1" ]; then echo "` + importIfaces[im].nextVersion() + `"; else echo "` + importIfaces[im].latestVersion() + `"; fi)'", `) } } rbc.Text("]}' "). Text(android.PathForModuleSrc(ctx, "Android.bp").String()). Text("&&"). BuiltTool("bpmodify"). Text("-w -m " + m.properties.BaseName). Text("-parameter frozen -set-bool true"). Text(android.PathForModuleSrc(ctx, "Android.bp").String()) }, isFreezingApi) } else { for _, im := range iface.getImportsForVersion(v) { if hasVersionSuffix(im) { imports = append(imports, im) } else { versionSuffix := importIfaces[im].latestVersion() if !importIfaces[im].hasVersion() || importIfaces[im].isExplicitlyUnFrozen() { versionSuffix = importIfaces[im].nextVersion() } imports = append(imports, im+"-V"+versionSuffix) } } importsStr := strings.Join(wrap(`"`, imports, `"`), ", ") data := fmt.Sprintf(`{version: "%s", imports: [%s]}`, v, importsStr) // Also modify Android.bp file to add the new version to the 'versions_with_info' property. wrapWithDiffCheckIf(m, rb, func(rbc *android.RuleBuilderCommand) { rbc.BuiltTool("bpmodify"). Text("-w -m " + m.properties.BaseName). Text("-parameter versions_with_info -add-literal '" + data + "' "). Text(android.PathForModuleSrc(ctx, "Android.bp").String()). Text("&&"). BuiltTool("bpmodify"). Text("-w -m " + m.properties.BaseName). Text("-parameter frozen -set-bool true"). Text(android.PathForModuleSrc(ctx, "Android.bp").String()) }, isFreezingApi) } } } func (m *aidlApi) makeApiDumpAsVersion(ctx android.ModuleContext, dump apiDump, version string, latestVersionDump *apiDump) android.WritablePath { creatingNewVersion := version != currentVersion moduleDir := android.PathForModuleSrc(ctx).String() targetDir := filepath.Join(moduleDir, m.apiDir(), version) rb := android.NewRuleBuilder(pctx, ctx) transitive := ctx.Config().IsEnvTrue("AIDL_TRANSITIVE_FREEZE") var actionWord string if creatingNewVersion { actionWord = "Making" // We are asked to create a new version. But before doing that, check if the given // dump is the same as the latest version. If so, don't create a new version, // otherwise we will be unnecessarily creating many versions. // Copy the given dump to the target directory only when the equality check failed // (i.e. `has_development` file contains "1"). wrapWithDiffCheckIf(m, rb, func(rbc *android.RuleBuilderCommand) { rbc.Text("mkdir -p " + targetDir + " && "). Text("cp -rf " + dump.dir.String() + "/. " + targetDir).Implicits(dump.files) }, true /* needToWrap */) wrapWithDiffCheckIfElse(m, rb, func(rbc *android.RuleBuilderCommand) { rbc.Text(fmt.Sprintf(`echo "There is change between ToT version and the latest stable version. Freezing %s-V%s."`, m.properties.BaseName, version)) }, func(rbc *android.RuleBuilderCommand) { rbc.Text(fmt.Sprintf(`echo "There is no change from the latest stable version of %s. Nothing happened."`, m.properties.BaseName)) }) m.migrateAndAppendVersion(ctx, rb, &version, transitive) } else { actionWord = "Updating" if m.isFrozen() { rb.Command().BuiltTool("bpmodify"). Text("-w -m " + m.properties.BaseName). Text("-parameter frozen -set-bool false"). Text(android.PathForModuleSrc(ctx, "Android.bp").String()) } // We are updating the current version. Don't copy .hash to the current dump rb.Command().Text("mkdir -p " + targetDir) rb.Command().Text("rsync --recursive --update --delete-before " + dump.dir.String() + "/* " + targetDir).Implicits(dump.files) m.migrateAndAppendVersion(ctx, rb, nil, false) } timestampFile := android.PathForModuleOut(ctx, "update_or_freeze_api_"+version+".timestamp") // explicitly don't touch timestamp, so that the command can be run repeatedly rb.Command().Text("true").ImplicitOutput(timestampFile) rb.Build("dump_aidl_api_"+m.properties.BaseName+"_"+version, actionWord+" AIDL API dump version "+version+" for "+m.properties.BaseName+" (see "+targetDir+")") return timestampFile } type deps struct { preprocessed android.Paths implicits android.Paths imports []string } // calculates import flags(-I) from deps. // When the target is ToT, use ToT of imported interfaces. If not, we use "current" snapshot of // imported interfaces. func getDeps(ctx android.ModuleContext, versionedImports map[string]string) deps { var deps deps ctx.VisitDirectDeps(func(dep android.Module) { switch ctx.OtherModuleDependencyTag(dep).(type) { case importInterfaceDepTag: iface := dep.(*aidlInterface) if version, ok := versionedImports[iface.BaseModuleName()]; ok { if iface.preprocessed[version] == nil { ctx.ModuleErrorf("can't import %v's preprocessed(version=%v)", iface.BaseModuleName(), version) } deps.preprocessed = append(deps.preprocessed, iface.preprocessed[version]) } case interfaceDepTag: iface := dep.(*aidlInterface) deps.imports = append(deps.imports, iface.properties.Include_dirs...) case apiDepTag: api := dep.(*aidlApi) // add imported module's checkapiTimestamps as implicits to make sure that imported apiDump is up-to-date deps.implicits = append(deps.implicits, api.checkApiTimestamps.Paths()...) deps.implicits = append(deps.implicits, api.checkHashTimestamps.Paths()...) deps.implicits = append(deps.implicits, api.hasDevelopment) case interfaceHeadersDepTag: aidlLibraryInfo, ok := android.OtherModuleProvider(ctx, dep, aidl_library.AidlLibraryProvider) if !ok { ctx.PropertyErrorf("headers", "module %v does not provide AidlLibraryInfo", dep.Name()) return } deps.implicits = append(deps.implicits, aidlLibraryInfo.Hdrs.ToList()...) deps.imports = append(deps.imports, android.Paths(aidlLibraryInfo.IncludeDirs.ToList()).Strings()...) } }) return deps } func (m *aidlApi) checkApi(ctx android.ModuleContext, oldDump, newDump apiDump, checkApiLevel string, messageFile android.Path) android.WritablePath { newVersion := newDump.dir.Base() timestampFile := android.PathForModuleOut(ctx, "checkapi_"+newVersion+".timestamp") // --checkapi(old,new) should use imports for "new" deps := getDeps(ctx, m.getImports(ctx, newDump.version)) var implicits android.Paths implicits = append(implicits, deps.implicits...) implicits = append(implicits, deps.preprocessed...) implicits = append(implicits, oldDump.files...) implicits = append(implicits, newDump.files...) implicits = append(implicits, messageFile) var optionalFlags []string if m.properties.Stability != nil { optionalFlags = append(optionalFlags, "--stability", *m.properties.Stability) } optionalFlags = append(optionalFlags, wrap("-p", deps.preprocessed.Strings(), "")...) ctx.Build(pctx, android.BuildParams{ Rule: aidlCheckApiRule, Implicits: implicits, Output: timestampFile, Args: map[string]string{ "optionalFlags": strings.Join(optionalFlags, " "), "imports": strings.Join(wrap("-I", deps.imports, ""), " "), "old": oldDump.dir.String(), "new": newDump.dir.String(), "messageFile": messageFile.String(), "checkApiLevel": checkApiLevel, }, }) return timestampFile } func (m *aidlApi) checkCompatibility(ctx android.ModuleContext, oldDump, newDump apiDump) android.WritablePath { messageFile := android.PathForSource(ctx, "system/tools/aidl/build/message_check_compatibility.txt") return m.checkApi(ctx, oldDump, newDump, "compatible", messageFile) } func (m *aidlApi) checkEquality(ctx android.ModuleContext, oldDump apiDump, newDump apiDump) android.WritablePath { // Use different messages depending on whether platform SDK is finalized or not. // In case when it is finalized, we should never allow updating the already frozen API. // If it's not finalized, we let users to update the current version by invoking // `m -update-api`. var messageFile android.SourcePath if m.isFrozen() { messageFile = android.PathForSource(ctx, "system/tools/aidl/build/message_check_equality_frozen.txt") } else { messageFile = android.PathForSource(ctx, "system/tools/aidl/build/message_check_equality.txt") } formattedMessageFile := android.PathForModuleOut(ctx, "message_check_equality.txt") rb := android.NewRuleBuilder(pctx, ctx) rb.Command().Text("sed").Flag(" s/%s/" + m.properties.BaseName + "/g ").Input(messageFile).Text(" > ").Output(formattedMessageFile) rb.Build("format_message_"+m.properties.BaseName, "") return m.checkApi(ctx, oldDump, newDump, "equal", formattedMessageFile) } func (m *aidlApi) checkIntegrity(ctx android.ModuleContext, dump apiDump) android.WritablePath { version := dump.dir.Base() timestampFile := android.PathForModuleOut(ctx, "checkhash_"+version+".timestamp") messageFile := android.PathForSource(ctx, "system/tools/aidl/build/message_check_integrity.txt") var implicits android.Paths implicits = append(implicits, dump.files...) implicits = append(implicits, dump.hashFile.Path()) implicits = append(implicits, messageFile) ctx.Build(pctx, android.BuildParams{ Rule: aidlVerifyHashRule, Implicits: implicits, Output: timestampFile, Args: map[string]string{ "apiDir": dump.dir.String(), "version": versionForHashGen(version), "hashFile": dump.hashFile.Path().String(), "messageFile": messageFile.String(), }, }) return timestampFile } // Get the `latest` versions of the imported AIDL interfaces. If an interface is frozen, this is the // last frozen version, if it is `frozen: false` this is the last frozen version + 1, if `frozen` is // not set this is the last frozen version because we don't know if there are changes or not to the // interface. // map["foo":"3", "bar":1] func (m *aidlApi) getLatestImportVersions(ctx android.ModuleContext) map[string]string { var latest_versions = make(map[string]string) ctx.VisitDirectDeps(func(dep android.Module) { switch ctx.OtherModuleDependencyTag(dep).(type) { case apiDepTag: api := dep.(*aidlApi) if len(api.properties.Versions) > 0 { if api.properties.Frozen == nil || api.isFrozen() { latest_versions[api.properties.BaseName] = api.latestVersion() } else { latest_versions[api.properties.BaseName] = api.nextVersion() } } else { latest_versions[api.properties.BaseName] = "1" } } }) return latest_versions } func (m *aidlApi) checkForDevelopment(ctx android.ModuleContext, latestVersionDump *apiDump, totDump apiDump) android.WritablePath { hasDevPath := android.PathForModuleOut(ctx, "has_development") rb := android.NewRuleBuilder(pctx, ctx) rb.Command().Text("rm -f " + hasDevPath.String()) if latestVersionDump != nil { current_imports := m.getImports(ctx, currentVersion) last_frozen_imports := m.getImports(ctx, m.properties.Versions[len(m.properties.Versions)-1]) var latest_versions = m.getLatestImportVersions(ctx) // replace any "latest" version with the version number from latest_versions for import_name, latest_version := range current_imports { if latest_version == "latest" { current_imports[import_name] = latest_versions[import_name] } } for import_name, latest_version := range last_frozen_imports { if latest_version == "latest" { last_frozen_imports[import_name] = latest_versions[import_name] } } different_imports := false if !reflect.DeepEqual(current_imports, last_frozen_imports) { if m.isFrozen() { ctx.ModuleErrorf("This interface is 'frozen: true' but the imports have changed. Set 'frozen: false' to allow changes: \n Version %s imports: %s\n Version %s imports: %s\n", currentVersion, fmt.Sprint(current_imports), m.properties.Versions[len(m.properties.Versions)-1], fmt.Sprint(last_frozen_imports)) return hasDevPath } different_imports = true } // checkapi(latest, tot) should use imports for nextVersion(=tot) hasDevCommand := rb.Command() if !different_imports { hasDevCommand.BuiltTool("aidl").FlagWithArg("--checkapi=", "equal") if m.properties.Stability != nil { hasDevCommand.FlagWithArg("--stability ", *m.properties.Stability) } deps := getDeps(ctx, m.getImports(ctx, m.nextVersion())) hasDevCommand. FlagForEachArg("-I", deps.imports).Implicits(deps.implicits). FlagForEachInput("-p", deps.preprocessed). Text(latestVersionDump.dir.String()).Implicits(latestVersionDump.files). Text(totDump.dir.String()).Implicits(totDump.files) if m.isExplicitlyUnFrozen() { // Throw an error if checkapi returns with no differences msg := fmt.Sprintf("echo \"Interface %s can not be marked \\`frozen: false\\` if there are no changes "+ "between the current version and the last frozen version.\"", m.properties.BaseName) hasDevCommand. Text(fmt.Sprintf("2> /dev/null && %s && exit -1 || echo $? >", msg)).Output(hasDevPath) } else { // if is explicitly frozen if m.isFrozen() { // Throw an error if checkapi returns WITH differences msg := fmt.Sprintf("echo \"Interface %s can not be marked \\`frozen: true\\` because there are changes "+ "between the current version and the last frozen version.\"", m.properties.BaseName) hasDevCommand. Text(fmt.Sprintf("2> /dev/null || ( %s && exit -1) && echo 0 >", msg)).Output(hasDevPath) } else { hasDevCommand. Text("2> /dev/null; echo $? >").Output(hasDevPath) } } } else { // We know there are different imports which means has_development must be true hasDevCommand.Text("echo 1 >").Output(hasDevPath) } } else { rb.Command().Text("echo 1 >").Output(hasDevPath) } rb.Build("check_for_development", "") return hasDevPath } func (m *aidlApi) GenerateAndroidBuildActions(ctx android.ModuleContext) { // An API dump is created from source and it is compared against the API dump of the // 'current' (yet-to-be-finalized) version. By checking this we enforce that any change in // the AIDL interface is gated by the AIDL API review even before the interface is frozen as // a new version. totApiDump := m.createApiDumpFromSource(ctx) currentApiDir := android.ExistentPathForSource(ctx, ctx.ModuleDir(), m.apiDir(), currentVersion) var currentApiDump apiDump if currentApiDir.Valid() { currentApiDump = apiDump{ version: nextVersion(m.properties.Versions), dir: currentApiDir.Path(), files: ctx.Glob(filepath.Join(currentApiDir.Path().String(), "**/*.aidl"), nil), hashFile: android.ExistentPathForSource(ctx, ctx.ModuleDir(), m.apiDir(), currentVersion, ".hash"), } checked := m.checkEquality(ctx, currentApiDump, totApiDump) m.checkApiTimestamps = append(m.checkApiTimestamps, checked) } else { // The "current" directory might not exist, in case when the interface is first created. // Instruct user to create one by executing `m -update-api`. rb := android.NewRuleBuilder(pctx, ctx) ifaceName := m.properties.BaseName rb.Command().Text(fmt.Sprintf(`echo "API dump for the current version of AIDL interface %s does not exist."`, ifaceName)) rb.Command().Text(fmt.Sprintf(`echo "Run the command \"m %s-update-api\" or add \"unstable: true\" to the build rule for the interface if it does not need to be versioned"`, ifaceName)) // This file will never be created. Otherwise, the build will pass simply by running 'm; m'. alwaysChecked := android.PathForModuleOut(ctx, "checkapi_current.timestamp") rb.Command().Text("false").ImplicitOutput(alwaysChecked) rb.Build("check_current_aidl_api", "") m.checkApiTimestamps = append(m.checkApiTimestamps, alwaysChecked) } // Also check that version X is backwards compatible with version X-1. // "current" is checked against the latest version. var dumps []apiDump for _, ver := range m.properties.Versions { apiDir := filepath.Join(ctx.ModuleDir(), m.apiDir(), ver) apiDirPath := android.ExistentPathForSource(ctx, apiDir) if apiDirPath.Valid() { hashFilePath := filepath.Join(apiDir, ".hash") dump := apiDump{ version: ver, dir: apiDirPath.Path(), files: ctx.Glob(filepath.Join(apiDirPath.String(), "**/*.aidl"), nil), hashFile: android.ExistentPathForSource(ctx, hashFilePath), } if !dump.hashFile.Valid() { // We should show the source path of hash_gen because aidl_hash_gen cannot be built due to build error. cmd := fmt.Sprintf(`(croot && system/tools/aidl/build/hash_gen.sh %s %s %s)`, apiDir, versionForHashGen(ver), hashFilePath) ctx.ModuleErrorf("A frozen aidl_interface must have '.hash' file, but %s-V%s doesn't have it. Use the command below to generate a hash (DANGER: this should not normally happen. If an interface is changed downstream, it may cause undefined behavior, test failures, unexplained weather conditions, or otherwise broad malfunction of society. DO NOT RUN THIS COMMAND TO BREAK APIS. DO NOT!).\n%s\n", m.properties.BaseName, ver, cmd) } dumps = append(dumps, dump) } else if ctx.Config().AllowMissingDependencies() { ctx.AddMissingDependencies([]string{apiDir}) } else { ctx.ModuleErrorf("API version %s path %s does not exist", ver, apiDir) } } var latestVersionDump *apiDump if len(dumps) >= 1 { latestVersionDump = &dumps[len(dumps)-1] } if currentApiDir.Valid() { dumps = append(dumps, currentApiDump) } for i, _ := range dumps { if dumps[i].hashFile.Valid() { checkHashTimestamp := m.checkIntegrity(ctx, dumps[i]) m.checkHashTimestamps = append(m.checkHashTimestamps, checkHashTimestamp) } if i == 0 { continue } checked := m.checkCompatibility(ctx, dumps[i-1], dumps[i]) m.checkApiTimestamps = append(m.checkApiTimestamps, checked) } // Check for active development on the unfrozen version m.hasDevelopment = m.checkForDevelopment(ctx, latestVersionDump, totApiDump) // API dump from source is updated to the 'current' version. Triggered by `m -update-api` m.updateApiTimestamp = m.makeApiDumpAsVersion(ctx, totApiDump, currentVersion, nil) // API dump from source is frozen as the next stable version. Triggered by `m -freeze-api` nextVersion := m.nextVersion() m.freezeApiTimestamp = m.makeApiDumpAsVersion(ctx, totApiDump, nextVersion, latestVersionDump) nextApiDir := filepath.Join(ctx.ModuleDir(), m.apiDir(), nextVersion) if android.ExistentPathForSource(ctx, nextApiDir).Valid() { ctx.ModuleErrorf("API Directory exists for version %s path %s exists, but it is not specified in versions field.", nextVersion, nextApiDir) } } func (m *aidlApi) AndroidMk() android.AndroidMkData { return android.AndroidMkData{ Custom: func(w io.Writer, name, prefix, moduleDir string, data android.AndroidMkData) { android.WriteAndroidMkData(w, data) targetName := m.properties.BaseName + "-freeze-api" fmt.Fprintln(w, ".PHONY:", targetName) fmt.Fprintln(w, targetName+":", m.freezeApiTimestamp.String()) targetName = m.properties.BaseName + "-update-api" fmt.Fprintln(w, ".PHONY:", targetName) fmt.Fprintln(w, targetName+":", m.updateApiTimestamp.String()) }, } } func (m *aidlApi) DepsMutator(ctx android.BottomUpMutatorContext) { ctx.AddReverseDependency(ctx.Module(), nil, aidlMetadataSingletonName) } func aidlApiFactory() android.Module { m := &aidlApi{} m.AddProperties(&m.properties) android.InitAndroidModule(m) return m } func addApiModule(mctx android.DefaultableHookContext, i *aidlInterface) string { apiModule := i.ModuleBase.Name() + aidlApiSuffix srcs, aidlRoot := i.srcsForVersion(mctx, i.nextVersion()) mctx.CreateModule(aidlApiFactory, &nameProperties{ Name: proptools.StringPtr(apiModule), }, &aidlApiProperties{ BaseName: i.ModuleBase.Name(), Srcs: srcs, AidlRoot: aidlRoot, Stability: i.properties.Stability, Unstable: i.properties.Unstable, Imports: i.properties.Imports, Headers: i.properties.Headers, Versions: i.getVersions(), Dumpapi: i.properties.Dumpapi, Frozen: i.properties.Frozen, }) return apiModule } func versionForHashGen(ver string) string { // aidlHashGen uses the version before current version. If it has never been frozen, return 'latest-version'. verInt, _ := strconv.Atoi(ver) if verInt > 1 { return strconv.Itoa(verInt - 1) } return "latest-version" } func init() { android.RegisterParallelSingletonType("aidl-freeze-api", freezeApiSingletonFactory) } func freezeApiSingletonFactory() android.Singleton { return &freezeApiSingleton{} } type freezeApiSingleton struct{} func (f *freezeApiSingleton) GenerateBuildActions(ctx android.SingletonContext) { var files android.Paths ctx.VisitAllModules(func(module android.Module) { if !module.Enabled() { return } if m, ok := module.(*aidlApi); ok { ownersToFreeze := strings.Fields(ctx.Config().Getenv("AIDL_FREEZE_OWNERS")) var shouldBeFrozen bool if len(ownersToFreeze) > 0 { shouldBeFrozen = android.InList(m.Owner(), ownersToFreeze) } else { shouldBeFrozen = m.Owner() == "" } if shouldBeFrozen { files = append(files, m.freezeApiTimestamp) } } }) ctx.Phony("aidl-freeze-api", files...) } ./PaxHeaders.X/build_aidl_api_0100644 0000000 0000000 00000000034 15172120304 015277 xustar000000000 0000000 28 mtime=1776853188.3180000 build/aidl_api/0040755 0000000 0000000 00000000000 15172120304 012444 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-piece-1_0100644 0000000 0000000 00000000034 15172120304 017557 xustar000000000 0000000 28 mtime=1776853188.3180000 build/aidl_api/test-piece-1/0040755 0000000 0000000 00000000000 15172120304 014644 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-piece-1_1_0100644 0000000 0000000 00000000034 15172120304 017777 xustar000000000 0000000 28 mtime=1776853188.3180000 build/aidl_api/test-piece-1/1/0040755 0000000 0000000 00000000000 15172120304 015004 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-piece-1_1_.hash0100644 0000000 0000000 00000000034 15172120304 020721 xustar000000000 0000000 28 mtime=1776853188.3180000 build/aidl_api/test-piece-1/1/.hash0100644 0000000 0000000 00000000051 15172120304 015721 0ustar000000000 0000000 13e24b2fac6a979971819fba2ab0d6d7c4182122 ./PaxHeaders.X/build_aidl_api_test-piece-1_1_some_package_0100644 0000000 0000000 00000000034 15172120304 022475 xustar000000000 0000000 28 mtime=1776853188.3180000 build/aidl_api/test-piece-1/1/some_package/0040755 0000000 0000000 00000000000 15172120304 017422 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-piece-1_1_some_package_IFoo.aidl0100644 0000000 0000000 00000000034 15172120304 024162 xustar000000000 0000000 28 mtime=1776853188.3180000 build/aidl_api/test-piece-1/1/some_package/IFoo.aidl0100644 0000000 0000000 00000000275 15172120304 021112 0ustar000000000 0000000 package some_package; interface IFoo { void CanYouDealWithThisThing(inout some_package.Thing parcel); void CanYouDealWithThisSubThing(inout some_package.sub_package.SubThing parcel); } ./PaxHeaders.X/build_aidl_api_test-piece-1_1_some_package_Thing.aidl0100644 0000000 0000000 00000000034 15172120304 024377 xustar000000000 0000000 28 mtime=1776853188.3180000 build/aidl_api/test-piece-1/1/some_package/Thing.aidl0100644 0000000 0000000 00000000075 15172120304 021325 0ustar000000000 0000000 package some_package; parcelable Thing { int a; int b; } ./PaxHeaders.X/build_aidl_api_test-piece-1_1_some_package_sub_package_0100644 0000000 0000000 00000000034 15172120304 025021 xustar000000000 0000000 28 mtime=1776853188.3180000 build/aidl_api/test-piece-1/1/some_package/sub_package/0040755 0000000 0000000 00000000000 15172120304 021666 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-piece-1_1_some_package_sub_package_IFoo.aidl0100644 0000000 0000000 00000000034 15172120304 026506 xustar000000000 0000000 28 mtime=1776853188.3180000 build/aidl_api/test-piece-1/1/some_package/sub_package/IFoo.aidl0100644 0000000 0000000 00000000311 15172120304 023345 0ustar000000000 0000000 package some_package.sub_package; interface IFoo { void CanYouDealWithThisThing(inout some_package.Thing parcel); void CanYouDealWithThisSubThing(inout some_package.sub_package.SubThing parcel); } ./PaxHeaders.X/build_aidl_api_test-piece-1_1_some_package_sub_package_SubThing.aidl0100644 0000000 0000000 00000000034 15172120304 027375 xustar000000000 0000000 28 mtime=1776853188.3180000 build/aidl_api/test-piece-1/1/some_package/sub_package/SubThing.aidl0100644 0000000 0000000 00000000114 15172120304 024235 0ustar000000000 0000000 package some_package.sub_package; parcelable SubThing { int a; int b; } ./PaxHeaders.X/build_aidl_api_test-piece-1_2_0100644 0000000 0000000 00000000034 15172120304 020000 xustar000000000 0000000 28 mtime=1776853188.3180000 build/aidl_api/test-piece-1/2/0040755 0000000 0000000 00000000000 15172120304 015005 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-piece-1_2_.hash0100644 0000000 0000000 00000000034 15172120304 020722 xustar000000000 0000000 28 mtime=1776853188.3180000 build/aidl_api/test-piece-1/2/.hash0100644 0000000 0000000 00000000051 15172120304 015722 0ustar000000000 0000000 dc2a9292847e43b4360bb183f7491f0e9895eaa9 ./PaxHeaders.X/build_aidl_api_test-piece-1_2_some_package_0100644 0000000 0000000 00000000034 15172120304 022476 xustar000000000 0000000 28 mtime=1776853188.3180000 build/aidl_api/test-piece-1/2/some_package/0040755 0000000 0000000 00000000000 15172120304 017423 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-piece-1_2_some_package_IFoo.aidl0100644 0000000 0000000 00000000034 15172120304 024163 xustar000000000 0000000 28 mtime=1776853188.3180000 build/aidl_api/test-piece-1/2/some_package/IFoo.aidl0100644 0000000 0000000 00000002365 15172120304 021115 0ustar000000000 0000000 /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a frozen snapshot of an AIDL interface (or parcelable). Do not // try to edit this file. It looks like you are doing that because you have // modified an AIDL interface in a backward-incompatible way, e.g., deleting a // function from an interface or a field from a parcelable and it broke the // build. That breakage is intended. // // You must not make a backward incompatible changes to the AIDL files built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package some_package; interface IFoo { /* @hide */ void CanYouDealWithThisThing(inout some_package.Thing parcel); /* @hide */ void CanYouDealWithThisSubThing(inout some_package.sub_package.SubThing parcel); } ./PaxHeaders.X/build_aidl_api_test-piece-1_2_some_package_Thing.aidl0100644 0000000 0000000 00000000034 15172120304 024400 xustar000000000 0000000 28 mtime=1776853188.3180000 build/aidl_api/test-piece-1/2/some_package/Thing.aidl0100644 0000000 0000000 00000002131 15172120304 021321 0ustar000000000 0000000 /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a frozen snapshot of an AIDL interface (or parcelable). Do not // try to edit this file. It looks like you are doing that because you have // modified an AIDL interface in a backward-incompatible way, e.g., deleting a // function from an interface or a field from a parcelable and it broke the // build. That breakage is intended. // // You must not make a backward incompatible changes to the AIDL files built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package some_package; parcelable Thing { int a; int b; } ./PaxHeaders.X/build_aidl_api_test-piece-1_2_some_package_sub_package_0100644 0000000 0000000 00000000034 15172120304 025022 xustar000000000 0000000 28 mtime=1776853188.3180000 build/aidl_api/test-piece-1/2/some_package/sub_package/0040755 0000000 0000000 00000000000 15172120304 021667 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-piece-1_2_some_package_sub_package_IFoo.aidl0100644 0000000 0000000 00000000034 15172120304 026507 xustar000000000 0000000 28 mtime=1776853188.3180000 build/aidl_api/test-piece-1/2/some_package/sub_package/IFoo.aidl0100644 0000000 0000000 00000002345 15172120304 023357 0ustar000000000 0000000 /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a frozen snapshot of an AIDL interface (or parcelable). Do not // try to edit this file. It looks like you are doing that because you have // modified an AIDL interface in a backward-incompatible way, e.g., deleting a // function from an interface or a field from a parcelable and it broke the // build. That breakage is intended. // // You must not make a backward incompatible changes to the AIDL files built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package some_package.sub_package; interface IFoo { void CanYouDealWithThisThing(inout some_package.Thing parcel); void CanYouDealWithThisSubThing(inout some_package.sub_package.SubThing parcel); } ./PaxHeaders.X/build_aidl_api_test-piece-1_2_some_package_sub_package_SubThing.aidl0100644 0000000 0000000 00000000034 15172120304 027376 xustar000000000 0000000 28 mtime=1776853188.3180000 build/aidl_api/test-piece-1/2/some_package/sub_package/SubThing.aidl0100644 0000000 0000000 00000002150 15172120304 024240 0ustar000000000 0000000 /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a frozen snapshot of an AIDL interface (or parcelable). Do not // try to edit this file. It looks like you are doing that because you have // modified an AIDL interface in a backward-incompatible way, e.g., deleting a // function from an interface or a field from a parcelable and it broke the // build. That breakage is intended. // // You must not make a backward incompatible changes to the AIDL files built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package some_package.sub_package; parcelable SubThing { int a; int b; } ./PaxHeaders.X/build_aidl_api_test-piece-1_3_0100644 0000000 0000000 00000000034 15172120304 020001 xustar000000000 0000000 28 mtime=1776853188.3180000 build/aidl_api/test-piece-1/3/0040755 0000000 0000000 00000000000 15172120304 015006 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-piece-1_3_.hash0100644 0000000 0000000 00000000034 15172120304 020723 xustar000000000 0000000 28 mtime=1776853188.3180000 build/aidl_api/test-piece-1/3/.hash0100644 0000000 0000000 00000000051 15172120304 015723 0ustar000000000 0000000 54f935920ab0934c242145cf00f9852ae3f5a63e ./PaxHeaders.X/build_aidl_api_test-piece-1_3_some_package_0100644 0000000 0000000 00000000034 15172120304 022477 xustar000000000 0000000 28 mtime=1776853188.3180000 build/aidl_api/test-piece-1/3/some_package/0040755 0000000 0000000 00000000000 15172120304 017424 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-piece-1_3_some_package_IFoo.aidl0100644 0000000 0000000 00000000034 15172120304 024164 xustar000000000 0000000 28 mtime=1776853188.3180000 build/aidl_api/test-piece-1/3/some_package/IFoo.aidl0100644 0000000 0000000 00000002331 15172120304 021107 0ustar000000000 0000000 /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a frozen snapshot of an AIDL interface (or parcelable). Do not // try to edit this file. It looks like you are doing that because you have // modified an AIDL interface in a backward-incompatible way, e.g., deleting a // function from an interface or a field from a parcelable and it broke the // build. That breakage is intended. // // You must not make a backward incompatible changes to the AIDL files built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package some_package; interface IFoo { void CanYouDealWithThisThing(inout some_package.Thing parcel); void CanYouDealWithThisSubThing(inout some_package.sub_package.SubThing parcel); } ./PaxHeaders.X/build_aidl_api_test-piece-1_3_some_package_Thing.aidl0100644 0000000 0000000 00000000034 15172120304 024401 xustar000000000 0000000 28 mtime=1776853188.3180000 build/aidl_api/test-piece-1/3/some_package/Thing.aidl0100644 0000000 0000000 00000002131 15172120304 021322 0ustar000000000 0000000 /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a frozen snapshot of an AIDL interface (or parcelable). Do not // try to edit this file. It looks like you are doing that because you have // modified an AIDL interface in a backward-incompatible way, e.g., deleting a // function from an interface or a field from a parcelable and it broke the // build. That breakage is intended. // // You must not make a backward incompatible changes to the AIDL files built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package some_package; parcelable Thing { int a; int b; } ./PaxHeaders.X/build_aidl_api_test-piece-1_3_some_package_sub_package_0100644 0000000 0000000 00000000034 15172120304 025023 xustar000000000 0000000 28 mtime=1776853188.3190000 build/aidl_api/test-piece-1/3/some_package/sub_package/0040755 0000000 0000000 00000000000 15172120304 021670 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-piece-1_3_some_package_sub_package_IFoo.aidl0100644 0000000 0000000 00000000034 15172120304 026510 xustar000000000 0000000 28 mtime=1776853188.3190000 build/aidl_api/test-piece-1/3/some_package/sub_package/IFoo.aidl0100644 0000000 0000000 00000002345 15172120304 023360 0ustar000000000 0000000 /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a frozen snapshot of an AIDL interface (or parcelable). Do not // try to edit this file. It looks like you are doing that because you have // modified an AIDL interface in a backward-incompatible way, e.g., deleting a // function from an interface or a field from a parcelable and it broke the // build. That breakage is intended. // // You must not make a backward incompatible changes to the AIDL files built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package some_package.sub_package; interface IFoo { void CanYouDealWithThisThing(inout some_package.Thing parcel); void CanYouDealWithThisSubThing(inout some_package.sub_package.SubThing parcel); } ./PaxHeaders.X/build_aidl_api_test-piece-1_3_some_package_sub_package_SubThing.aidl0100644 0000000 0000000 00000000034 15172120304 027377 xustar000000000 0000000 28 mtime=1776853188.3190000 build/aidl_api/test-piece-1/3/some_package/sub_package/SubThing.aidl0100644 0000000 0000000 00000002150 15172120304 024241 0ustar000000000 0000000 /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a frozen snapshot of an AIDL interface (or parcelable). Do not // try to edit this file. It looks like you are doing that because you have // modified an AIDL interface in a backward-incompatible way, e.g., deleting a // function from an interface or a field from a parcelable and it broke the // build. That breakage is intended. // // You must not make a backward incompatible changes to the AIDL files built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package some_package.sub_package; parcelable SubThing { int a; int b; } ./PaxHeaders.X/build_aidl_api_test-piece-1_4_0100644 0000000 0000000 00000000034 15172120304 020002 xustar000000000 0000000 28 mtime=1776853188.3190000 build/aidl_api/test-piece-1/4/0040755 0000000 0000000 00000000000 15172120304 015007 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-piece-1_4_.hash0100644 0000000 0000000 00000000034 15172120304 020724 xustar000000000 0000000 28 mtime=1776853188.3190000 build/aidl_api/test-piece-1/4/.hash0100644 0000000 0000000 00000000051 15172120304 015724 0ustar000000000 0000000 be5dd6bf9c9000ee053621f118b7d6a7cfd1e79e ./PaxHeaders.X/build_aidl_api_test-piece-1_4_some_package_0100644 0000000 0000000 00000000034 15172120304 022500 xustar000000000 0000000 28 mtime=1776853188.3190000 build/aidl_api/test-piece-1/4/some_package/0040755 0000000 0000000 00000000000 15172120304 017425 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-piece-1_4_some_package_IFoo.aidl0100644 0000000 0000000 00000000034 15172120304 024165 xustar000000000 0000000 28 mtime=1776853188.3190000 build/aidl_api/test-piece-1/4/some_package/IFoo.aidl0100644 0000000 0000000 00000003624 15172120304 021116 0ustar000000000 0000000 /* * Copyright (C) 2018 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL file. Do not edit it manually. There are // two cases: // 1). this is a frozen version file - do not edit this in any case. // 2). this is a 'current' file. If you make a backwards compatible change to // the interface (from the latest frozen version), the build system will // prompt you to update this file with `m -update-api`. // // You must not make a backward incompatible change to any AIDL file built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package some_package; @SuppressWarnings(value={"inout-parameter"}) interface IFoo { void CanYouDealWithThisThing(inout some_package.Thing parcel); void CanYouDealWithThisSubThing(inout some_package.sub_package.SubThing parcel); } ./PaxHeaders.X/build_aidl_api_test-piece-1_4_some_package_Thing.aidl0100644 0000000 0000000 00000000034 15172120304 024402 xustar000000000 0000000 28 mtime=1776853188.3190000 build/aidl_api/test-piece-1/4/some_package/Thing.aidl0100644 0000000 0000000 00000003347 15172120304 021335 0ustar000000000 0000000 /* * Copyright (C) 2018 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL file. Do not edit it manually. There are // two cases: // 1). this is a frozen version file - do not edit this in any case. // 2). this is a 'current' file. If you make a backwards compatible change to // the interface (from the latest frozen version), the build system will // prompt you to update this file with `m -update-api`. // // You must not make a backward incompatible change to any AIDL file built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package some_package; parcelable Thing { int a; int b; } ./PaxHeaders.X/build_aidl_api_test-piece-1_4_some_package_sub_package_0100644 0000000 0000000 00000000034 15172120304 025024 xustar000000000 0000000 28 mtime=1776853188.3190000 build/aidl_api/test-piece-1/4/some_package/sub_package/0040755 0000000 0000000 00000000000 15172120304 021671 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-piece-1_4_some_package_sub_package_IFoo.aidl0100644 0000000 0000000 00000000034 15172120304 026511 xustar000000000 0000000 28 mtime=1776853188.3190000 build/aidl_api/test-piece-1/4/some_package/sub_package/IFoo.aidl0100644 0000000 0000000 00000003640 15172120304 023360 0ustar000000000 0000000 /* * Copyright (C) 2018 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL file. Do not edit it manually. There are // two cases: // 1). this is a frozen version file - do not edit this in any case. // 2). this is a 'current' file. If you make a backwards compatible change to // the interface (from the latest frozen version), the build system will // prompt you to update this file with `m -update-api`. // // You must not make a backward incompatible change to any AIDL file built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package some_package.sub_package; @SuppressWarnings(value={"inout-parameter"}) interface IFoo { void CanYouDealWithThisThing(inout some_package.Thing parcel); void CanYouDealWithThisSubThing(inout some_package.sub_package.SubThing parcel); } ./PaxHeaders.X/build_aidl_api_test-piece-1_4_some_package_sub_package_SubThing.aidl0100644 0000000 0000000 00000000034 15172120304 027400 xustar000000000 0000000 28 mtime=1776853188.3190000 build/aidl_api/test-piece-1/4/some_package/sub_package/SubThing.aidl0100644 0000000 0000000 00000003366 15172120304 024254 0ustar000000000 0000000 /* * Copyright (C) 2018 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL file. Do not edit it manually. There are // two cases: // 1). this is a frozen version file - do not edit this in any case. // 2). this is a 'current' file. If you make a backwards compatible change to // the interface (from the latest frozen version), the build system will // prompt you to update this file with `m -update-api`. // // You must not make a backward incompatible change to any AIDL file built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package some_package.sub_package; parcelable SubThing { int a; int b; } ./PaxHeaders.X/build_aidl_api_test-piece-1_current_0100644 0000000 0000000 00000000034 15172120304 021321 xustar000000000 0000000 28 mtime=1776853188.3190000 build/aidl_api/test-piece-1/current/0040755 0000000 0000000 00000000000 15172120304 016326 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-piece-1_current_some_package_0100644 0000000 0000000 00000000034 15172120304 024017 xustar000000000 0000000 28 mtime=1776853188.3190000 build/aidl_api/test-piece-1/current/some_package/0040755 0000000 0000000 00000000000 15172120304 020744 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-piece-1_current_some_package_IFoo.aidl0100644 0000000 0000000 00000000034 15172120304 025504 xustar000000000 0000000 28 mtime=1776853188.3190000 build/aidl_api/test-piece-1/current/some_package/IFoo.aidl0100644 0000000 0000000 00000003624 15172120304 022435 0ustar000000000 0000000 /* * Copyright (C) 2018 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL file. Do not edit it manually. There are // two cases: // 1). this is a frozen version file - do not edit this in any case. // 2). this is a 'current' file. If you make a backwards compatible change to // the interface (from the latest frozen version), the build system will // prompt you to update this file with `m -update-api`. // // You must not make a backward incompatible change to any AIDL file built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package some_package; @SuppressWarnings(value={"inout-parameter"}) interface IFoo { void CanYouDealWithThisThing(inout some_package.Thing parcel); void CanYouDealWithThisSubThing(inout some_package.sub_package.SubThing parcel); } ./PaxHeaders.X/build_aidl_api_test-piece-1_current_some_package_Thing.aidl0100644 0000000 0000000 00000000034 15172120304 025721 xustar000000000 0000000 28 mtime=1776853188.3190000 build/aidl_api/test-piece-1/current/some_package/Thing.aidl0100644 0000000 0000000 00000003347 15172120304 022654 0ustar000000000 0000000 /* * Copyright (C) 2018 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL file. Do not edit it manually. There are // two cases: // 1). this is a frozen version file - do not edit this in any case. // 2). this is a 'current' file. If you make a backwards compatible change to // the interface (from the latest frozen version), the build system will // prompt you to update this file with `m -update-api`. // // You must not make a backward incompatible change to any AIDL file built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package some_package; parcelable Thing { int a; int b; } ./PaxHeaders.X/build_aidl_api_test-piece-1_current_some_package_sub_package_0100644 0000000 0000000 00000000034 15172120304 026343 xustar000000000 0000000 28 mtime=1776853188.3190000 build/aidl_api/test-piece-1/current/some_package/sub_package/0040755 0000000 0000000 00000000000 15172120304 023210 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-piece-1_current_some_package_sub_package_IFoo.aidl0100644 0000000 0000000 00000000034 15172120304 030030 xustar000000000 0000000 28 mtime=1776853188.3190000 build/aidl_api/test-piece-1/current/some_package/sub_package/IFoo.aidl0100644 0000000 0000000 00000003640 15172120304 024677 0ustar000000000 0000000 /* * Copyright (C) 2018 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL file. Do not edit it manually. There are // two cases: // 1). this is a frozen version file - do not edit this in any case. // 2). this is a 'current' file. If you make a backwards compatible change to // the interface (from the latest frozen version), the build system will // prompt you to update this file with `m -update-api`. // // You must not make a backward incompatible change to any AIDL file built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package some_package.sub_package; @SuppressWarnings(value={"inout-parameter"}) interface IFoo { void CanYouDealWithThisThing(inout some_package.Thing parcel); void CanYouDealWithThisSubThing(inout some_package.sub_package.SubThing parcel); } ./PaxHeaders.X/build_aidl_api_test-piece-1_current_some_package_sub_package_SubThing.aidl0100644 0000000 0000000 00000000034 15172120304 030717 xustar000000000 0000000 28 mtime=1776853188.3190000 build/aidl_api/test-piece-1/current/some_package/sub_package/SubThing.aidl0100644 0000000 0000000 00000003366 15172120304 025573 0ustar000000000 0000000 /* * Copyright (C) 2018 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL file. Do not edit it manually. There are // two cases: // 1). this is a frozen version file - do not edit this in any case. // 2). this is a 'current' file. If you make a backwards compatible change to // the interface (from the latest frozen version), the build system will // prompt you to update this file with `m -update-api`. // // You must not make a backward incompatible change to any AIDL file built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package some_package.sub_package; parcelable SubThing { int a; int b; } ./PaxHeaders.X/build_aidl_api_test-piece-2_0100644 0000000 0000000 00000000034 15172120304 017560 xustar000000000 0000000 28 mtime=1776853188.3190000 build/aidl_api/test-piece-2/0040755 0000000 0000000 00000000000 15172120304 014645 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-piece-2_1_0100644 0000000 0000000 00000000034 15172120304 020000 xustar000000000 0000000 28 mtime=1776853188.3190000 build/aidl_api/test-piece-2/1/0040755 0000000 0000000 00000000000 15172120304 015005 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-piece-2_1_.hash0100644 0000000 0000000 00000000034 15172120304 020722 xustar000000000 0000000 28 mtime=1776853188.3190000 build/aidl_api/test-piece-2/1/.hash0100644 0000000 0000000 00000000122 15172120304 015721 0ustar000000000 0000000 c544902ab8a1d2e72ae9396032ba113e9b9698c4 fcd36db451cdbeeb049833fd7f499a987acf3930 ./PaxHeaders.X/build_aidl_api_test-piece-2_1_INoPackage.aidl0100644 0000000 0000000 00000000034 15172120304 022572 xustar000000000 0000000 28 mtime=1776853188.3190000 build/aidl_api/test-piece-2/1/INoPackage.aidl0100644 0000000 0000000 00000000121 15172120304 017570 0ustar000000000 0000000 interface INoPackage { void CanYouDealWithThisBar(in some_package.IBar bar); } ./PaxHeaders.X/build_aidl_api_test-piece-2_1_some_package_0100644 0000000 0000000 00000000034 15172120304 022476 xustar000000000 0000000 28 mtime=1776853188.3190000 build/aidl_api/test-piece-2/1/some_package/0040755 0000000 0000000 00000000000 15172120304 017423 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-piece-2_1_some_package_IBar.aidl0100644 0000000 0000000 00000000034 15172120304 024144 xustar000000000 0000000 28 mtime=1776853188.3190000 build/aidl_api/test-piece-2/1/some_package/IBar.aidl0100644 0000000 0000000 00000000150 15172120304 021064 0ustar000000000 0000000 package some_package; interface IBar { oneway void CanYouDealWithThisFoo(in some_package.IFoo foo); } ./PaxHeaders.X/build_aidl_api_test-piece-2_current_0100644 0000000 0000000 00000000034 15172120304 021322 xustar000000000 0000000 28 mtime=1776853188.3190000 build/aidl_api/test-piece-2/current/0040755 0000000 0000000 00000000000 15172120304 016327 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-piece-2_current_INoPackage.aidl0100644 0000000 0000000 00000000034 15172120304 024114 xustar000000000 0000000 28 mtime=1776853188.3190000 build/aidl_api/test-piece-2/current/INoPackage.aidl0100644 0000000 0000000 00000003373 15172120304 021126 0ustar000000000 0000000 /* * Copyright (C) 2018 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL file. Do not edit it manually. There are // two cases: // 1). this is a frozen version file - do not edit this in any case. // 2). this is a 'current' file. If you make a backwards compatible change to // the interface (from the latest frozen version), the build system will // prompt you to update this file with `m -update-api`. // // You must not make a backward incompatible change to any AIDL file built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. interface INoPackage { void CanYouDealWithThisBar(in some_package.IBar bar); } ./PaxHeaders.X/build_aidl_api_test-piece-2_current_some_package_0100644 0000000 0000000 00000000034 15172120304 024020 xustar000000000 0000000 28 mtime=1776853188.3190000 build/aidl_api/test-piece-2/current/some_package/0040755 0000000 0000000 00000000000 15172120304 020745 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-piece-2_current_some_package_IBar.aidl0100644 0000000 0000000 00000000034 15172120304 025466 xustar000000000 0000000 28 mtime=1776853188.3200000 build/aidl_api/test-piece-2/current/some_package/IBar.aidl0100644 0000000 0000000 00000003422 15172120304 022413 0ustar000000000 0000000 /* * Copyright (C) 2018 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL file. Do not edit it manually. There are // two cases: // 1). this is a frozen version file - do not edit this in any case. // 2). this is a 'current' file. If you make a backwards compatible change to // the interface (from the latest frozen version), the build system will // prompt you to update this file with `m -update-api`. // // You must not make a backward incompatible change to any AIDL file built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package some_package; interface IBar { oneway void CanYouDealWithThisFoo(in some_package.IFoo foo); } ./PaxHeaders.X/build_aidl_api_test-piece-3_0100644 0000000 0000000 00000000034 15172120304 017561 xustar000000000 0000000 28 mtime=1776853188.3200000 build/aidl_api/test-piece-3/0040755 0000000 0000000 00000000000 15172120304 014646 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-piece-3_1_0100644 0000000 0000000 00000000034 15172120304 020001 xustar000000000 0000000 28 mtime=1776853188.3200000 build/aidl_api/test-piece-3/1/0040755 0000000 0000000 00000000000 15172120304 015006 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-piece-3_1_.hash0100644 0000000 0000000 00000000034 15172120304 020723 xustar000000000 0000000 28 mtime=1776853188.3200000 build/aidl_api/test-piece-3/1/.hash0100644 0000000 0000000 00000000051 15172120304 015723 0ustar000000000 0000000 f630cb120fa36f9f2507d730513a03b0cd4fbc0e ./PaxHeaders.X/build_aidl_api_test-piece-3_1_other_package_0100644 0000000 0000000 00000000034 15172120304 022655 xustar000000000 0000000 28 mtime=1776853188.3200000 build/aidl_api/test-piece-3/1/other_package/0040755 0000000 0000000 00000000000 15172120304 017602 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-piece-3_1_other_package_IBaz.aidl0100644 0000000 0000000 00000000034 15172120304 024333 xustar000000000 0000000 28 mtime=1776853188.3200000 build/aidl_api/test-piece-3/1/other_package/IBaz.aidl0100644 0000000 0000000 00000000142 15172120304 021254 0ustar000000000 0000000 package other_package; interface IBaz { void CanYouDealWithThisBar(in some_package.IBar bar); } ./PaxHeaders.X/build_aidl_api_test-piece-3_2_0100644 0000000 0000000 00000000034 15172120304 020002 xustar000000000 0000000 28 mtime=1776853188.3200000 build/aidl_api/test-piece-3/2/0040755 0000000 0000000 00000000000 15172120304 015007 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-piece-3_2_.hash0100644 0000000 0000000 00000000034 15172120304 020724 xustar000000000 0000000 28 mtime=1776853188.3200000 build/aidl_api/test-piece-3/2/.hash0100644 0000000 0000000 00000000051 15172120304 015724 0ustar000000000 0000000 4be68328b234e427de4c612783612c3eda330235 ./PaxHeaders.X/build_aidl_api_test-piece-3_2_other_package_0100644 0000000 0000000 00000000034 15172120304 022656 xustar000000000 0000000 28 mtime=1776853188.3200000 build/aidl_api/test-piece-3/2/other_package/0040755 0000000 0000000 00000000000 15172120304 017603 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-piece-3_2_other_package_Enum.aidl0100644 0000000 0000000 00000000034 15172120304 024413 xustar000000000 0000000 28 mtime=1776853188.3200000 build/aidl_api/test-piece-3/2/other_package/Enum.aidl0100644 0000000 0000000 00000003336 15172120304 021344 0ustar000000000 0000000 /* * Copyright (C) 2022 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. */ /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL file. Do not edit it manually. There are // two cases: // 1). this is a frozen version file - do not edit this in any case. // 2). this is a 'current' file. If you make a backwards compatible change to // the interface (from the latest frozen version), the build system will // prompt you to update this file with `m -update-api`. // // You must not make a backward incompatible change to any AIDL file built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package other_package; enum Enum { ZERO, ONE, } ./PaxHeaders.X/build_aidl_api_test-piece-3_2_other_package_IBaz.aidl0100644 0000000 0000000 00000000034 15172120304 024334 xustar000000000 0000000 28 mtime=1776853188.3200000 build/aidl_api/test-piece-3/2/other_package/IBaz.aidl0100644 0000000 0000000 00000003500 15172120304 021256 0ustar000000000 0000000 /* * Copyright (C) 2018 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL file. Do not edit it manually. There are // two cases: // 1). this is a frozen version file - do not edit this in any case. // 2). this is a 'current' file. If you make a backwards compatible change to // the interface (from the latest frozen version), the build system will // prompt you to update this file with `m -update-api`. // // You must not make a backward incompatible change to any AIDL file built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package other_package; interface IBaz { void CanYouDealWithThisBar(in some_package.IBar bar); const int ZERO = other_package.Enum.ZERO /* 0 */; } ./PaxHeaders.X/build_aidl_api_test-piece-3_current_0100644 0000000 0000000 00000000034 15172120304 021323 xustar000000000 0000000 28 mtime=1776853188.3200000 build/aidl_api/test-piece-3/current/0040755 0000000 0000000 00000000000 15172120304 016330 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-piece-3_current_other_package_0100644 0000000 0000000 00000000034 15172120304 024177 xustar000000000 0000000 28 mtime=1776853188.3200000 build/aidl_api/test-piece-3/current/other_package/0040755 0000000 0000000 00000000000 15172120304 021124 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-piece-3_current_other_package_Enum.aidl0100644 0000000 0000000 00000000034 15172120304 025734 xustar000000000 0000000 28 mtime=1776853188.3200000 build/aidl_api/test-piece-3/current/other_package/Enum.aidl0100644 0000000 0000000 00000003346 15172120304 022666 0ustar000000000 0000000 /* * Copyright (C) 2022 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. */ /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL file. Do not edit it manually. There are // two cases: // 1). this is a frozen version file - do not edit this in any case. // 2). this is a 'current' file. If you make a backwards compatible change to // the interface (from the latest frozen version), the build system will // prompt you to update this file with `m -update-api`. // // You must not make a backward incompatible change to any AIDL file built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package other_package; enum Enum { ZERO = 0, ONE = 1, } ./PaxHeaders.X/build_aidl_api_test-piece-3_current_other_package_IBaz.aidl0100644 0000000 0000000 00000000034 15172120304 025655 xustar000000000 0000000 28 mtime=1776853188.3200000 build/aidl_api/test-piece-3/current/other_package/IBaz.aidl0100644 0000000 0000000 00000003442 15172120304 022604 0ustar000000000 0000000 /* * Copyright (C) 2018 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL file. Do not edit it manually. There are // two cases: // 1). this is a frozen version file - do not edit this in any case. // 2). this is a 'current' file. If you make a backwards compatible change to // the interface (from the latest frozen version), the build system will // prompt you to update this file with `m -update-api`. // // You must not make a backward incompatible change to any AIDL file built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package other_package; interface IBaz { void CanYouDealWithThisBar(in some_package.IBar bar); const int ZERO = 0; } ./PaxHeaders.X/build_aidl_api_test-piece-4_0100644 0000000 0000000 00000000034 15172120304 017562 xustar000000000 0000000 28 mtime=1776853188.3200000 build/aidl_api/test-piece-4/0040755 0000000 0000000 00000000000 15172120304 014647 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-piece-4_1_0100644 0000000 0000000 00000000034 15172120304 020002 xustar000000000 0000000 28 mtime=1776853188.3200000 build/aidl_api/test-piece-4/1/0040755 0000000 0000000 00000000000 15172120304 015007 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-piece-4_1_.hash0100644 0000000 0000000 00000000034 15172120304 020724 xustar000000000 0000000 28 mtime=1776853188.3200000 build/aidl_api/test-piece-4/1/.hash0100644 0000000 0000000 00000000051 15172120304 015724 0ustar000000000 0000000 29d4015ee2a4171396aecd925156aa2e47a42013 ./PaxHeaders.X/build_aidl_api_test-piece-4_1_another_package_0100644 0000000 0000000 00000000034 15172120304 023175 xustar000000000 0000000 28 mtime=1776853188.3200000 build/aidl_api/test-piece-4/1/another_package/0040755 0000000 0000000 00000000000 15172120304 020122 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-piece-4_1_another_package_IFaz.aidl0100644 0000000 0000000 00000000034 15172120304 024657 xustar000000000 0000000 28 mtime=1776853188.3200000 build/aidl_api/test-piece-4/1/another_package/IFaz.aidl0100644 0000000 0000000 00000000144 15172120304 021602 0ustar000000000 0000000 package another_package; interface IFaz { void CanYouDealWithThisFoo(in some_package.IFoo foo); } ./PaxHeaders.X/build_aidl_api_test-piece-4_current_0100644 0000000 0000000 00000000034 15172120304 021324 xustar000000000 0000000 28 mtime=1776853188.3200000 build/aidl_api/test-piece-4/current/0040755 0000000 0000000 00000000000 15172120304 016331 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-piece-4_current_another_package_0100644 0000000 0000000 00000000034 15172120304 024517 xustar000000000 0000000 28 mtime=1776853188.3200000 build/aidl_api/test-piece-4/current/another_package/0040755 0000000 0000000 00000000000 15172120304 021444 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-piece-4_current_another_package_IFaz.aidl0100644 0000000 0000000 00000000034 15172120304 026201 xustar000000000 0000000 28 mtime=1776853188.3200000 build/aidl_api/test-piece-4/current/another_package/IFaz.aidl0100644 0000000 0000000 00000002242 15172120304 023125 0ustar000000000 0000000 /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL file. Do not edit it manually. There are // two cases: // 1). this is a frozen version file - do not edit this in any case. // 2). this is a 'current' file. If you make a backwards compatible change to // the interface (from the latest frozen version), the build system will // prompt you to update this file with `m -update-api`. // // You must not make a backward incompatible change to any AIDL file built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package another_package; interface IFaz { void CanYouDealWithThisFoo(in some_package.IFoo foo); } ./PaxHeaders.X/build_aidl_api_test-root-package_0100644 0000000 0000000 00000000034 15172120304 020710 xustar000000000 0000000 28 mtime=1776853188.3200000 build/aidl_api/test-root-package/0040755 0000000 0000000 00000000000 15172120304 015775 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-root-package_1_0100644 0000000 0000000 00000000034 15172120304 021130 xustar000000000 0000000 28 mtime=1776853188.3200000 build/aidl_api/test-root-package/1/0040755 0000000 0000000 00000000000 15172120304 016135 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-root-package_1_.hash0100644 0000000 0000000 00000000034 15172120304 022052 xustar000000000 0000000 28 mtime=1776853188.3200000 build/aidl_api/test-root-package/1/.hash0100644 0000000 0000000 00000000051 15172120304 017052 0ustar000000000 0000000 1f59d8099e05dcc6ac47a9a12a1f2660dd60cfef ./PaxHeaders.X/build_aidl_api_test-root-package_1_test_package_0100644 0000000 0000000 00000000034 15172120304 023642 xustar000000000 0000000 28 mtime=1776853188.3200000 build/aidl_api/test-root-package/1/test_package/0040755 0000000 0000000 00000000000 15172120304 020567 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-root-package_1_test_package_IBaz.aidl0100644 0000000 0000000 00000000034 15172120304 025320 xustar000000000 0000000 28 mtime=1776853188.3200000 build/aidl_api/test-root-package/1/test_package/IBaz.aidl0100644 0000000 0000000 00000000150 15172120304 022240 0ustar000000000 0000000 package test_package; interface IBaz { oneway void CanYouDealWithThisBar(in some_package.IBar bar); } ./PaxHeaders.X/build_aidl_api_test-root-package_2_0100644 0000000 0000000 00000000034 15172120304 021131 xustar000000000 0000000 28 mtime=1776853188.3200000 build/aidl_api/test-root-package/2/0040755 0000000 0000000 00000000000 15172120304 016136 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-root-package_2_.hash0100644 0000000 0000000 00000000034 15172120304 022053 xustar000000000 0000000 28 mtime=1776853188.3200000 build/aidl_api/test-root-package/2/.hash0100644 0000000 0000000 00000000051 15172120304 017053 0ustar000000000 0000000 7025642541e73177f105c6d5b62a980fa5b4ace3 ./PaxHeaders.X/build_aidl_api_test-root-package_2_test_package_0100644 0000000 0000000 00000000034 15172120304 023643 xustar000000000 0000000 28 mtime=1776853188.3200000 build/aidl_api/test-root-package/2/test_package/0040755 0000000 0000000 00000000000 15172120304 020570 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-root-package_2_test_package_IBaz.aidl0100644 0000000 0000000 00000000034 15172120304 025321 xustar000000000 0000000 28 mtime=1776853188.3200000 build/aidl_api/test-root-package/2/test_package/IBaz.aidl0100644 0000000 0000000 00000000413 15172120304 022243 0ustar000000000 0000000 package test_package; interface IBaz { oneway void CanYouDealWithThisBar(in some_package.IBar bar); void MethodAddedInVersion2(); ParcelFileDescriptor readPFD(); void writePFD(in ParcelFileDescriptor fd); void readWritePFD(inout ParcelFileDescriptor fd); } ./PaxHeaders.X/build_aidl_api_test-root-package_3_0100644 0000000 0000000 00000000034 15172120304 021132 xustar000000000 0000000 28 mtime=1776853188.3210000 build/aidl_api/test-root-package/3/0040755 0000000 0000000 00000000000 15172120304 016137 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-root-package_3_.hash0100644 0000000 0000000 00000000034 15172120304 022054 xustar000000000 0000000 28 mtime=1776853188.3210000 build/aidl_api/test-root-package/3/.hash0100644 0000000 0000000 00000000051 15172120304 017054 0ustar000000000 0000000 fe1b4b56b7263d121c36b566a5d6ddf7496261cc ./PaxHeaders.X/build_aidl_api_test-root-package_3_test_package_0100644 0000000 0000000 00000000034 15172120304 023644 xustar000000000 0000000 28 mtime=1776853188.3210000 build/aidl_api/test-root-package/3/test_package/0040755 0000000 0000000 00000000000 15172120304 020571 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-root-package_3_test_package_IBaz.aidl0100644 0000000 0000000 00000000034 15172120304 025322 xustar000000000 0000000 28 mtime=1776853188.3210000 build/aidl_api/test-root-package/3/test_package/IBaz.aidl0100644 0000000 0000000 00000004231 15172120304 022246 0ustar000000000 0000000 /* * Copyright (C) 2018 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL file. Do not edit it manually. There are // two cases: // 1). this is a frozen version file - do not edit this in any case. // 2). this is a 'current' file. If you make a backwards compatible change to // the interface (from the latest frozen version), the build system will // prompt you to update this file with `m -update-api`. // // You must not make a backward incompatible change to any AIDL file built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package test_package; @SuppressWarnings(value={"mixed-oneway", "inout-parameter", "out-array"}) interface IBaz { oneway void CanYouDealWithThisBar(in some_package.IBar bar); void MethodAddedInVersion2(); ParcelFileDescriptor readPFD(); void writePFD(in ParcelFileDescriptor fd); void readWritePFD(inout ParcelFileDescriptor fd); ParcelFileDescriptor[] readPFDArray(); void writePFDArray(in ParcelFileDescriptor[] fds); void readWritePFDArray(inout ParcelFileDescriptor[] fds); } ./PaxHeaders.X/build_aidl_api_test-root-package_current_0100644 0000000 0000000 00000000034 15172120304 022452 xustar000000000 0000000 28 mtime=1776853188.3210000 build/aidl_api/test-root-package/current/0040755 0000000 0000000 00000000000 15172120304 017457 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-root-package_current_test_package_0100644 0000000 0000000 00000000034 15172120304 025164 xustar000000000 0000000 28 mtime=1776853188.3210000 build/aidl_api/test-root-package/current/test_package/0040755 0000000 0000000 00000000000 15172120304 022111 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_test-root-package_current_test_package_IBaz.aidl0100644 0000000 0000000 00000000034 15172120304 026642 xustar000000000 0000000 28 mtime=1776853188.3210000 build/aidl_api/test-root-package/current/test_package/IBaz.aidl0100644 0000000 0000000 00000004231 15172120304 023566 0ustar000000000 0000000 /* * Copyright (C) 2018 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL file. Do not edit it manually. There are // two cases: // 1). this is a frozen version file - do not edit this in any case. // 2). this is a 'current' file. If you make a backwards compatible change to // the interface (from the latest frozen version), the build system will // prompt you to update this file with `m -update-api`. // // You must not make a backward incompatible change to any AIDL file built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package test_package; @SuppressWarnings(value={"mixed-oneway", "inout-parameter", "out-array"}) interface IBaz { oneway void CanYouDealWithThisBar(in some_package.IBar bar); void MethodAddedInVersion2(); ParcelFileDescriptor readPFD(); void writePFD(in ParcelFileDescriptor fd); void readWritePFD(inout ParcelFileDescriptor fd); ParcelFileDescriptor[] readPFDArray(); void writePFDArray(in ParcelFileDescriptor[] fds); void readWritePFDArray(inout ParcelFileDescriptor[] fds); } ./PaxHeaders.X/build_aidl_api_tests-unfrozen-vendor_0100644 0000000 0000000 00000000034 15172120304 021660 xustar000000000 0000000 28 mtime=1776853188.3210000 build/aidl_api/tests-unfrozen-vendor/0040755 0000000 0000000 00000000000 15172120304 016745 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_tests-unfrozen-vendor_1_0100644 0000000 0000000 00000000034 15172120304 022100 xustar000000000 0000000 28 mtime=1776853188.3210000 build/aidl_api/tests-unfrozen-vendor/1/0040755 0000000 0000000 00000000000 15172120304 017105 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_tests-unfrozen-vendor_1_.hash0100644 0000000 0000000 00000000034 15172120304 023022 xustar000000000 0000000 28 mtime=1776853188.3210000 build/aidl_api/tests-unfrozen-vendor/1/.hash0100644 0000000 0000000 00000000051 15172120304 020022 0ustar000000000 0000000 4c1abd625626228b3aa4a015e3745cd08752ddb6 ./PaxHeaders.X/build_aidl_api_tests-unfrozen-vendor_1_vendor_0100644 0000000 0000000 00000000034 15172120304 023455 xustar000000000 0000000 28 mtime=1776853188.3210000 build/aidl_api/tests-unfrozen-vendor/1/vendor/0040755 0000000 0000000 00000000000 15172120304 020402 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_tests-unfrozen-vendor_1_vendor_IFoo.aidl0100644 0000000 0000000 00000000034 15172120304 025142 xustar000000000 0000000 28 mtime=1776853188.3210000 build/aidl_api/tests-unfrozen-vendor/1/vendor/IFoo.aidl0100644 0000000 0000000 00000002157 15172120304 022073 0ustar000000000 0000000 /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL file. Do not edit it manually. There are // two cases: // 1). this is a frozen version file - do not edit this in any case. // 2). this is a 'current' file. If you make a backwards compatible change to // the interface (from the latest frozen version), the build system will // prompt you to update this file with `m -update-api`. // // You must not make a backward incompatible change to any AIDL file built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package vendor; interface IFoo { void foo(); } ./PaxHeaders.X/build_aidl_api_tests-unfrozen-vendor_current_0100644 0000000 0000000 00000000034 15172120304 023422 xustar000000000 0000000 28 mtime=1776853188.3210000 build/aidl_api/tests-unfrozen-vendor/current/0040755 0000000 0000000 00000000000 15172120304 020427 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_tests-unfrozen-vendor_current_vendor_0100644 0000000 0000000 00000000034 15172120304 024777 xustar000000000 0000000 28 mtime=1776853188.3210000 build/aidl_api/tests-unfrozen-vendor/current/vendor/0040755 0000000 0000000 00000000000 15172120304 021724 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_tests-unfrozen-vendor_current_vendor_IFoo.aidl0100644 0000000 0000000 00000000034 15172120304 026464 xustar000000000 0000000 28 mtime=1776853188.3210000 build/aidl_api/tests-unfrozen-vendor/current/vendor/IFoo.aidl0100644 0000000 0000000 00000002175 15172120304 023415 0ustar000000000 0000000 /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL file. Do not edit it manually. There are // two cases: // 1). this is a frozen version file - do not edit this in any case. // 2). this is a 'current' file. If you make a backwards compatible change to // the interface (from the latest frozen version), the build system will // prompt you to update this file with `m -update-api`. // // You must not make a backward incompatible change to any AIDL file built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package vendor; interface IFoo { void foo(); void bar(); } ./PaxHeaders.X/build_aidl_api_tests-vintf_0100644 0000000 0000000 00000000034 15172120304 017645 xustar000000000 0000000 28 mtime=1776853188.3210000 build/aidl_api/tests-vintf/0040755 0000000 0000000 00000000000 15172120304 014732 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_tests-vintf_1_0100644 0000000 0000000 00000000034 15172120304 020065 xustar000000000 0000000 28 mtime=1776853188.3210000 build/aidl_api/tests-vintf/1/0040755 0000000 0000000 00000000000 15172120304 015072 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_tests-vintf_1_.hash0100644 0000000 0000000 00000000034 15172120304 021007 xustar000000000 0000000 28 mtime=1776853188.3210000 build/aidl_api/tests-vintf/1/.hash0100644 0000000 0000000 00000000051 15172120304 016007 0ustar000000000 0000000 76be80502c7d4b9097cbed126e03a5a618c4cca3 ./PaxHeaders.X/build_aidl_api_tests-vintf_1_vintf_0100644 0000000 0000000 00000000034 15172120304 021273 xustar000000000 0000000 28 mtime=1776853188.3210000 build/aidl_api/tests-vintf/1/vintf/0040755 0000000 0000000 00000000000 15172120304 016220 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_tests-vintf_1_vintf_IFoo.aidl0100644 0000000 0000000 00000000034 15172120304 022760 xustar000000000 0000000 28 mtime=1776853188.3210000 build/aidl_api/tests-vintf/1/vintf/IFoo.aidl0100644 0000000 0000000 00000004016 15172120304 017705 0ustar000000000 0000000 /* * Copyright (C) 2022 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. */ /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL file. Do not edit it manually. There are // two cases: // 1). this is a frozen version file - do not edit this in any case. // 2). this is a 'current' file. If you make a backwards compatible change to // the interface (from the latest frozen version), the build system will // prompt you to update this file with `m -update-api`. // // You must not make a backward incompatible change to any AIDL file built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package vintf; @VintfStability interface IFoo { vintf.IFoo.Foo[] abar(in vintf.IFoo.Foo[] f); ParcelFileDescriptor afd(in ParcelFileDescriptor fd); vintf.IFoo.E ae(in vintf.IFoo.E e); vintf.IFoo.A aa(in vintf.IFoo.A a); parcelable Foo { String a; } union A { String a; int b; } enum E { A = 0, B = 1, C = 2, } } ./PaxHeaders.X/build_aidl_api_tests-vintf_current_0100644 0000000 0000000 00000000034 15172120304 021407 xustar000000000 0000000 28 mtime=1776853188.3210000 build/aidl_api/tests-vintf/current/0040755 0000000 0000000 00000000000 15172120304 016414 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_tests-vintf_current_vintf_0100644 0000000 0000000 00000000034 15172120304 022615 xustar000000000 0000000 28 mtime=1776853188.3210000 build/aidl_api/tests-vintf/current/vintf/0040755 0000000 0000000 00000000000 15172120304 017542 5ustar000000000 0000000 ./PaxHeaders.X/build_aidl_api_tests-vintf_current_vintf_IFoo.aidl0100644 0000000 0000000 00000000034 15172120304 024302 xustar000000000 0000000 28 mtime=1776853188.3210000 build/aidl_api/tests-vintf/current/vintf/IFoo.aidl0100644 0000000 0000000 00000004016 15172120304 021227 0ustar000000000 0000000 /* * Copyright (C) 2022 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. */ /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL file. Do not edit it manually. There are // two cases: // 1). this is a frozen version file - do not edit this in any case. // 2). this is a 'current' file. If you make a backwards compatible change to // the interface (from the latest frozen version), the build system will // prompt you to update this file with `m -update-api`. // // You must not make a backward incompatible change to any AIDL file built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package vintf; @VintfStability interface IFoo { vintf.IFoo.Foo[] abar(in vintf.IFoo.Foo[] f); ParcelFileDescriptor afd(in ParcelFileDescriptor fd); vintf.IFoo.E ae(in vintf.IFoo.E e); vintf.IFoo.A aa(in vintf.IFoo.A a); parcelable Foo { String a; } union A { String a; int b; } enum E { A = 0, B = 1, C = 2, } } ./PaxHeaders.X/build_aidl_gen_rule.go0100644 0000000 0000000 00000000034 15172120304 016573 xustar000000000 0000000 28 mtime=1776853188.3210000 build/aidl_gen_rule.go0100644 0000000 0000000 00000031172 15172120304 014023 0ustar000000000 0000000 // Copyright (C) 2021 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. package aidl import ( "android/soong/android" "android/soong/genrule" "strconv" "path/filepath" "strings" "github.com/google/blueprint" "github.com/google/blueprint/pathtools" "github.com/google/blueprint/proptools" ) var ( aidlDirPrepareRule = pctx.StaticRule("aidlDirPrepareRule", blueprint.RuleParams{ Command: `mkdir -p "${outDir}" && touch ${out} # ${in}`, Description: "create ${out}", }, "outDir") aidlCppRule = pctx.StaticRule("aidlCppRule", blueprint.RuleParams{ Command: `mkdir -p "${headerDir}" && ` + `mkdir -p "${outDir}/staging" && ` + `mkdir -p "${headerDir}/staging" && ` + `${aidlCmd} --lang=${lang} ${optionalFlags} --ninja -d ${outStagingFile}.d ` + `-h ${headerDir}/staging -o ${outDir}/staging ${imports} ${nextImports} ${in} && ` + `rsync --checksum ${outStagingFile}.d ${out}.d && ` + `rsync --checksum ${outStagingFile} ${out} && ` + `( [ -z "${stagingHeaders}" ] || rsync --checksum ${stagingHeaders} ${fullHeaderDir} ) && ` + `sed -i 's/\/gen\/staging\//\/gen\//g' ${out}.d && ` + `rm ${outStagingFile} ${outStagingFile}.d ${stagingHeaders}`, Depfile: "${out}.d", Deps: blueprint.DepsGCC, CommandDeps: []string{"${aidlCmd}"}, Restat: true, Description: "AIDL ${lang} ${in}", }, "imports", "nextImports", "lang", "headerDir", "outDir", "optionalFlags", "stagingHeaders", "outStagingFile", "fullHeaderDir") aidlJavaRule = pctx.StaticRule("aidlJavaRule", blueprint.RuleParams{ Command: `${aidlCmd} --lang=java ${optionalFlags} --ninja -d ${out}.d ` + `-o ${outDir} ${imports} ${nextImports} ${in}`, Depfile: "${out}.d", Deps: blueprint.DepsGCC, CommandDeps: []string{"${aidlCmd}"}, Restat: true, Description: "AIDL Java ${in}", }, "imports", "nextImports", "outDir", "optionalFlags") aidlRustRule = pctx.StaticRule("aidlRustRule", blueprint.RuleParams{ Command: `${aidlCmd} --lang=rust ${optionalFlags} --ninja -d ${out}.d ` + `-o ${outDir} ${imports} ${nextImports} ${in}`, Depfile: "${out}.d", Deps: blueprint.DepsGCC, CommandDeps: []string{"${aidlCmd}"}, Restat: true, Description: "AIDL Rust ${in}", }, "imports", "nextImports", "outDir", "optionalFlags") ) type aidlGenProperties struct { Srcs []string `android:"path"` AidlRoot string // base directory for the input aidl file Imports []string Headers []string Stability *string Min_sdk_version *string Platform_apis bool Lang string // target language [java|cpp|ndk|rust] BaseName string GenLog bool Version string GenRpc bool GenTrace bool Unstable *bool NotFrozen bool RequireFrozenReason string Visibility []string Flags []string UseUnfrozen bool } type aidlGenRule struct { android.ModuleBase properties aidlGenProperties deps deps implicitInputs android.Paths importFlags string nextImportFlags string // A frozen aidl_interface always have a hash file hashFile android.Path genOutDir android.ModuleGenPath genHeaderDir android.ModuleGenPath genHeaderDeps android.Paths genOutputs android.WritablePaths } var _ android.SourceFileProducer = (*aidlGenRule)(nil) var _ genrule.SourceFileGenerator = (*aidlGenRule)(nil) func (g *aidlGenRule) aidlInterface(ctx android.BaseModuleContext) *aidlInterface { return ctx.GetDirectDepWithTag(g.properties.BaseName, interfaceDep).(*aidlInterface) } func (g *aidlGenRule) getImports(ctx android.ModuleContext) map[string]string { iface := g.aidlInterface(ctx) return iface.getImports(g.properties.Version) } func (g *aidlGenRule) GenerateAndroidBuildActions(ctx android.ModuleContext) { srcs, nextImports := getPaths(ctx, g.properties.Srcs, g.properties.AidlRoot) g.deps = getDeps(ctx, g.getImports(ctx)) if ctx.Failed() { return } genDirTimestamp := android.PathForModuleGen(ctx, "timestamp") // $out/gen/timestamp g.implicitInputs = append(g.implicitInputs, genDirTimestamp) g.implicitInputs = append(g.implicitInputs, g.deps.implicits...) g.implicitInputs = append(g.implicitInputs, g.deps.preprocessed...) g.nextImportFlags = strings.Join(wrap("-N", nextImports, ""), " ") g.importFlags = strings.Join(wrap("-I", g.deps.imports, ""), " ") g.genOutDir = android.PathForModuleGen(ctx) g.genHeaderDir = android.PathForModuleGen(ctx, "include") for _, src := range srcs { outFile, headers := g.generateBuildActionsForSingleAidl(ctx, src) g.genOutputs = append(g.genOutputs, outFile) g.genHeaderDeps = append(g.genHeaderDeps, headers...) } // This is to clean genOutDir before generating any file ctx.Build(pctx, android.BuildParams{ Rule: aidlDirPrepareRule, Inputs: srcs, Output: genDirTimestamp, Args: map[string]string{ "outDir": g.genOutDir.String(), }, }) // This is to trigger genrule alone ctx.Build(pctx, android.BuildParams{ Rule: android.Phony, Output: android.PathForModuleOut(ctx, "timestamp"), // $out/timestamp Inputs: g.genOutputs.Paths(), }) } func (g *aidlGenRule) generateBuildActionsForSingleAidl(ctx android.ModuleContext, src android.Path) (android.WritablePath, android.Paths) { relPath := src.Rel() baseDir := strings.TrimSuffix(strings.TrimSuffix(src.String(), relPath), "/") var ext string if g.properties.Lang == langJava { ext = "java" } else if g.properties.Lang == langRust { ext = "rs" } else { ext = "cpp" } outFile := android.PathForModuleGen(ctx, pathtools.ReplaceExtension(relPath, ext)) outStagingFile := android.PathForModuleGen(ctx, pathtools.ReplaceExtension("staging/"+relPath, ext)) implicits := g.implicitInputs // default version is 1 for any stable interface version := "1" previousVersion := "" previousApiDir := "" if g.properties.Version != "" { version = g.properties.Version } versionInt, err := strconv.Atoi(version) if err != nil && g.properties.Version != "" { ctx.PropertyErrorf(g.properties.Version, "Invalid Version string: %s", g.properties.Version) } else if err == nil && versionInt > 1 { previousVersion = strconv.Itoa(versionInt - 1) previousApiDir = filepath.Join(ctx.ModuleDir(), aidlApiDir, g.properties.BaseName, previousVersion) } optionalFlags := append([]string{}, g.properties.Flags...) if proptools.Bool(g.properties.Unstable) != true { optionalFlags = append(optionalFlags, "--structured") optionalFlags = append(optionalFlags, "--version "+version) hash := "notfrozen" if !strings.HasPrefix(baseDir, ctx.Config().SoongOutDir()) { hashFile := android.ExistentPathForSource(ctx, baseDir, ".hash") if hashFile.Valid() { hash = "$$(tail -1 '" + hashFile.Path().String() + "')" implicits = append(implicits, hashFile.Path()) g.hashFile = hashFile.Path() } } optionalFlags = append(optionalFlags, "--hash "+hash) } if g.properties.GenRpc { optionalFlags = append(optionalFlags, "--rpc") } if g.properties.GenTrace { optionalFlags = append(optionalFlags, "-t") } if g.properties.Stability != nil { optionalFlags = append(optionalFlags, "--stability", *g.properties.Stability) } if g.properties.Platform_apis { optionalFlags = append(optionalFlags, "--min_sdk_version platform_apis") } else { minSdkVer := proptools.StringDefault(g.properties.Min_sdk_version, "current") optionalFlags = append(optionalFlags, "--min_sdk_version "+minSdkVer) } optionalFlags = append(optionalFlags, wrap("-p", g.deps.preprocessed.Strings(), "")...) // If this is an unfrozen version of a previously frozen interface, we want (1) the location // of the previously frozen source and (2) the previously frozen hash so the generated // library can behave like both versions at run time. if !g.properties.UseUnfrozen && previousVersion != "" && !proptools.Bool(g.properties.Unstable) && g.hashFile == nil { apiDirPath := android.ExistentPathForSource(ctx, previousApiDir) if apiDirPath.Valid() { optionalFlags = append(optionalFlags, "--previous_api_dir="+apiDirPath.Path().String()) } else { ctx.PropertyErrorf("--previous_api_dir is invalid: %s", apiDirPath.Path().String()) } hashFile := android.ExistentPathForSource(ctx, previousApiDir, ".hash") if hashFile.Valid() { previousHash := "$$(tail -1 '" + hashFile.Path().String() + "')" implicits = append(implicits, hashFile.Path()) optionalFlags = append(optionalFlags, "--previous_hash "+previousHash) } else { ctx.ModuleErrorf("Failed to find previous version's hash file in %s", previousApiDir) } } var headers android.WritablePaths if g.properties.Lang == langJava { ctx.Build(pctx, android.BuildParams{ Rule: aidlJavaRule, Input: src, Implicits: implicits, Output: outFile, Args: map[string]string{ "imports": g.importFlags, "nextImports": g.nextImportFlags, "outDir": g.genOutDir.String(), "optionalFlags": strings.Join(optionalFlags, " "), }, }) } else if g.properties.Lang == langRust { ctx.Build(pctx, android.BuildParams{ Rule: aidlRustRule, Input: src, Implicits: implicits, Output: outFile, Args: map[string]string{ "imports": g.importFlags, "nextImports": g.nextImportFlags, "outDir": g.genOutDir.String(), "optionalFlags": strings.Join(optionalFlags, " "), }, }) } else { typeName := strings.TrimSuffix(filepath.Base(relPath), ".aidl") packagePath := filepath.Dir(relPath) baseName := typeName // TODO(b/111362593): aidl_to_cpp_common.cpp uses heuristics to figure out if // an interface name has a leading I. Those same heuristics have been // moved here. if len(baseName) >= 2 && baseName[0] == 'I' && strings.ToUpper(baseName)[1] == baseName[1] { baseName = strings.TrimPrefix(typeName, "I") } prefix := "" if g.properties.Lang == langNdk || g.properties.Lang == langNdkPlatform { prefix = "aidl" } var stagingHeaders []string var fullHeaderDir = g.genHeaderDir.Join(ctx, prefix, packagePath) if g.properties.Lang != langCppAnalyzer { headers = append(headers, g.genHeaderDir.Join(ctx, prefix, packagePath, typeName+".h")) stagingHeaders = append(stagingHeaders, g.genHeaderDir.Join(ctx, "staging/"+prefix, packagePath, typeName+".h").String()) headers = append(headers, g.genHeaderDir.Join(ctx, prefix, packagePath, "Bp"+baseName+".h")) stagingHeaders = append(stagingHeaders, g.genHeaderDir.Join(ctx, "staging/"+prefix, packagePath, "Bp"+baseName+".h").String()) headers = append(headers, g.genHeaderDir.Join(ctx, prefix, packagePath, "Bn"+baseName+".h")) stagingHeaders = append(stagingHeaders, g.genHeaderDir.Join(ctx, "staging/"+prefix, packagePath, "Bn"+baseName+".h").String()) } if g.properties.GenLog { optionalFlags = append(optionalFlags, "--log") } aidlLang := g.properties.Lang if aidlLang == langNdkPlatform { aidlLang = "ndk" } ctx.Build(pctx, android.BuildParams{ Rule: aidlCppRule, Input: src, Implicits: implicits, Output: outFile, ImplicitOutputs: headers, Args: map[string]string{ "imports": g.importFlags, "nextImports": g.nextImportFlags, "lang": aidlLang, "headerDir": g.genHeaderDir.String(), "fullHeaderDir": fullHeaderDir.String(), "outDir": g.genOutDir.String(), "outStagingFile": outStagingFile.String(), "optionalFlags": strings.Join(optionalFlags, " "), "stagingHeaders": strings.Join(stagingHeaders, " "), }, }) } return outFile, headers.Paths() } func (g *aidlGenRule) GeneratedSourceFiles() android.Paths { return g.genOutputs.Paths() } func (g *aidlGenRule) Srcs() android.Paths { return g.genOutputs.Paths() } func (g *aidlGenRule) GeneratedDeps() android.Paths { return g.genHeaderDeps } func (g *aidlGenRule) GeneratedHeaderDirs() android.Paths { return android.Paths{g.genHeaderDir} } func (g *aidlGenRule) DepsMutator(ctx android.BottomUpMutatorContext) { ctx.AddReverseDependency(ctx.Module(), nil, aidlMetadataSingletonName) } func aidlGenFactory() android.Module { g := &aidlGenRule{} g.AddProperties(&g.properties) android.InitAndroidModule(g) return g } ./PaxHeaders.X/build_aidl_interface.go0100644 0000000 0000000 00000000034 15172120304 016733 xustar000000000 0000000 28 mtime=1776853188.3220000 build/aidl_interface.go0100644 0000000 0000000 00000121225 15172120304 014162 0ustar000000000 0000000 // Copyright (C) 2018 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package aidl import ( "android/soong/android" "android/soong/cc" "android/soong/java" "android/soong/rust" "fmt" "path/filepath" "regexp" "sort" "strconv" "strings" "github.com/google/blueprint" "github.com/google/blueprint/proptools" ) const ( aidlInterfaceSuffix = "_interface" aidlMetadataSingletonName = "aidl_metadata_json" aidlApiDir = "aidl_api" aidlApiSuffix = "-api" langCpp = "cpp" langJava = "java" langNdk = "ndk" langRust = "rust" langCppAnalyzer = "cpp-analyzer" // TODO(b/161456198) remove the NDK platform backend as the 'platform' variant of the NDK // backend serves the same purpose. langNdkPlatform = "ndk_platform" currentVersion = "current" ) var pctx = android.NewPackageContext("android/aidl") func init() { pctx.Import("android/soong/android") pctx.HostBinToolVariable("aidlCmd", "aidl") pctx.HostBinToolVariable("aidlHashGen", "aidl_hash_gen") pctx.SourcePathVariable("aidlToJniCmd", "system/tools/aidl/build/aidl_to_jni.py") pctx.SourcePathVariable("aidlRustGlueCmd", "system/tools/aidl/build/aidl_rust_glue.py") android.RegisterModuleType("aidl_interface", AidlInterfaceFactory) android.PreArchMutators(registerPreArchMutators) android.PostDepsMutators(registerPostDepsMutators) } func registerPreArchMutators(ctx android.RegisterMutatorsContext) { ctx.BottomUp("addInterfaceDeps", addInterfaceDeps).Parallel() ctx.BottomUp("checkImports", checkImports).Parallel() ctx.TopDown("createAidlInterface", createAidlInterfaceMutator).Parallel() } func registerPostDepsMutators(ctx android.RegisterMutatorsContext) { ctx.BottomUp("checkAidlGeneratedModules", checkAidlGeneratedModules).Parallel() } func createAidlInterfaceMutator(mctx android.TopDownMutatorContext) { if g, ok := mctx.Module().(*aidlImplementationGenerator); ok { g.GenerateImplementation(mctx) } } // A marker struct for AIDL-generated library modules type AidlGeneratedModuleProperties struct{} func wrapLibraryFactory(factory func() android.Module) func() android.Module { return func() android.Module { m := factory() // put a marker struct for AIDL-generated modules m.AddProperties(&AidlGeneratedModuleProperties{}) return m } } func isAidlGeneratedModule(module android.Module) bool { for _, props := range module.GetProperties() { // check if there's a marker struct if _, ok := props.(*AidlGeneratedModuleProperties); ok { return true } } return false } // AidlVersionInfo keeps the *-source module for each (aidl_interface & lang) and the list of // not-frozen versions (which shouldn't be used by other modules) type AidlVersionInfo struct { notFrozen []string requireFrozenReasons []string sourceMap map[string]string } var AidlVersionInfoProvider = blueprint.NewMutatorProvider[AidlVersionInfo]("checkAidlGeneratedModules") // Merges `other` version info into this one. // Returns the pair of mismatching versions when there's conflict. Otherwise returns nil. // For example, when a module depends on 'foo-V2-ndk', the map contains an entry of (foo, foo-V2-ndk-source). // Merging (foo, foo-V1-ndk-source) and (foo, foo-V2-ndk-source) will fail and returns // {foo-V1-ndk-source, foo-V2-ndk-source}. func (info *AidlVersionInfo) merge(other AidlVersionInfo) []string { info.notFrozen = append(info.notFrozen, other.notFrozen...) info.requireFrozenReasons = append(info.requireFrozenReasons, other.requireFrozenReasons...) if other.sourceMap == nil { return nil } if info.sourceMap == nil { info.sourceMap = make(map[string]string) } for ifaceName, otherSourceName := range other.sourceMap { if sourceName, ok := info.sourceMap[ifaceName]; ok { if sourceName != otherSourceName { return []string{sourceName, otherSourceName} } } else { info.sourceMap[ifaceName] = otherSourceName } } return nil } func reportUsingNotFrozenError(ctx android.BaseModuleContext, notFrozen []string, requireFrozenReason []string) { // TODO(b/154066686): Replace it with a common method instead of listing up module types. // Test libraries are exempted. if android.InList(ctx.ModuleType(), []string{"cc_test_library", "android_test", "cc_benchmark", "cc_test"}) { return } for i, name := range notFrozen { reason := requireFrozenReason[i] ctx.ModuleErrorf("%v is an unfrozen development version, and it can't be used because %q", name, reason) } } func reportMultipleVersionError(ctx android.BaseModuleContext, violators []string) { sort.Strings(violators) ctx.ModuleErrorf("depends on multiple versions of the same aidl_interface: %s", strings.Join(violators, ", ")) ctx.WalkDeps(func(child android.Module, parent android.Module) bool { if android.InList(child.Name(), violators) { ctx.ModuleErrorf("Dependency path: %s", ctx.GetPathString(true)) return false } return true }) } func checkAidlGeneratedModules(mctx android.BottomUpMutatorContext) { switch mctx.Module().(type) { case *java.Library: case *cc.Module: case *rust.Module: case *aidlGenRule: default: return } if gen, ok := mctx.Module().(*aidlGenRule); ok { var notFrozen []string var requireFrozenReasons []string if gen.properties.NotFrozen { notFrozen = []string{strings.TrimSuffix(mctx.ModuleName(), "-source")} requireFrozenReasons = []string{gen.properties.RequireFrozenReason} } android.SetProvider(mctx, AidlVersionInfoProvider, AidlVersionInfo{ notFrozen: notFrozen, requireFrozenReasons: requireFrozenReasons, sourceMap: map[string]string{ gen.properties.BaseName + "-" + gen.properties.Lang: gen.Name(), }, }) return } // Collect/merge AidlVersionInfos from direct dependencies var info AidlVersionInfo mctx.VisitDirectDeps(func(dep android.Module) { if otherInfo, ok := android.OtherModuleProvider(mctx, dep, AidlVersionInfoProvider); ok { if violators := info.merge(otherInfo); violators != nil { reportMultipleVersionError(mctx, violators) } } }) if !isAidlGeneratedModule(mctx.Module()) && len(info.notFrozen) > 0 { reportUsingNotFrozenError(mctx, info.notFrozen, info.requireFrozenReasons) } if mctx.Failed() { return } if info.sourceMap != nil || len(info.notFrozen) > 0 { android.SetProvider(mctx, AidlVersionInfoProvider, info) } } func getPaths(ctx android.ModuleContext, rawSrcs []string, root string) (srcs android.Paths, imports []string) { // TODO(b/189288369): move this to android.PathsForModuleSrcSubDir(ctx, srcs, subdir) for _, src := range rawSrcs { if m, _ := android.SrcIsModuleWithTag(src); m != "" { srcs = append(srcs, android.PathsForModuleSrc(ctx, []string{src})...) } else { srcs = append(srcs, android.PathsWithModuleSrcSubDir(ctx, android.PathsForModuleSrc(ctx, []string{src}), root)...) } } if len(srcs) == 0 { ctx.PropertyErrorf("srcs", "No sources provided in %v", root) } // gather base directories from input .aidl files for _, src := range srcs { if src.Ext() != ".aidl" { // Silently ignore non-aidl files as some filegroups have both java and aidl files together continue } baseDir := strings.TrimSuffix(src.String(), src.Rel()) baseDir = strings.TrimSuffix(baseDir, "/") if baseDir != "" && !android.InList(baseDir, imports) { imports = append(imports, baseDir) } } return srcs, imports } func isRelativePath(path string) bool { if path == "" { return true } return filepath.Clean(path) == path && path != ".." && !strings.HasPrefix(path, "../") && !strings.HasPrefix(path, "/") } type CommonBackendProperties struct { // Whether to generate code in the corresponding backend. // Default: // - for Java/NDK/CPP backends - True // - for Rust backend - False Enabled *bool Apex_available []string // The minimum version of the sdk that the compiled artifacts will run against // For native modules, the property needs to be set when a module is a part of mainline modules(APEX). // Forwarded to generated java/native module. Min_sdk_version *string // Whether tracing should be added to the interface. Gen_trace *bool } type CommonNativeBackendProperties struct { CommonBackendProperties // Must be NDK libraries, for stable types. Additional_shared_libraries []string // cflags to forward to native compilation. This is expected to be // used more for AIDL compiler developers than being actually // practical. Cflags []string // linker flags to forward to native compilation. This is expected // to be more useful for AIDL compiler developers than being // practical Ldflags []string // Whether to generate additional code for gathering information // about the transactions. // Default: false Gen_log *bool // VNDK properties for corresponding backend. cc.VndkProperties } type DumpApiProperties struct { // Dumps without license header (assuming it is the first comment in .aidl file). Default: false No_license *bool } type aidlInterfaceProperties struct { // Vndk properties for C++/NDK libraries only (preferred to use backend-specific settings) cc.VndkProperties // How to interpret VNDK options. We only want one library in the VNDK (not multiple // versions, since this would be a waste of space/unclear, and ultimately we want all // code in a given release to be updated to use a specific version). By default, this // puts either the latest stable version of the library or, if there is no stable // version, the unstable version of the library in the VNDK. When using this field, // explicitly set it to one of the values in the 'versions' field to put that version // in the VNDK or set it to the next version (1 higher than this) to mean the version // that will be frozen in the next update. Vndk_use_version *string // Whether the library can be installed on the vendor image. Vendor_available *bool // Whether the library can be installed on the odm image. Odm_available *bool // Whether the library can be installed on the product image. Product_available *bool // Whether the library can be installed on the recovery image. Recovery_available *bool // Whether the library can be loaded multiple times into the same process Double_loadable *bool // Whether the library can be used on host Host_supported *bool // Whether tracing should be added to the interface. Gen_trace *bool // Top level directories for includes. // TODO(b/128940869): remove it if aidl_interface can depend on framework.aidl Include_dirs []string // Relative path for includes. By default assumes AIDL path is relative to current directory. Local_include_dir string // List of .aidl files which compose this interface. Srcs []string `android:"path"` // Normally, in release configurations, such as next, unfrozen AIDL // interfaces may be disabled. However, for some partners developing // on Android, they may prefer to use the release configuration // while making a small amount of changes for development. In this // case, the VTS test vts_treble_vintf_vendor_test would still fail. // However, the build would be unblocked. // // Note: this will not work for AOSP android.* interfaces because they // will not be available in the compatibility matrix. Always_use_unfrozen *bool // List of aidl_interface modules that this uses. If one of your AIDL interfaces uses an // interface or parcelable from another aidl_interface, you should put its name here. // It could be an aidl_interface solely or with version(such as -V1) Imports []string // Stability promise. Currently only supports "vintf". // If this is unset, this corresponds to an interface with stability within // this compilation context (so an interface loaded here can only be used // with things compiled together, e.g. on the system.img). // If this is set to "vintf", this corresponds to a stability promise: the // interface must be kept stable as long as it is used. Stability *string // If true, this interface is frozen and does not have any changes since the last // frozen version. // If false, there are changes to this interface between the last frozen version (N) and // the current version (N + 1). Frozen *bool // Deprecated: Use `versions_with_info` instead. Don't use `versions` property directly. Versions []string // Previous API versions that are now frozen. The version that is last in // the list is considered as the most recent version. // The struct contains both version and imports information per a version. // Until versions property is removed, don't use `versions_with_info` directly. Versions_with_info []struct { Version string Imports []string } // Use aidlInterface.getVersions() VersionsInternal []string `blueprint:"mutated"` // The minimum version of the sdk that the compiled artifacts will run against // For native modules, the property needs to be set when a module is a part of mainline modules(APEX). // Forwarded to generated java/native module. This can be overridden by // backend..min_sdk_version. Min_sdk_version *string Backend struct { // Backend of the compiler generating code for Java clients. // When enabled, this creates a target called "-java". Java struct { CommonBackendProperties // Additional java libraries, for unstructured parcelables Additional_libs []string // Set to the version of the sdk to compile against // Default: system_current Sdk_version *string // Whether to compile against platform APIs instead of // an SDK. Platform_apis *bool // Whether RPC features are enabled (requires API level 32) // TODO(b/175819535): enable this automatically? Gen_rpc *bool // Lint properties for generated java module java.LintProperties } // Backend of the compiler generating code for C++ clients using // libbinder (unstable C++ interface) // When enabled, this creates a target called "-cpp". Cpp struct { CommonNativeBackendProperties } // Backend of the compiler generating code for C++ clients using libbinder_ndk // (stable C interface to system's libbinder) When enabled, this creates a target // called "-V-ndk" (for both apps and platform) and // "-V-ndk_platform" (for platform only). // TODO(b/161456198): remove the ndk_platform backend as the ndk backend can serve // the same purpose. Ndk struct { CommonNativeBackendProperties // Set to the version of the sdk to compile against, for the NDK // variant. // Default: current Sdk_version *string // If set to false, the ndk backend is exclusive to platform and is not // available to applications. Default is true (i.e. available to both // applications and platform). Apps_enabled *bool } // Backend of the compiler generating code for Rust clients. // When enabled, this creates a target called "-rust". Rust struct { CommonBackendProperties // Rustlibs needed for unstructured parcelables. Additional_rustlibs []string } } // Marks that this interface does not need to be stable. When set to true, the build system // doesn't create the API dump and require it to be updated. Default is false. Unstable *bool // Optional flags to be passed to the AIDL compiler for diagnostics. e.g. "-Weverything" Flags []string // --dumpapi options Dumpapi DumpApiProperties // List of aidl_library modules that provide aidl headers for the AIDL tool. Headers []string } type aidlInterface struct { android.ModuleBase android.DefaultableModuleBase properties aidlInterfaceProperties computedTypes []string // list of module names that are created for this interface internalModuleNames []string // map for version to preprocessed.aidl file. // There's two additional alias for versions: // - ""(empty) is for ToT // - "latest" is for i.latestVersion() preprocessed map[string]android.WritablePath } func (i *aidlInterface) shouldGenerateJavaBackend() bool { // explicitly true if not specified to give early warning to devs return proptools.BoolDefault(i.properties.Backend.Java.Enabled, true) } func (i *aidlInterface) shouldGenerateCppBackend() bool { // explicitly true if not specified to give early warning to devs return proptools.BoolDefault(i.properties.Backend.Cpp.Enabled, true) } func (i *aidlInterface) shouldGenerateNdkBackend() bool { // explicitly true if not specified to give early warning to devs return proptools.BoolDefault(i.properties.Backend.Ndk.Enabled, true) } // Returns whether the ndk backend supports applications or not. Default is `true`. `false` is // returned when `apps_enabled` is explicitly set to false or the interface is exclusive to vendor // (i.e. `vendor: true`). Note that the ndk_platform backend (which will be removed in the future) // is not affected by this. In other words, it is always exclusive for the platform, as its name // clearly shows. func (i *aidlInterface) shouldGenerateAppNdkBackend() bool { return i.shouldGenerateNdkBackend() && proptools.BoolDefault(i.properties.Backend.Ndk.Apps_enabled, true) && !i.SocSpecific() } func (i *aidlInterface) shouldGenerateRustBackend() bool { // explicitly true if not specified to give early warning to devs return proptools.BoolDefault(i.properties.Backend.Rust.Enabled, true) } func (i *aidlInterface) useUnfrozen(ctx android.EarlyModuleContext) bool { var use_unfrozen bool unfrozen_override := ctx.Config().Getenv("AIDL_USE_UNFROZEN_OVERRIDE") if unfrozen_override != "" { if unfrozen_override == "true" { use_unfrozen = true } else if unfrozen_override == "false" { use_unfrozen = false } else { ctx.PropertyErrorf("AIDL_USE_UNFROZEN_OVERRIDE has unexpected value of \"%s\". Should be \"true\" or \"false\".", unfrozen_override) } } else { use_unfrozen = ctx.DeviceConfig().Release_aidl_use_unfrozen() } // could check this earlier and return, but make sure we always verify // environmental variables if proptools.Bool(i.properties.Always_use_unfrozen) { use_unfrozen = true } return use_unfrozen } func (i *aidlInterface) minSdkVersion(lang string) *string { var ver *string switch lang { case langCpp: ver = i.properties.Backend.Cpp.Min_sdk_version case langJava: ver = i.properties.Backend.Java.Min_sdk_version case langNdk, langNdkPlatform: ver = i.properties.Backend.Ndk.Min_sdk_version case langRust: ver = i.properties.Backend.Rust.Min_sdk_version default: panic(fmt.Errorf("unsupported language backend %q\n", lang)) } if ver == nil { return i.properties.Min_sdk_version } return ver } func (i *aidlInterface) genTrace(lang string) bool { var ver *bool switch lang { case langCpp: ver = i.properties.Backend.Cpp.Gen_trace if ver == nil { // Enable tracing for all cpp backends by default ver = proptools.BoolPtr(true) } case langJava: ver = i.properties.Backend.Java.Gen_trace if ver == nil && proptools.Bool(i.properties.Backend.Java.Platform_apis) { // Enable tracing for all Java backends using platform APIs // TODO(161393989) Once we generate ATRACE_TAG_APP instead of ATRACE_TAG_AIDL, // this can be removed and we can start generating traces in all apps. ver = proptools.BoolPtr(true) } case langNdk, langNdkPlatform: ver = i.properties.Backend.Ndk.Gen_trace case langRust: // unsupported b/236880829 ver = i.properties.Backend.Rust.Gen_trace case langCppAnalyzer: *ver = false default: panic(fmt.Errorf("unsupported language backend %q\n", lang)) } if ver == nil { ver = i.properties.Gen_trace } return proptools.Bool(ver) } // Dep to *-api module(aidlApi) type apiDepTag struct { blueprint.BaseDependencyTag name string } type importInterfaceDepTag struct { blueprint.BaseDependencyTag anImport string } type interfaceDepTag struct { blueprint.BaseDependencyTag } type interfaceHeadersDepTag struct { blueprint.BaseDependencyTag } var ( // Dep from *-source (aidlGenRule) to *-api (aidlApi) apiDep = apiDepTag{name: "api"} // Dep from *-api (aidlApi) to *-api (aidlApi), representing imported interfaces importApiDep = apiDepTag{name: "imported-api"} // Dep to original *-interface (aidlInterface) interfaceDep = interfaceDepTag{} // Dep for a header interface interfaceHeadersDep = interfaceHeadersDepTag{} ) func addImportedInterfaceDeps(ctx android.BottomUpMutatorContext, imports []string) { for _, anImport := range imports { name, _ := parseModuleWithVersion(anImport) ctx.AddDependency(ctx.Module(), importInterfaceDepTag{anImport: anImport}, name+aidlInterfaceSuffix) } } // Run custom "Deps" mutator between AIDL modules created at LoadHook stage. // We can't use the "DepsMutator" for these dependencies because // - We need to create library modules (cc/java/...) before "arch" mutator. Note that cc_library // // should be mutated by os/image/arch mutators as well. // // - When creating library modules, we need to access the original interface and its imported // // interfaces to determine which version to use. See aidlInterface.getImportWithVersion. func addInterfaceDeps(mctx android.BottomUpMutatorContext) { switch i := mctx.Module().(type) { case *aidlInterface: // In fact this isn't necessary because soong checks dependencies on undefined modules. // But since aidl_interface overrides its name internally, this provides better error message. for _, anImportWithVersion := range i.properties.Imports { anImport, _ := parseModuleWithVersion(anImportWithVersion) if !mctx.OtherModuleExists(anImport + aidlInterfaceSuffix) { if !mctx.Config().AllowMissingDependencies() { mctx.PropertyErrorf("imports", "Import does not exist: "+anImport) } } } if mctx.Failed() { return } addImportedInterfaceDeps(mctx, i.properties.Imports) for _, header := range i.properties.Headers { mctx.AddDependency(i, interfaceHeadersDep, header) } case *aidlImplementationGenerator: mctx.AddDependency(i, interfaceDep, i.properties.AidlInterfaceName+aidlInterfaceSuffix) addImportedInterfaceDeps(mctx, i.properties.Imports) case *rust.Module: for _, props := range i.GetProperties() { if sp, ok := props.(*aidlRustSourceProviderProperties); ok { mctx.AddDependency(i, interfaceDep, sp.AidlInterfaceName+aidlInterfaceSuffix) addImportedInterfaceDeps(mctx, sp.Imports) break } } case *aidlApi: mctx.AddDependency(i, interfaceDep, i.properties.BaseName+aidlInterfaceSuffix) addImportedInterfaceDeps(mctx, i.properties.Imports) for _, anImport := range i.properties.Imports { name, _ := parseModuleWithVersion(anImport) mctx.AddDependency(i, importApiDep, name+aidlApiSuffix) } for _, header := range i.properties.Headers { mctx.AddDependency(i, interfaceHeadersDep, header) } case *aidlGenRule: mctx.AddDependency(i, interfaceDep, i.properties.BaseName+aidlInterfaceSuffix) addImportedInterfaceDeps(mctx, i.properties.Imports) if !proptools.Bool(i.properties.Unstable) { // for checkapi timestamps mctx.AddDependency(i, apiDep, i.properties.BaseName+aidlApiSuffix) } for _, header := range i.properties.Headers { mctx.AddDependency(i, interfaceHeadersDep, header) } } } // checkImports checks if "import:" property is valid. // In fact, this isn't necessary because Soong can check/report when we add a dependency to // undefined/unknown module. But module names are very implementation specific and may not be easy // to understand. For example, when foo (with java enabled) depends on bar (with java disabled), the // error message would look like "foo-V2-java depends on unknown module `bar-V3-java`", which isn't // clear that backend.java.enabled should be turned on. func checkImports(mctx android.BottomUpMutatorContext) { if i, ok := mctx.Module().(*aidlInterface); ok { mctx.VisitDirectDeps(func(dep android.Module) { tag, ok := mctx.OtherModuleDependencyTag(dep).(importInterfaceDepTag) if !ok { return } other := dep.(*aidlInterface) anImport := other.ModuleBase.Name() anImportWithVersion := tag.anImport _, version := parseModuleWithVersion(tag.anImport) candidateVersions := other.getVersions() if !proptools.Bool(other.properties.Frozen) { candidateVersions = concat(candidateVersions, []string{other.nextVersion()}) } if version == "" { if !proptools.Bool(other.properties.Unstable) { mctx.PropertyErrorf("imports", "%q depends on %q but does not specify a version (must be one of %q)", i.ModuleBase.Name(), anImport, candidateVersions) } } else { if !android.InList(version, candidateVersions) { mctx.PropertyErrorf("imports", "%q depends on %q version %q(%q), which doesn't exist. The version must be one of %q", i.ModuleBase.Name(), anImport, version, anImportWithVersion, candidateVersions) } } if i.shouldGenerateJavaBackend() && !other.shouldGenerateJavaBackend() { mctx.PropertyErrorf("backend.java.enabled", "Java backend not enabled in the imported AIDL interface %q", anImport) } if i.shouldGenerateCppBackend() && !other.shouldGenerateCppBackend() { mctx.PropertyErrorf("backend.cpp.enabled", "C++ backend not enabled in the imported AIDL interface %q", anImport) } if i.shouldGenerateNdkBackend() && !other.shouldGenerateNdkBackend() { mctx.PropertyErrorf("backend.ndk.enabled", "NDK backend not enabled in the imported AIDL interface %q", anImport) } if i.shouldGenerateRustBackend() && !other.shouldGenerateRustBackend() { mctx.PropertyErrorf("backend.rust.enabled", "Rust backend not enabled in the imported AIDL interface %q", anImport) } if i.isFrozen() && other.isExplicitlyUnFrozen() && version == "" { mctx.PropertyErrorf("frozen", "%q imports %q which is not frozen. Either %q must set 'frozen: false' or must explicitly import %q where * is one of %q", i.ModuleBase.Name(), anImport, i.ModuleBase.Name(), anImport+"-V*", candidateVersions) } if i.Owner() == "" && other.Owner() != "" { mctx.PropertyErrorf("imports", "%q imports %q which is an interface owned by %q. This is not allowed because the owned interface will not be frozen at the same time.", i.ModuleBase.Name(), anImport, other.Owner()) } }) } } func (i *aidlInterface) checkGenTrace(mctx android.DefaultableHookContext) { if !proptools.Bool(i.properties.Gen_trace) { return } if i.shouldGenerateJavaBackend() && !proptools.Bool(i.properties.Backend.Java.Platform_apis) { mctx.PropertyErrorf("gen_trace", "must be false when Java backend is enabled and platform_apis is false") } } func (i *aidlInterface) checkStability(mctx android.DefaultableHookContext) { if i.properties.Stability == nil { return } if proptools.Bool(i.properties.Unstable) { mctx.PropertyErrorf("stability", "must be empty when \"unstable\" is true") } // TODO(b/136027762): should we allow more types of stability (e.g. for APEX) or // should we switch this flag to be something like "vintf { enabled: true }" isVintf := "vintf" == proptools.String(i.properties.Stability) if !isVintf { mctx.PropertyErrorf("stability", "must be empty or \"vintf\"") } } func (i *aidlInterface) checkVersions(mctx android.DefaultableHookContext) { if len(i.properties.Versions) > 0 && len(i.properties.Versions_with_info) > 0 { mctx.ModuleErrorf("versions:%q and versions_with_info:%q cannot be used at the same time. Use versions_with_info instead of versions.", i.properties.Versions, i.properties.Versions_with_info) } if len(i.properties.Versions) > 0 { i.properties.VersionsInternal = make([]string, len(i.properties.Versions)) copy(i.properties.VersionsInternal, i.properties.Versions) } else if len(i.properties.Versions_with_info) > 0 { i.properties.VersionsInternal = make([]string, len(i.properties.Versions_with_info)) for idx, value := range i.properties.Versions_with_info { i.properties.VersionsInternal[idx] = value.Version for _, im := range value.Imports { if !hasVersionSuffix(im) { mctx.ModuleErrorf("imports in versions_with_info must specify its version, but %s. Add a version suffix(such as %s-V1).", im, im) return } } } } versions := make(map[string]bool) intVersions := make([]int, 0, len(i.getVersions())) for _, ver := range i.getVersions() { if _, dup := versions[ver]; dup { mctx.PropertyErrorf("versions", "duplicate found", ver) continue } versions[ver] = true n, err := strconv.Atoi(ver) if err != nil { mctx.PropertyErrorf("versions", "%q is not an integer", ver) continue } if n <= 0 { mctx.PropertyErrorf("versions", "should be > 0, but is %v", ver) continue } intVersions = append(intVersions, n) } if !mctx.Failed() && !sort.IntsAreSorted(intVersions) { mctx.PropertyErrorf("versions", "should be sorted, but is %v", i.getVersions()) } } func (i *aidlInterface) checkVndkUseVersion(mctx android.DefaultableHookContext) { if i.properties.Vndk_use_version == nil { return } if *i.properties.Vndk_use_version == i.nextVersion() { return } for _, ver := range i.getVersions() { if *i.properties.Vndk_use_version == ver { return } } mctx.PropertyErrorf("vndk_use_version", "Specified version %q does not exist", *i.properties.Vndk_use_version) } func (i *aidlInterface) checkFlags(mctx android.DefaultableHookContext) { for _, flag := range i.properties.Flags { if !strings.HasPrefix(flag, "-W") { mctx.PropertyErrorf("flags", "Unexpected flag type '%s'. Only flags starting with '-W' for diagnostics are supported.", flag) } } } func (i *aidlInterface) nextVersion() string { if proptools.Bool(i.properties.Unstable) { return "" } return nextVersion(i.getVersions()) } func nextVersion(versions []string) string { if len(versions) == 0 { return "1" } ver := versions[len(versions)-1] i, err := strconv.Atoi(ver) if err != nil { panic(err) } return strconv.Itoa(i + 1) } func (i *aidlInterface) latestVersion() string { if !i.hasVersion() { return "0" } return i.getVersions()[len(i.getVersions())-1] } func (i *aidlInterface) hasVersion() bool { return len(i.getVersions()) > 0 } func (i *aidlInterface) getVersions() []string { return i.properties.VersionsInternal } func (i *aidlInterface) isFrozen() bool { return proptools.Bool(i.properties.Frozen) } // in order to keep original behavior for certain operations, we may want to // check if frozen is set. func (i *aidlInterface) isExplicitlyUnFrozen() bool { return i.properties.Frozen != nil && !proptools.Bool(i.properties.Frozen) } func hasVersionSuffix(moduleName string) bool { hasVersionSuffix, _ := regexp.MatchString("-V\\d+$", moduleName) return hasVersionSuffix } func parseModuleWithVersion(moduleName string) (string, string) { if hasVersionSuffix(moduleName) { versionIdx := strings.LastIndex(moduleName, "-V") if versionIdx == -1 { panic("-V must exist in this context") } return moduleName[:versionIdx], moduleName[versionIdx+len("-V"):] } return moduleName, "" } func trimVersionSuffixInList(moduleNames []string) []string { return wrapFunc("", moduleNames, "", func(moduleName string) string { moduleNameWithoutVersion, _ := parseModuleWithVersion(moduleName) return moduleNameWithoutVersion }) } func (i *aidlInterface) checkRequireFrozenAndReason(mctx android.EarlyModuleContext) (bool, string) { if proptools.Bool(i.properties.Unstable) { return false, "it's an unstable interface" } if proptools.Bool(i.properties.Frozen) { return true, "it's explicitly marked as `frozen: true`" } if i.Owner() == "" { if mctx.Config().IsEnvTrue("AIDL_FROZEN_REL") { return true, "this is a release branch (simulated by setting AIDL_FROZEN_REL) - freeze it or set 'owners:'" } } else { // has an OWNER // These interfaces are verified by other tests like vts_treble_vintf_vendor_test // but this can be used to verify they are frozen at build time. if android.InList(i.Owner(), strings.Fields(mctx.Config().Getenv("AIDL_FROZEN_OWNERS"))) { return true, "the owner field is in environment variable AIDL_FROZEN_OWNERS" } } return false, "by default, we don't require the interface to be frozen" } func aidlInterfaceHook(mctx android.DefaultableHookContext, i *aidlInterface) { if hasVersionSuffix(i.ModuleBase.Name()) { mctx.PropertyErrorf("name", "aidl_interface should not have '-V suffix") } if !isRelativePath(i.properties.Local_include_dir) { mctx.PropertyErrorf("local_include_dir", "must be relative path: "+i.properties.Local_include_dir) } i.checkStability(mctx) i.checkVersions(mctx) i.checkVndkUseVersion(mctx) i.checkGenTrace(mctx) i.checkFlags(mctx) if mctx.Failed() { return } var libs []string unstable := proptools.Bool(i.properties.Unstable) if unstable { if i.hasVersion() { mctx.PropertyErrorf("versions", "cannot have versions for an unstable interface") return } if i.properties.Stability != nil { mctx.ModuleErrorf("unstable:true and stability:%q cannot happen at the same time", i.properties.Stability) return } } if i.isFrozen() { if !i.hasVersion() { mctx.PropertyErrorf("frozen", "cannot be frozen without versions") return } } if !unstable && mctx.Namespace().Path != "." && i.Owner() == "" { mctx.PropertyErrorf("owner", "aidl_interface in a soong_namespace must have the 'owner' property set.") } requireFrozenVersion, requireFrozenReason := i.checkRequireFrozenAndReason(mctx) // surface error early, main check is via checkUnstableModuleMutator if requireFrozenVersion && !i.hasVersion() { mctx.PropertyErrorf("versions", "must be set (need to be frozen) because: %q", requireFrozenReason) } vndkEnabled := proptools.Bool(i.properties.VndkProperties.Vndk.Enabled) || proptools.Bool(i.properties.Backend.Cpp.CommonNativeBackendProperties.VndkProperties.Vndk.Enabled) || proptools.Bool(i.properties.Backend.Ndk.CommonNativeBackendProperties.VndkProperties.Vndk.Enabled) if vndkEnabled && !proptools.Bool(i.properties.Unstable) { if i.properties.Frozen == nil { mctx.PropertyErrorf("frozen", "true or false must be specified when the VNDK is enabled on a versioned interface (not `unstable: true`)") } if !proptools.Bool(i.properties.Frozen) && i.properties.Vndk_use_version == nil { mctx.PropertyErrorf("vndk_use_version", "must be specified if interface is unfrozen (or specify 'frozen: false')") } } versions := i.getVersions() nextVersion := i.nextVersion() shouldGenerateLangBackendMap := map[string]bool{ langCpp: i.shouldGenerateCppBackend(), langNdk: i.shouldGenerateNdkBackend(), langJava: i.shouldGenerateJavaBackend(), langRust: i.shouldGenerateRustBackend()} // The ndk_platform backend is generated only when explicitly requested. This will // eventually be completely removed the devices in the long tail are gone. if mctx.DeviceConfig().GenerateAidlNdkPlatformBackend() { shouldGenerateLangBackendMap[langNdkPlatform] = i.shouldGenerateNdkBackend() } for lang, shouldGenerate := range shouldGenerateLangBackendMap { if !shouldGenerate { continue } libs = append(libs, addLibrary(mctx, i, nextVersion, lang, requireFrozenVersion, requireFrozenReason)) for _, version := range versions { libs = append(libs, addLibrary(mctx, i, version, lang, false, "this is a known frozen version")) } } // In the future, we may want to force the -cpp backend to be on host, // and limit its visibility, even if it's not created normally if i.shouldGenerateCppBackend() && len(i.properties.Imports) == 0 { libs = append(libs, addLibrary(mctx, i, nextVersion, langCppAnalyzer, false, "analysis always uses latest version even if frozen")) } if unstable { apiDirRoot := filepath.Join(aidlApiDir, i.ModuleBase.Name()) aidlDumps, _ := mctx.GlobWithDeps(filepath.Join(mctx.ModuleDir(), apiDirRoot, "**/*.aidl"), nil) if len(aidlDumps) != 0 { mctx.PropertyErrorf("unstable", "The interface is configured as unstable, "+ "but API dumps exist under %q. Unstable interface cannot have dumps.", apiDirRoot) } } else { addApiModule(mctx, i) } // Reserve this module name for future use. factoryFunc := func() android.Module { result := &phonyAidlInterface{ origin: i, } android.InitAndroidModule(result) return result } mctx.CreateModule(factoryFunc, &phonyProperties{ Name: proptools.StringPtr(i.ModuleBase.Name()), }) i.internalModuleNames = libs } func (p *phonyAidlInterface) GenerateAndroidBuildActions(_ android.ModuleContext) { // No-op. } type phonyAidlInterface struct { android.ModuleBase origin *aidlInterface } func (i *aidlInterface) commonBackendProperties(lang string) CommonBackendProperties { switch lang { case langCpp: return i.properties.Backend.Cpp.CommonBackendProperties case langJava: return i.properties.Backend.Java.CommonBackendProperties case langNdk, langNdkPlatform: return i.properties.Backend.Ndk.CommonBackendProperties case langRust: return i.properties.Backend.Rust.CommonBackendProperties default: panic(fmt.Errorf("unsupported language backend %q\n", lang)) } } func (i *aidlInterface) Name() string { return i.ModuleBase.Name() + aidlInterfaceSuffix } func (i *aidlInterface) GenerateAndroidBuildActions(ctx android.ModuleContext) { srcs, _ := getPaths(ctx, i.properties.Srcs, i.properties.Local_include_dir) for _, src := range srcs { computedType := strings.TrimSuffix(strings.ReplaceAll(src.Rel(), "/", "."), ".aidl") i.computedTypes = append(i.computedTypes, computedType) } i.preprocessed = make(map[string]android.WritablePath) // generate (len(versions) + 1) preprocessed.aidl files for _, version := range concat(i.getVersions(), []string{i.nextVersion()}) { i.preprocessed[version] = i.buildPreprocessed(ctx, version) } // helpful aliases if !proptools.Bool(i.properties.Unstable) { if i.hasVersion() { i.preprocessed["latest"] = i.preprocessed[i.latestVersion()] } else { // when we have no frozen versions yet, use "next version" as latest i.preprocessed["latest"] = i.preprocessed[i.nextVersion()] } i.preprocessed[""] = i.preprocessed[i.nextVersion()] } } func (i *aidlInterface) getImportsForVersion(version string) []string { // `Imports` is used when version == i.nextVersion() or`versions` is defined instead of `versions_with_info` importsSrc := i.properties.Imports for _, v := range i.properties.Versions_with_info { if v.Version == version { importsSrc = v.Imports break } } imports := make([]string, len(importsSrc)) copy(imports, importsSrc) return imports } func (i *aidlInterface) getImports(version string) map[string]string { imports := make(map[string]string) imports_src := i.getImportsForVersion(version) useLatestStable := !proptools.Bool(i.properties.Unstable) && version != "" && version != i.nextVersion() for _, importString := range imports_src { name, targetVersion := parseModuleWithVersion(importString) if targetVersion == "" && useLatestStable { targetVersion = "latest" } imports[name] = targetVersion } return imports } // generate preprocessed.aidl which contains only types with evaluated constants. // "imports" will use preprocessed.aidl with -p flag to avoid parsing the entire transitive list // of dependencies. func (i *aidlInterface) buildPreprocessed(ctx android.ModuleContext, version string) android.WritablePath { deps := getDeps(ctx, i.getImports(version)) preprocessed := android.PathForModuleOut(ctx, version, "preprocessed.aidl") rb := android.NewRuleBuilder(pctx, ctx) srcs, root_dir := i.srcsForVersion(ctx, version) if len(srcs) == 0 { ctx.PropertyErrorf("srcs", "No sources for a previous version in %v. Was a version manually added to .bp file? This is added automatically by -freeze-api.", root_dir) } paths, imports := getPaths(ctx, srcs, root_dir) imports = append(imports, deps.imports...) imports = append(imports, i.properties.Include_dirs...) preprocessCommand := rb.Command().BuiltTool("aidl"). FlagWithOutput("--preprocess ", preprocessed) if !proptools.Bool(i.properties.Unstable) { preprocessCommand.Flag("--structured") } if i.properties.Stability != nil { preprocessCommand.FlagWithArg("--stability ", *i.properties.Stability) } preprocessCommand.FlagForEachInput("-p", deps.preprocessed) preprocessCommand.FlagForEachArg("-I", imports) preprocessCommand.Inputs(paths) name := i.BaseModuleName() if version != "" { name += "/" + version } rb.Build("export_"+name, "export types for "+name) return preprocessed } func (i *aidlInterface) DepsMutator(ctx android.BottomUpMutatorContext) { ctx.AddReverseDependency(ctx.Module(), nil, aidlMetadataSingletonName) } func AidlInterfaceFactory() android.Module { i := &aidlInterface{} i.AddProperties(&i.properties) android.InitAndroidModule(i) android.InitDefaultableModule(i) i.SetDefaultableHook(func(ctx android.DefaultableHookContext) { aidlInterfaceHook(ctx, i) }) return i } ./PaxHeaders.X/build_aidl_interface_backends.go0100644 0000000 0000000 00000000034 15172120304 020565 xustar000000000 0000000 28 mtime=1776853188.3240000 build/aidl_interface_backends.go0100644 0000000 0000000 00000055675 15172120304 016033 0ustar000000000 0000000 // Copyright (C) 2021 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. package aidl import ( "android/soong/android" "android/soong/cc" "android/soong/java" "android/soong/rust" "fmt" "path/filepath" "strings" "github.com/google/blueprint/proptools" ) func addLibrary(mctx android.DefaultableHookContext, i *aidlInterface, version string, lang string, notFrozen bool, requireFrozenReason string) string { if lang == langJava { return addJavaLibrary(mctx, i, version, notFrozen, requireFrozenReason) } else if lang == langRust { return addRustLibrary(mctx, i, version, notFrozen, requireFrozenReason) } else if lang == langCppAnalyzer { return addCppAnalyzerLibrary(mctx, i, version, notFrozen, requireFrozenReason) } else if lang == langCpp || lang == langNdk || lang == langNdkPlatform { return addCppLibrary(mctx, i, version, lang, notFrozen, requireFrozenReason) } else { panic(fmt.Errorf("unsupported language backend %q\n", lang)) } } func addCppLibrary(mctx android.DefaultableHookContext, i *aidlInterface, version string, lang string, notFrozen bool, requireFrozenReason string) string { cppSourceGen := i.versionedName(version) + "-" + lang + "-source" cppModuleGen := i.versionedName(version) + "-" + lang srcs, aidlRoot := i.srcsForVersion(mctx, version) if len(srcs) == 0 { // This can happen when the version is about to be frozen; the version // directory is created but API dump hasn't been copied there. // Don't create a library for the yet-to-be-frozen version. return "" } var overrideVndkProperties cc.VndkProperties if !i.isModuleForVndk(version) { // We only want the VNDK to include the latest interface. For interfaces in // development, they will be frozen, so we put their latest version in the // VNDK. For interfaces which are already frozen, we put their latest version // in the VNDK, and when that version is frozen, the version in the VNDK can // be updated. Otherwise, we remove this library from the VNDK, to avoid adding // multiple versions of the same library to the VNDK. overrideVndkProperties.Vndk.Enabled = proptools.BoolPtr(false) overrideVndkProperties.Vndk.Support_system_process = proptools.BoolPtr(false) } var commonProperties *CommonNativeBackendProperties if lang == langCpp { commonProperties = &i.properties.Backend.Cpp.CommonNativeBackendProperties } else if lang == langNdk || lang == langNdkPlatform { commonProperties = &i.properties.Backend.Ndk.CommonNativeBackendProperties } genLog := proptools.Bool(commonProperties.Gen_log) genTrace := i.genTrace(lang) mctx.CreateModule(aidlGenFactory, &nameProperties{ Name: proptools.StringPtr(cppSourceGen), }, &aidlGenProperties{ Srcs: srcs, AidlRoot: aidlRoot, Imports: i.getImportsForVersion(version), Headers: i.properties.Headers, Stability: i.properties.Stability, Min_sdk_version: i.minSdkVersion(lang), Lang: lang, BaseName: i.ModuleBase.Name(), GenLog: genLog, Version: i.versionForInitVersionCompat(version), GenTrace: genTrace, Unstable: i.properties.Unstable, NotFrozen: notFrozen, RequireFrozenReason: requireFrozenReason, Flags: i.flagsForAidlGenRule(version), UseUnfrozen: i.useUnfrozen(mctx), }, ) importExportDependencies := []string{} sharedLibDependency := commonProperties.Additional_shared_libraries var headerLibs []string var sdkVersion *string var stl *string var cpp_std *string var hostSupported *bool addCflags := commonProperties.Cflags targetProp := ccTargetProperties{ Darwin: darwinProperties{Enabled: proptools.BoolPtr(false)}, } if lang == langCpp { importExportDependencies = append(importExportDependencies, "libbinder", "libutils") if genTrace { sharedLibDependency = append(sharedLibDependency, "libcutils") } hostSupported = i.properties.Host_supported } else if lang == langNdk || lang == langNdkPlatform { importExportDependencies = append(importExportDependencies, "libbinder_ndk") nonAppProps := imageProperties{ Cflags: []string{"-DBINDER_STABILITY_SUPPORT"}, } if genTrace { sharedLibDependency = append(sharedLibDependency, "libandroid") nonAppProps.Exclude_shared_libs = []string{"libandroid"} nonAppProps.Header_libs = []string{"libandroid_aidltrace"} nonAppProps.Shared_libs = []string{"libcutils"} } targetProp.Platform = nonAppProps targetProp.Vendor = nonAppProps targetProp.Product = nonAppProps hostSupported = i.properties.Host_supported if lang == langNdk && i.shouldGenerateAppNdkBackend() { sdkVersion = i.properties.Backend.Ndk.Sdk_version if sdkVersion == nil { sdkVersion = proptools.StringPtr("current") } // Don't worry! This maps to libc++.so for the platform variant. stl = proptools.StringPtr("c++_shared") } } else { panic("Unrecognized language: " + lang) } vendorAvailable := i.properties.Vendor_available odmAvailable := i.properties.Odm_available productAvailable := i.properties.Product_available recoveryAvailable := i.properties.Recovery_available if lang == langCpp { // Vendor and product modules cannot use the libbinder (cpp) backend of AIDL in a // way that is stable. So, in order to prevent accidental usage of these library by // vendor and product forcibly disabling this version of the library. // // It may be the case in the future that we will want to enable this (if some generic // helper should be used by both libbinder vendor things using /dev/vndbinder as well // as those things using /dev/binder + libbinder_ndk to talk to stable interfaces). if "vintf" == proptools.String(i.properties.Stability) { overrideVndkProperties.Vndk.Private = proptools.BoolPtr(true) } // As libbinder is not available for the product processes, we must not create // product variant for the aidl_interface productAvailable = nil } mctx.CreateModule(aidlImplementationGeneratorFactory, &nameProperties{ Name: proptools.StringPtr(cppModuleGen + "-generator"), }, &aidlImplementationGeneratorProperties{ Lang: lang, AidlInterfaceName: i.ModuleBase.Name(), Version: version, Imports: i.getImportsForVersion(version), ModuleProperties: []interface{}{ &ccProperties{ Name: proptools.StringPtr(cppModuleGen), Vendor_available: vendorAvailable, Odm_available: odmAvailable, Product_available: productAvailable, Recovery_available: recoveryAvailable, Host_supported: hostSupported, Defaults: []string{"aidl-cpp-module-defaults"}, Double_loadable: i.properties.Double_loadable, Generated_sources: []string{cppSourceGen}, Generated_headers: []string{cppSourceGen}, Export_generated_headers: []string{cppSourceGen}, Shared_libs: append(importExportDependencies, sharedLibDependency...), Header_libs: headerLibs, Export_shared_lib_headers: importExportDependencies, Sdk_version: sdkVersion, Stl: stl, Cpp_std: cpp_std, Cflags: append(addCflags, "-Wextra", "-Wall", "-Werror", "-Wextra-semi"), Ldflags: commonProperties.Ldflags, Apex_available: commonProperties.Apex_available, Min_sdk_version: i.minSdkVersion(lang), Target: targetProp, Tidy: proptools.BoolPtr(true), // Do the tidy check only for the generated headers Tidy_flags: []string{"--header-filter=" + android.PathForOutput(mctx).String() + ".*"}, Tidy_checks_as_errors: []string{ "*", "-clang-analyzer-deadcode.DeadStores", // b/253079031 "-clang-analyzer-cplusplus.NewDeleteLeaks", // b/253079031 "-clang-analyzer-optin.performance.Padding", // b/253079031 }, Include_build_directory: proptools.BoolPtr(false), // b/254682497 }, &i.properties.VndkProperties, &commonProperties.VndkProperties, &overrideVndkProperties, }, }) return cppModuleGen } func addCppAnalyzerLibrary(mctx android.DefaultableHookContext, i *aidlInterface, version string, notFrozen bool, requireFrozenReason string) string { cppAnalyzerSourceGen := i.versionedName("") + "-cpp-analyzer-source" cppAnalyzerModuleGen := i.versionedName("") + "-cpp-analyzer" srcs, aidlRoot := i.srcsForVersion(mctx, version) if len(srcs) == 0 { return "" } mctx.CreateModule(aidlGenFactory, &nameProperties{ Name: proptools.StringPtr(cppAnalyzerSourceGen), }, &aidlGenProperties{ Srcs: srcs, AidlRoot: aidlRoot, Imports: i.getImportsForVersion(version), Stability: i.properties.Stability, Min_sdk_version: i.minSdkVersion(langCpp), Lang: langCppAnalyzer, BaseName: i.ModuleBase.Name(), Version: i.versionForInitVersionCompat(version), Unstable: i.properties.Unstable, NotFrozen: notFrozen, RequireFrozenReason: requireFrozenReason, Flags: i.flagsForAidlGenRule(version), UseUnfrozen: i.useUnfrozen(mctx), }) importExportDependencies := []string{} var hostSupported *bool var addCflags []string // not using cpp backend cflags for now targetProp := ccTargetProperties{ Darwin: darwinProperties{Enabled: proptools.BoolPtr(false)}, } importExportDependencies = append(importExportDependencies, "libbinder", "libutils") hostSupported = i.properties.Host_supported vendorAvailable := i.properties.Vendor_available odmAvailable := i.properties.Odm_available productAvailable := i.properties.Product_available recoveryAvailable := i.properties.Recovery_available productAvailable = nil commonProperties := &i.properties.Backend.Cpp.CommonNativeBackendProperties g := aidlImplementationGeneratorProperties{ ModuleProperties: []interface{}{ &ccProperties{ Name: proptools.StringPtr(cppAnalyzerModuleGen), Vendor_available: vendorAvailable, Odm_available: odmAvailable, Product_available: productAvailable, Recovery_available: recoveryAvailable, Host_supported: hostSupported, Defaults: []string{"aidl-cpp-module-defaults"}, Double_loadable: i.properties.Double_loadable, Installable: proptools.BoolPtr(true), Generated_sources: []string{cppAnalyzerSourceGen}, Generated_headers: []string{cppAnalyzerSourceGen}, Export_generated_headers: []string{cppAnalyzerSourceGen}, Shared_libs: append(append(importExportDependencies, i.versionedName(version)+"-"+langCpp), commonProperties.Additional_shared_libraries...), Static_libs: []string{"aidl-analyzer-main"}, Export_shared_lib_headers: importExportDependencies, Cflags: append(addCflags, "-Wextra", "-Wall", "-Werror", "-Wextra-semi"), Ldflags: commonProperties.Ldflags, Min_sdk_version: i.minSdkVersion(langCpp), Target: targetProp, Tidy: proptools.BoolPtr(true), // Do the tidy check only for the generated headers Tidy_flags: []string{"--header-filter=" + android.PathForOutput(mctx).String() + ".*"}, Tidy_checks_as_errors: []string{ "*", "-clang-diagnostic-deprecated-declarations", // b/253081572 "-clang-analyzer-deadcode.DeadStores", // b/253079031 "-clang-analyzer-cplusplus.NewDeleteLeaks", // b/253079031 "-clang-analyzer-optin.performance.Padding", // b/253079031 }, }, }, } mctx.CreateModule(wrapLibraryFactory(cc.BinaryFactory), g.ModuleProperties...) return cppAnalyzerModuleGen } func addJavaLibrary(mctx android.DefaultableHookContext, i *aidlInterface, version string, notFrozen bool, requireFrozenReason string) string { javaSourceGen := i.versionedName(version) + "-java-source" javaModuleGen := i.versionedName(version) + "-java" srcs, aidlRoot := i.srcsForVersion(mctx, version) if len(srcs) == 0 { // This can happen when the version is about to be frozen; the version // directory is created but API dump hasn't been copied there. // Don't create a library for the yet-to-be-frozen version. return "" } minSdkVersion := i.minSdkVersion(langJava) sdkVersion := i.properties.Backend.Java.Sdk_version if !proptools.Bool(i.properties.Backend.Java.Platform_apis) && sdkVersion == nil { // platform apis requires no default sdkVersion = proptools.StringPtr("system_current") } // use sdkVersion if minSdkVersion is not set if sdkVersion != nil && minSdkVersion == nil { minSdkVersion = proptools.StringPtr(android.SdkSpecFrom(mctx, *sdkVersion).ApiLevel.String()) } mctx.CreateModule(aidlGenFactory, &nameProperties{ Name: proptools.StringPtr(javaSourceGen), }, &aidlGenProperties{ Srcs: srcs, AidlRoot: aidlRoot, Imports: i.getImportsForVersion(version), Headers: i.properties.Headers, Stability: i.properties.Stability, Min_sdk_version: minSdkVersion, Platform_apis: proptools.Bool(i.properties.Backend.Java.Platform_apis), Lang: langJava, BaseName: i.ModuleBase.Name(), Version: version, GenRpc: proptools.Bool(i.properties.Backend.Java.Gen_rpc), GenTrace: i.genTrace(langJava), Unstable: i.properties.Unstable, NotFrozen: notFrozen, RequireFrozenReason: requireFrozenReason, Flags: i.flagsForAidlGenRule(version), UseUnfrozen: i.useUnfrozen(mctx), }) mctx.CreateModule(aidlImplementationGeneratorFactory, &nameProperties{ Name: proptools.StringPtr(javaModuleGen + "-generator"), }, &aidlImplementationGeneratorProperties{ Lang: langJava, AidlInterfaceName: i.ModuleBase.Name(), Version: version, Imports: i.getImportsForVersion(version), ModuleProperties: []interface{}{ &javaProperties{ Name: proptools.StringPtr(javaModuleGen), Installable: proptools.BoolPtr(true), Defaults: []string{"aidl-java-module-defaults"}, Sdk_version: sdkVersion, Srcs: []string{":" + javaSourceGen}, Apex_available: i.properties.Backend.Java.Apex_available, Min_sdk_version: i.minSdkVersion(langJava), Static_libs: i.properties.Backend.Java.Additional_libs, }, &i.properties.Backend.Java.LintProperties, }, }) return javaModuleGen } func addRustLibrary(mctx android.DefaultableHookContext, i *aidlInterface, version string, notFrozen bool, requireFrozenReason string) string { rustSourceGen := i.versionedName(version) + "-rust-source" rustModuleGen := i.versionedName(version) + "-rust" srcs, aidlRoot := i.srcsForVersion(mctx, version) if len(srcs) == 0 { // This can happen when the version is about to be frozen; the version // directory is created but API dump hasn't been copied there. // Don't create a library for the yet-to-be-frozen version. return "" } mctx.CreateModule(aidlGenFactory, &nameProperties{ Name: proptools.StringPtr(rustSourceGen), }, &aidlGenProperties{ Srcs: srcs, AidlRoot: aidlRoot, Imports: i.getImportsForVersion(version), Headers: i.properties.Headers, Stability: i.properties.Stability, Min_sdk_version: i.minSdkVersion(langRust), Lang: langRust, BaseName: i.ModuleBase.Name(), Version: i.versionForInitVersionCompat(version), Unstable: i.properties.Unstable, NotFrozen: notFrozen, RequireFrozenReason: requireFrozenReason, Flags: i.flagsForAidlGenRule(version), UseUnfrozen: i.useUnfrozen(mctx), }) versionedRustName := fixRustName(i.versionedName(version)) rustCrateName := fixRustName(i.ModuleBase.Name()) mctx.CreateModule(wrapLibraryFactory(aidlRustLibraryFactory), &rustProperties{ Name: proptools.StringPtr(rustModuleGen), Crate_name: rustCrateName, Stem: proptools.StringPtr("lib" + versionedRustName), Defaults: []string{"aidl-rust-module-defaults"}, Host_supported: i.properties.Host_supported, Vendor_available: i.properties.Vendor_available, Product_available: i.properties.Product_available, Apex_available: i.properties.Backend.Rust.Apex_available, Min_sdk_version: i.minSdkVersion(langRust), Target: rustTargetProperties{Darwin: darwinProperties{Enabled: proptools.BoolPtr(false)}}, Rustlibs: i.properties.Backend.Rust.Additional_rustlibs, }, &rust.SourceProviderProperties{ Source_stem: proptools.StringPtr(versionedRustName), }, &aidlRustSourceProviderProperties{ SourceGen: rustSourceGen, Imports: i.getImportsForVersion(version), Version: version, AidlInterfaceName: i.ModuleBase.Name(), }) return rustModuleGen } // This function returns module name with version. Assume that there is foo of which latest version is 2 // Version -> Module name // "1"->foo-V1 // "2"->foo-V2 // "3"->foo-V3 // And assume that there is 'bar' which is an 'unstable' interface. // ""->bar func (i *aidlInterface) versionedName(version string) string { name := i.ModuleBase.Name() if version == "" { return name } return name + "-V" + version } func (i *aidlInterface) srcsForVersion(mctx android.EarlyModuleContext, version string) (srcs []string, aidlRoot string) { if version == i.nextVersion() { return i.properties.Srcs, i.properties.Local_include_dir } else { aidlRoot = filepath.Join(aidlApiDir, i.ModuleBase.Name(), version) full_paths, err := mctx.GlobWithDeps(filepath.Join(mctx.ModuleDir(), aidlRoot, "**/*.aidl"), nil) if err != nil { panic(err) } for _, path := range full_paths { // Here, we need path local to the module srcs = append(srcs, strings.TrimPrefix(path, mctx.ModuleDir()+"/")) } return srcs, aidlRoot } } // For certain backend, avoid a difference between the initial version of a versioned // interface and an unversioned interface. This ensures that prebuilts can't prevent // an interface from switching from unversioned to versioned. func (i *aidlInterface) versionForInitVersionCompat(version string) string { if !i.hasVersion() { return "" } return version } func (i *aidlInterface) flagsForAidlGenRule(version string) (flags []string) { // For the latest unfrozen version of an interface we turn on all warnings and use // all flags supplied by the 'flags' field in the aidl_interface module if version == i.nextVersion() && !i.isFrozen() { flags = append(flags, "-Weverything -Wno-missing-permission-annotation") flags = append(flags, i.properties.Flags...) } return } func (i *aidlInterface) isModuleForVndk(version string) bool { if i.properties.Vndk_use_version != nil { if !i.hasVersion() && version != *i.properties.Vndk_use_version { panic("unrecognized vndk_use_version") } // Will be exactly one of the version numbers return version == *i.properties.Vndk_use_version } // For an interface with no versions, this is the ToT interface. if !i.hasVersion() { return version == i.nextVersion() } return version == i.latestVersion() } // importing aidl_interface's version | imported aidl_interface | imported aidl_interface's version // -------------------------------------------------------------------------------------------------- // whatever | unstable | unstable version // ToT version(including unstable) | whatever | ToT version(unstable if unstable) // otherwise | whatever | the latest stable version // In the case that import specifies the version which it wants to use, use that version. func (i *aidlInterface) getImportWithVersion(version string, anImport string, other *aidlInterface) string { if hasVersionSuffix(anImport) { return anImport } if proptools.Bool(other.properties.Unstable) { return anImport } if version == i.nextVersion() || !other.hasVersion() { return other.versionedName(other.nextVersion()) } return other.versionedName(other.latestVersion()) } // Assuming that the context module has deps to its original aidl_interface and imported // aidl_interface modules with interfaceDepTag and importInterfaceDepTag, returns the list of // imported interfaces with versions. func getImportsWithVersion(ctx android.BaseMutatorContext, interfaceName, version string) []string { i := ctx.GetDirectDepWithTag(interfaceName+aidlInterfaceSuffix, interfaceDep).(*aidlInterface) var imports []string ctx.VisitDirectDeps(func(dep android.Module) { if tag, ok := ctx.OtherModuleDependencyTag(dep).(importInterfaceDepTag); ok { other := dep.(*aidlInterface) imports = append(imports, i.getImportWithVersion(version, tag.anImport, other)) } }) return imports } func aidlImplementationGeneratorFactory() android.Module { g := &aidlImplementationGenerator{} g.AddProperties(&g.properties) android.InitAndroidModule(g) return g } type aidlImplementationGenerator struct { android.ModuleBase properties aidlImplementationGeneratorProperties } type aidlImplementationGeneratorProperties struct { Lang string AidlInterfaceName string Version string Imports []string ModuleProperties []interface{} } func (g *aidlImplementationGenerator) DepsMutator(ctx android.BottomUpMutatorContext) { } func (g *aidlImplementationGenerator) GenerateAndroidBuildActions(ctx android.ModuleContext) { } func (g *aidlImplementationGenerator) GenerateImplementation(ctx android.TopDownMutatorContext) { imports := wrap("", getImportsWithVersion(ctx, g.properties.AidlInterfaceName, g.properties.Version), "-"+g.properties.Lang) if g.properties.Lang == langJava { if p, ok := g.properties.ModuleProperties[0].(*javaProperties); ok { p.Static_libs = append(p.Static_libs, imports...) } ctx.CreateModule(wrapLibraryFactory(java.LibraryFactory), g.properties.ModuleProperties...) } else { if p, ok := g.properties.ModuleProperties[0].(*ccProperties); ok { p.Shared_libs = append(p.Shared_libs, imports...) p.Export_shared_lib_headers = append(p.Export_shared_lib_headers, imports...) } module := ctx.CreateModule(wrapLibraryFactory(cc.LibraryFactory), g.properties.ModuleProperties...) // AIDL-generated CC modules can't be used across system/vendor boundary. So marking it // as MustUseVendorVariant. See build/soong/cc/config/vndk.go module.(*cc.Module).Properties.MustUseVendorVariant = true } } ./PaxHeaders.X/build_aidl_interface_defaults.go0100644 0000000 0000000 00000000034 15172120304 020622 xustar000000000 0000000 28 mtime=1776853188.3250000 build/aidl_interface_defaults.go0100644 0000000 0000000 00000001066 15172120304 016051 0ustar000000000 0000000 package aidl import ( "android/soong/android" ) func init() { android.RegisterModuleType("aidl_interface_defaults", AidlInterfaceDefaultsFactory) } type Defaults struct { android.ModuleBase android.DefaultsModuleBase } func (d *Defaults) GenerateAndroidBuildActions(ctx android.ModuleContext) { } func (d *Defaults) DepsMutator(ctx android.BottomUpMutatorContext) { } func AidlInterfaceDefaultsFactory() android.Module { module := &Defaults{} module.AddProperties( &aidlInterfaceProperties{}, ) android.InitDefaultsModule(module) return module } ./PaxHeaders.X/build_aidl_interface_metadata_singleton.go0100644 0000000 0000000 00000000034 15172120304 022655 xustar000000000 0000000 28 mtime=1776853188.3250000 build/aidl_interface_metadata_singleton.go0100644 0000000 0000000 00000013204 15172120304 020101 0ustar000000000 0000000 // Copyright (C) 2021 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. package aidl import ( "android/soong/android" "fmt" "strings" "github.com/google/blueprint" "github.com/google/blueprint/proptools" ) var ( aidlMetadataRule = pctx.StaticRule("aidlMetadataRule", blueprint.RuleParams{ Command: `rm -f ${out} && { ` + `echo '{' && ` + `echo "\"name\": \"${name}\"," && ` + `echo "\"stability\": \"${stability}\"," && ` + `echo "\"types\": [${types}]," && ` + `echo "\"hashes\": [${hashes}]," && ` + `echo "\"has_development\": ${has_development}," && ` + `echo "\"use_unfrozen\": ${use_unfrozen}," && ` + `echo "\"versions\": [${versions}]" && ` + `echo '}' ` + `;} >> ${out}`, Description: "AIDL metadata: ${out}", }, "name", "stability", "types", "hashes", "has_development", "use_unfrozen", "versions") joinJsonObjectsToArrayRule = pctx.StaticRule("joinJsonObjectsToArrayRule", blueprint.RuleParams{ Rspfile: "$out.rsp", RspfileContent: "$files", Command: "rm -rf ${out} && " + // Start the output array with an opening bracket. "echo '[' >> ${out} && " + // Append each input file and a comma to the output. "for file in $$(cat ${out}.rsp); do " + "cat $$file >> ${out}; echo ',' >> ${out}; " + "done && " + // Remove the last comma, replacing it with the closing bracket. "sed -i '$$d' ${out} && echo ']' >> ${out}", Description: "Joining JSON objects into array ${out}", }, "files") ) func init() { android.RegisterModuleType("aidl_interfaces_metadata", aidlInterfacesMetadataSingletonFactory) } func aidlInterfacesMetadataSingletonFactory() android.Module { i := &aidlInterfacesMetadataSingleton{} android.InitAndroidModule(i) return i } type aidlInterfacesMetadataSingleton struct { android.ModuleBase metadataPath android.WritablePath } var _ android.OutputFileProducer = (*aidlInterfacesMetadataSingleton)(nil) func (m *aidlInterfacesMetadataSingleton) GenerateAndroidBuildActions(ctx android.ModuleContext) { if m.Name() != aidlMetadataSingletonName { ctx.PropertyErrorf("name", "must be %s", aidlMetadataSingletonName) return } type ModuleInfo struct { Stability string ComputedTypes []string HashFiles []string HasDevelopment android.WritablePath UseUnfrozen bool Versions []string } // name -> ModuleInfo moduleInfos := map[string]ModuleInfo{} ctx.VisitDirectDeps(func(m android.Module) { if !m.ExportedToMake() { return } switch t := m.(type) { case *aidlInterface: info := moduleInfos[t.ModuleBase.Name()] info.Stability = proptools.StringDefault(t.properties.Stability, "") info.ComputedTypes = t.computedTypes info.Versions = t.getVersions() info.UseUnfrozen = t.useUnfrozen(ctx) moduleInfos[t.ModuleBase.Name()] = info case *aidlGenRule: info := moduleInfos[t.properties.BaseName] if t.hashFile != nil { info.HashFiles = append(info.HashFiles, t.hashFile.String()) } moduleInfos[t.properties.BaseName] = info case *aidlApi: info := moduleInfos[t.properties.BaseName] info.HasDevelopment = t.hasDevelopment moduleInfos[t.properties.BaseName] = info } }) var metadataOutputs android.Paths for _, name := range android.SortedKeys(moduleInfos) { info := moduleInfos[name] metadataPath := android.PathForModuleOut(ctx, "metadata_"+name) metadataOutputs = append(metadataOutputs, metadataPath) // There is one aidlGenRule per-version per-backend. If we had // objects per version and sub-objects per backend, we could // avoid needing to filter out duplicates. info.HashFiles = android.FirstUniqueStrings(info.HashFiles) readHashes := "" if len(info.HashFiles) > 0 { readHashes = "$$(sed 's/.*/\"&\",/' " + strings.Join(info.HashFiles, " ") + "| tr '\\n' ' ' | sed 's/, $$//')" } implicits := android.PathsForSource(ctx, info.HashFiles) hasDevelopmentValue := "true" if info.HasDevelopment != nil { hasDevelopmentValue = "$$(if [ \"$$(cat " + info.HasDevelopment.String() + ")\" = \"1\" ]; then echo true; else echo false; fi)" } useUnfrozenValue := "false" if info.UseUnfrozen { useUnfrozenValue = "true" } ctx.Build(pctx, android.BuildParams{ Rule: aidlMetadataRule, Implicits: implicits, Input: info.HasDevelopment, Output: metadataPath, Args: map[string]string{ "name": name, "stability": info.Stability, "types": strings.Join(wrap(`\"`, info.ComputedTypes, `\"`), ", "), "hashes": readHashes, "has_development": hasDevelopmentValue, "use_unfrozen": useUnfrozenValue, "versions": strings.Join(info.Versions, ", "), }, }) } m.metadataPath = android.PathForModuleOut(ctx, "aidl_metadata.json") ctx.Build(pctx, android.BuildParams{ Rule: joinJsonObjectsToArrayRule, Inputs: metadataOutputs, Output: m.metadataPath, Args: map[string]string{ "files": strings.Join(metadataOutputs.Strings(), " "), }, }) } func (m *aidlInterfacesMetadataSingleton) OutputFiles(tag string) (android.Paths, error) { if tag != "" { return nil, fmt.Errorf("unsupported tag %q", tag) } return android.Paths{m.metadataPath}, nil } ./PaxHeaders.X/build_aidl_rust_glue.py0100644 0000000 0000000 00000000034 15172120304 017027 xustar000000000 0000000 28 mtime=1776853188.3260000 build/aidl_rust_glue.py0100755 0000000 0000000 00000007250 15172120304 014262 0ustar000000000 0000000 #!/usr/bin/env python3 # # 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. # import argparse import collections import os import pathlib import sys class RustModule: def __init__(self): self.files = [] self.nested = collections.defaultdict(RustModule) def emit(self, output_file, indent=""): for (input_name, input_path) in self.files: output_file.write(indent) output_file.write("pub mod %s {\n" % input_name) # Copy the contents of the input file into the output with open(input_path, "r") as input_file: for l in input_file: output_file.write(indent) output_file.write(" ") output_file.write(l) output_file.write(indent) output_file.write("}\n") for name, mod in self.nested.items(): output_file.write(indent) output_file.write("pub mod %s {\n" % name) mod.emit(output_file, indent + " ") output_file.write(indent) output_file.write("}\n") def emit_mangled(self, output_file, indent="", prefix=""): for (input_name, _) in self.files: output_file.write(indent) output_file.write("pub use %s::%s::mangled::*;\n" % (prefix, input_name)) for name, mod in self.nested.items(): new_prefix = prefix + "::" + name mod.emit_mangled(output_file, indent, prefix=new_prefix) def main(output, root, inputs, imports): root_module = RustModule() for inp in inputs: in_rel = os.path.relpath(inp, root) in_path = pathlib.PurePath(in_rel) node = root_module for part in in_path.parts[:-1]: node = node.nested[part] if os.path.isfile(inp): in_name, in_ext = os.path.splitext(in_path.parts[-1]) node.files.append((in_name, inp)) with open(output, "w") as lib_rs_file: lib_rs_file.write("#![allow(non_snake_case)]\n") lib_rs_file.write("#![allow(missing_docs)]\n") lib_rs_file.write("#[deprecated(note = \"Please access via libbinder_rs binder::\")]\n") lib_rs_file.write("pub use binder;\n") lib_rs_file.write("pub mod aidl {\n") root_module.emit(lib_rs_file, indent=" ") lib_rs_file.write("}\n") lib_rs_file.write("pub mod mangled {\n") root_module.emit_mangled(lib_rs_file, indent=" ", prefix="super::aidl") for imp in imports: lib_rs_file.write(" pub(crate) use %s::mangled::*;\n" % imp) lib_rs_file.write("}\n") def execute(): parser = argparse.ArgumentParser(description='Generate the top-level lib.rs.', fromfile_prefix_chars='@') parser.add_argument('output', help='Path to output .rs file') parser.add_argument('root', help='Common ancestor of all input files') parser.add_argument('inputs', nargs='+', help='Input .rs files') parser.add_argument('-I', '--import', action='append', dest='imports', default=[], help='Crates to import') args = parser.parse_args() if args is None: sys.exit(1) sys.exit(main(args.output, args.root, args.inputs, args.imports)) if __name__ == "__main__": execute() ./PaxHeaders.X/build_aidl_rust_source_provider.go0100644 0000000 0000000 00000000034 15172120304 021262 xustar000000000 0000000 28 mtime=1776853188.3260000 build/aidl_rust_source_provider.go0100644 0000000 0000000 00000010755 15172120304 016516 0ustar000000000 0000000 // Copyright (C) 2021 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. package aidl import ( "android/soong/android" "android/soong/rust" "strings" "github.com/google/blueprint" "github.com/google/blueprint/proptools" ) var ( aidlRustGlueRule = pctx.StaticRule("aidlRustGlueRule", blueprint.RuleParams{ Command: `${aidlRustGlueCmd} ${out} ${root} ${in} ${imports}`, CommandDeps: []string{"${aidlRustGlueCmd}"}, }, "root", "imports") ) type aidlRustSourceProviderProperties struct { SourceGen string `android:"path"` Imports []string Version string AidlInterfaceName string } type aidlRustSourceProvider struct { *rust.BaseSourceProvider properties aidlRustSourceProviderProperties } var aidlRustSourceTag = struct { blueprint.DependencyTag }{} func (sp *aidlRustSourceProvider) GenerateSource(ctx rust.ModuleContext, _ rust.PathDeps) android.Path { sourceStem := proptools.String(sp.BaseSourceProvider.Properties.Source_stem) topLevelOutputFile := android.PathForModuleOut(ctx, sourceStem+".rs") aidlGenModule := ctx.GetDirectDepWithTag(sp.properties.SourceGen, aidlRustSourceTag) // Find the gen directory for the source module srcGenDir := aidlGenModule.(*aidlGenRule).genOutDir srcPaths := aidlGenModule.(*aidlGenRule).genOutputs.Paths() // In Rust, we import our dependency crates into `mangled`: // use dependency::mangled::*; // so we can use the crate:: Rust path prefix to refer to // both crate-local and imported paths (from dependencies) importFlags := make([]string, len(sp.properties.Imports)) for i, dep := range trimVersionSuffixInList(sp.properties.Imports) { importFlags[i] = "-I" + fixRustName(dep) } // In Rust, we need to do some extra post-processing: // emit a top-level foo.rs that includes all the generated .rs // files verbatim ("glued" together). The generated glue file // replicates the AIDL package hierarchy from the input // .aidl files in two ways: // * 1:1 mapping in the crate::aidl namespace, used by downstream users // * mangled in the crate::mangled namespace, used internally // to resolve AIDL package paths between dependencies ctx.Build(pctx, android.BuildParams{ Rule: aidlRustGlueRule, Inputs: srcPaths, Output: topLevelOutputFile, Args: map[string]string{ "root": srcGenDir.String(), "imports": strings.Join(importFlags, " "), }, }) sp.BaseSourceProvider.OutputFiles = android.Paths{topLevelOutputFile} return topLevelOutputFile } func (sp *aidlRustSourceProvider) SourceProviderProps() []interface{} { return append(sp.BaseSourceProvider.SourceProviderProps(), &sp.properties) } func (sp *aidlRustSourceProvider) SourceProviderDeps(ctx rust.DepsContext, deps rust.Deps) rust.Deps { deps = sp.BaseSourceProvider.SourceProviderDeps(ctx, deps) deps.Rustlibs = append(deps.Rustlibs, "libbinder_rs") deps.Rustlibs = append(deps.Rustlibs, wrap("", getImportsWithVersion(ctx, sp.properties.AidlInterfaceName, sp.properties.Version), "-"+langRust)...) deps.ProcMacros = append(deps.ProcMacros, "libasync_trait") // Add a depencency to the source module (*-rust-source) directly via `ctx` because // the source module is specific to aidlRustSourceProvider and we don't want the rust module // to know about it. ctx.AddDependency(ctx.Module(), aidlRustSourceTag, sp.properties.SourceGen) return deps } func (sp *aidlRustSourceProvider) AndroidMk(ctx rust.AndroidMkContext, ret *android.AndroidMkEntries) { ctx.SubAndroidMk(ret, sp.BaseSourceProvider) ret.ExtraEntries = append(ret.ExtraEntries, func(ctx android.AndroidMkExtraEntriesContext, entries *android.AndroidMkEntries) { entries.SetBool("LOCAL_UNINSTALLABLE_MODULE", true) }) } func aidlRustLibraryFactory() android.Module { sourceProvider := &aidlRustSourceProvider{ BaseSourceProvider: rust.NewSourceProvider(), properties: aidlRustSourceProviderProperties{}, } module := rust.NewSourceProviderModule(android.HostAndDeviceSupported, sourceProvider, false, false) return module.Init() } ./PaxHeaders.X/build_aidl_test.go0100644 0000000 0000000 00000000034 15172120304 015752 xustar000000000 0000000 28 mtime=1776853188.3270000 build/aidl_test.go0100644 0000000 0000000 00000172067 15172120304 013213 0ustar000000000 0000000 // Copyright (C) 2019 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. package aidl import ( "fmt" "os" "path/filepath" "strings" "testing" "github.com/google/blueprint" "github.com/google/blueprint/proptools" "android/soong/aidl_library" "android/soong/android" "android/soong/cc" "android/soong/genrule" "android/soong/java" "android/soong/rust" ) func TestMain(m *testing.M) { os.Exit(m.Run()) } func withFiles(files map[string][]byte) android.FixturePreparer { return android.FixtureMergeMockFs(files) } func intPtr(v int) *int { return &v } func setReleaseEnv() android.FixturePreparer { return android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) { variables.Release_aidl_use_unfrozen = proptools.BoolPtr(false) }) } func setTestFreezeEnv() android.FixturePreparer { return android.FixtureMergeEnv(map[string]string{ "AIDL_FROZEN_REL": "true", "AIDL_FROZEN_OWNERS": "aosp test", }) } func setUseUnfrozenOverrideEnvTrue() android.FixturePreparer { return android.FixtureMergeEnv(map[string]string{ "AIDL_USE_UNFROZEN_OVERRIDE": "true", }) } func setUseUnfrozenOverrideEnvFalse() android.FixturePreparer { return android.FixtureMergeEnv(map[string]string{ "AIDL_USE_UNFROZEN_OVERRIDE": "false", }) } func setTransitiveFreezeEnv() android.FixturePreparer { return android.FixtureMergeEnv(map[string]string{ "AIDL_TRANSITIVE_FREEZE": "true", }) } func _testAidl(t *testing.T, bp string, customizers ...android.FixturePreparer) android.FixturePreparer { t.Helper() preparers := []android.FixturePreparer{} preparers = append(preparers, cc.PrepareForTestWithCcDefaultModules, java.PrepareForTestWithJavaDefaultModules, genrule.PrepareForTestWithGenRuleBuildComponents, android.PrepareForTestWithNamespace, ) bp = bp + ` package { default_visibility: ["//visibility:public"], } java_defaults { name: "aidl-java-module-defaults", } cc_defaults { name: "aidl-cpp-module-defaults", } rust_defaults { name: "aidl-rust-module-defaults", } cc_library { name: "libbinder", recovery_available: true, } cc_library_static { name: "aidl-analyzer-main", host_supported: true, vendor_available: true, recovery_available: true, } cc_library { name: "libutils", recovery_available: true, } cc_library { name: "libcutils", recovery_available: true, } cc_library { name: "libbinder_ndk", recovery_available: true, stubs: { versions: ["29"], } } ndk_library { name: "libbinder_ndk", symbol_file: "libbinder_ndk.map.txt", first_version: "29", } cc_library { name: "liblog", no_libcrt: true, nocrt: true, system_shared_libs: [], } rust_library { name: "libstd", crate_name: "std", srcs: [""], no_stdlibs: true, sysroot: true, } rust_library { name: "libtest", crate_name: "test", srcs: [""], no_stdlibs: true, sysroot: true, } rust_library { name: "libbinder_rs", crate_name: "binder", srcs: [""], } rust_proc_macro { name: "libasync_trait", crate_name: "async_trait", srcs: [""], no_stdlibs: true, } ` preparers = append(preparers, android.FixtureWithRootAndroidBp(bp)) preparers = append(preparers, android.FixtureAddTextFile("system/tools/aidl/build/Android.bp", ` aidl_interfaces_metadata { name: "aidl_metadata_json", visibility: ["//system/tools/aidl:__subpackages__"], } `)) preparers = append(preparers, android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) { variables.Release_aidl_use_unfrozen = proptools.BoolPtr(true) })) preparers = append(preparers, customizers...) preparers = append(preparers, rust.PrepareForTestWithRustBuildComponents, android.FixtureRegisterWithContext(func(ctx android.RegistrationContext) { ctx.RegisterModuleType("aidl_interface", AidlInterfaceFactory) ctx.RegisterModuleType("aidl_interface_defaults", AidlInterfaceDefaultsFactory) ctx.RegisterModuleType("aidl_interfaces_metadata", aidlInterfacesMetadataSingletonFactory) ctx.RegisterModuleType("rust_defaults", func() android.Module { return rust.DefaultsFactory() }) ctx.RegisterModuleType("aidl_library", aidl_library.AidlLibraryFactory) ctx.PreArchMutators(registerPreArchMutators) ctx.PostDepsMutators(registerPostDepsMutators) }), ) return android.GroupFixturePreparers(preparers...) } func testAidl(t *testing.T, bp string, customizers ...android.FixturePreparer) (*android.TestContext, android.Config) { t.Helper() preparer := _testAidl(t, bp, customizers...) result := preparer.RunTest(t) return result.TestContext, result.Config } func testAidlError(t *testing.T, pattern, bp string, customizers ...android.FixturePreparer) { t.Helper() preparer := _testAidl(t, bp, customizers...) preparer. ExtendWithErrorHandler(android.FixtureExpectsAtLeastOneErrorMatchingPattern(pattern)). RunTest(t) } // asserts that there are expected module regardless of variants func assertModulesExists(t *testing.T, ctx *android.TestContext, names ...string) { t.Helper() missing := []string{} for _, name := range names { variants := ctx.ModuleVariantsForTests(name) if len(variants) == 0 { missing = append(missing, name) } } if len(missing) > 0 { // find all the modules that do exist allModuleNames := make(map[string]bool) ctx.VisitAllModules(func(m blueprint.Module) { allModuleNames[ctx.ModuleName(m)] = true }) t.Errorf("expected modules(%v) not found. all modules: %v", missing, android.SortedKeys(allModuleNames)) } } func assertContains(t *testing.T, actual, expected string) { t.Helper() if !strings.Contains(actual, expected) { t.Errorf("%q is not found in %q.", expected, actual) } } func assertListContains(t *testing.T, actual []string, expected string) { t.Helper() for _, a := range actual { if strings.Contains(a, expected) { return } } t.Errorf("%q is not found in %v.", expected, actual) } // Vintf module must have versions in release version func TestVintfWithoutVersionInRelease(t *testing.T) { vintfWithoutVersionBp := ` aidl_interface { name: "foo", stability: "vintf", srcs: [ "IFoo.aidl", ], owner: "test", backend: { rust: { enabled: true, }, }, }` expectedError := `module "foo_interface": versions: must be set \(need to be frozen\) because` testAidlError(t, expectedError, vintfWithoutVersionBp, setTestFreezeEnv()) ctx, _ := testAidl(t, vintfWithoutVersionBp, setReleaseEnv()) assertModulesExists(t, ctx, "foo-V1-java", "foo-V1-rust", "foo-V1-cpp", "foo-V1-ndk") ctx, _ = testAidl(t, vintfWithoutVersionBp) assertModulesExists(t, ctx, "foo-V1-java", "foo-V1-rust", "foo-V1-cpp", "foo-V1-ndk") } // Check if using unstable version in release cause an error. func TestUnstableVersionUsageInRelease(t *testing.T) { unstableVersionUsageInJavaBp := ` aidl_interface { name: "foo", versions: [ "1", ], srcs: [ "IFoo.aidl", ], } java_library { name: "bar", libs: ["foo-V2-java"], }` files := withFiles(map[string][]byte{ "aidl_api/foo/1/foo.1.aidl": nil, "aidl_api/foo/1/.hash": nil, }) expectedError := `foo-V2-java is an unfrozen development version, and it can't be used because` testAidlError(t, expectedError, unstableVersionUsageInJavaBp, setTestFreezeEnv(), files) testAidl(t, unstableVersionUsageInJavaBp, setReleaseEnv(), files) testAidl(t, unstableVersionUsageInJavaBp, files) // A stable version can be used in release version stableVersionUsageInJavaBp := ` aidl_interface { name: "foo", versions: [ "1", ], srcs: [ "IFoo.aidl", ], } java_library { name: "bar", libs: ["foo-V1-java"], }` testAidl(t, stableVersionUsageInJavaBp, setReleaseEnv(), files) testAidl(t, stableVersionUsageInJavaBp, setTestFreezeEnv(), files) testAidl(t, stableVersionUsageInJavaBp, files) } func TestUsingUnstableVersionIndirectlyInRelease(t *testing.T) { unstableVersionUsageInJavaBp := ` aidl_interface { name: "xxx", srcs: ["IFoo.aidl"], versions: ["1"], } aidl_interface { name: "foo", imports: ["xxx-V2"], // not OK versions: ["1"], srcs: ["IFoo.aidl"], } java_library { name: "bar", libs: ["foo-V1-java"], // OK }` files := withFiles(map[string][]byte{ "aidl_api/foo/1/foo.1.aidl": nil, "aidl_api/foo/1/.hash": nil, "aidl_api/xxx/1/foo.1.aidl": nil, "aidl_api/xxx/1/.hash": nil, }) expectedError := `xxx-V2-java is an unfrozen development version` testAidlError(t, expectedError, unstableVersionUsageInJavaBp, setTestFreezeEnv(), files) testAidl(t, unstableVersionUsageInJavaBp, setReleaseEnv(), files) testAidl(t, unstableVersionUsageInJavaBp, files) } func TestFrozenTrueSimple(t *testing.T) { frozenTest := ` aidl_interface { name: "foo", versions: ["1"], frozen: true, srcs: ["IFoo.aidl"], }` files := withFiles(map[string][]byte{ "aidl_api/foo/1/foo.1.aidl": nil, "aidl_api/foo/1/.hash": nil, }) testAidl(t, frozenTest, files, setReleaseEnv()) testAidl(t, frozenTest, files, setTestFreezeEnv()) testAidl(t, frozenTest, files) } func TestFrozenWithNoVersions(t *testing.T) { frozenTest := ` aidl_interface { name: "foo", frozen: true, srcs: ["IFoo.aidl"], }` files := withFiles(map[string][]byte{ "aidl_api/foo/1/foo.1.aidl": nil, "aidl_api/foo/1/.hash": nil, }) expectedError := `cannot be frozen without versions` testAidlError(t, expectedError, frozenTest, files, setReleaseEnv()) testAidlError(t, expectedError, frozenTest, files, setTestFreezeEnv()) testAidlError(t, expectedError, frozenTest, files) } func TestFrozenImportingFrozen(t *testing.T) { frozenTest := ` aidl_interface { name: "xxx", srcs: ["IFoo.aidl"], frozen: true, versions: ["1"], } aidl_interface { name: "foo", imports: ["xxx-V1"], versions: ["1"], frozen: true, srcs: ["IFoo.aidl"], }` files := withFiles(map[string][]byte{ "aidl_api/foo/1/foo.1.aidl": nil, "aidl_api/foo/1/.hash": nil, "aidl_api/xxx/1/foo.1.aidl": nil, "aidl_api/xxx/1/.hash": nil, }) testAidl(t, frozenTest, files, setReleaseEnv()) testAidl(t, frozenTest, files, setTestFreezeEnv()) testAidl(t, frozenTest, files) } func TestFrozenImportingVersionUnfrozen(t *testing.T) { frozenTest := ` aidl_interface { name: "xxx", srcs: ["IFoo.aidl"], frozen: false, versions: ["1"], } aidl_interface { name: "foo", imports: ["xxx-V1"], versions: ["1"], frozen: true, srcs: ["IFoo.aidl"], }` files := withFiles(map[string][]byte{ "aidl_api/foo/1/foo.1.aidl": nil, "aidl_api/foo/1/.hash": nil, "aidl_api/xxx/1/foo.1.aidl": nil, "aidl_api/xxx/1/.hash": nil, }) testAidl(t, frozenTest, files, setReleaseEnv()) testAidl(t, frozenTest, files, setTestFreezeEnv()) testAidl(t, frozenTest, files) } func TestFrozenImportingUnfrozenWithFrozen(t *testing.T) { frozenTest := ` aidl_interface { name: "xxx", srcs: ["IFoo.aidl"], frozen: false, versions: ["1"], } aidl_interface { name: "foo", imports: ["xxx"], versions: ["1"], frozen: true, srcs: ["IFoo.aidl"], }` files := withFiles(map[string][]byte{ "aidl_api/foo/1/foo.1.aidl": nil, "aidl_api/foo/1/.hash": nil, "aidl_api/xxx/1/foo.1.aidl": nil, "aidl_api/xxx/1/.hash": nil, }) expectedError := `"foo" imports "xxx" which is not frozen. Either "foo" must` testAidlError(t, expectedError, frozenTest, files, setReleaseEnv()) testAidlError(t, expectedError, frozenTest, files, setTestFreezeEnv()) testAidlError(t, expectedError, frozenTest, files) } func TestFrozenImportingUnfrozen(t *testing.T) { frozenTest := ` aidl_interface { name: "xxx", srcs: ["IFoo.aidl"], owner: "test", frozen: false, } aidl_interface { name: "foo", imports: ["xxx"], versions: ["1"], frozen: true, srcs: ["IFoo.aidl"], }` files := withFiles(map[string][]byte{ "aidl_api/foo/1/foo.1.aidl": nil, "aidl_api/foo/1/.hash": nil, "aidl_api/xxx/1/foo.1.aidl": nil, "aidl_api/xxx/1/.hash": nil, }) expectedError := `versions: must be set \(need to be frozen\) because` testAidlError(t, expectedError, frozenTest, files, setTestFreezeEnv()) expectedError = `"foo" imports "xxx" which is not frozen. Either "foo" must` testAidlError(t, expectedError, frozenTest, files, setReleaseEnv()) testAidlError(t, expectedError, frozenTest, files) } // This is allowed to keep legacy behavior. It could be prevented directly after API-freeze // if all frozen interfaces are explicitly marked `frozen: true,`. func TestFrozenImportingUnSpecified(t *testing.T) { frozenTrueSimple := ` aidl_interface { name: "xxx", srcs: ["IFoo.aidl"], versions: ["1"], } aidl_interface { name: "foo", imports: ["xxx-V1"], versions: ["1"], frozen: true, srcs: ["IFoo.aidl"], }` files := withFiles(map[string][]byte{ "aidl_api/foo/1/foo.1.aidl": nil, "aidl_api/foo/1/.hash": nil, "aidl_api/xxx/1/foo.1.aidl": nil, "aidl_api/xxx/1/.hash": nil, }) testAidl(t, frozenTrueSimple, files, setReleaseEnv()) testAidl(t, frozenTrueSimple, files, setTestFreezeEnv()) testAidl(t, frozenTrueSimple, files) } // Keeping legacy behavior if "frozen" is not specified func TestImportingNewLegacy(t *testing.T) { frozenTest := ` aidl_interface { name: "xxx", srcs: ["IFoo.aidl"], versions: ["1"], } aidl_interface { name: "foo", imports: ["xxx-V2"], versions_with_info: [ {version: "1", imports: ["xxx-V1"]}, ], srcs: ["IFoo.aidl"], }` files := withFiles(map[string][]byte{ "aidl_api/foo/1/foo.1.aidl": nil, "aidl_api/foo/1/.hash": nil, "aidl_api/xxx/1/foo.1.aidl": nil, "aidl_api/xxx/1/.hash": nil, }) testAidl(t, frozenTest, files, setReleaseEnv()) testAidl(t, frozenTest, files, setTestFreezeEnv()) testAidl(t, frozenTest, files) } // We don't have a way to know if if "xxx" has changes to it and will // need a new version without the "frozen" attribute. So we keep the // legacy behavior and assume "foo" is still importing the old version. func TestFrozenImportingNewLegacy(t *testing.T) { frozenTest := ` aidl_interface { name: "xxx", srcs: ["IFoo.aidl"], versions: ["1"], } aidl_interface { name: "foo", imports: ["xxx-V1"], frozen: true, versions_with_info: [ {version: "1", imports: ["xxx-V1"]}, ], srcs: ["IFoo.aidl"], }` files := withFiles(map[string][]byte{ "aidl_api/foo/1/foo.1.aidl": nil, "aidl_api/foo/1/.hash": nil, "aidl_api/xxx/1/foo.1.aidl": nil, "aidl_api/xxx/1/.hash": nil, }) testAidl(t, frozenTest, files, setReleaseEnv()) testAidl(t, frozenTest, files, setTestFreezeEnv()) testAidl(t, frozenTest, files) } func TestFrozenImportingNewImplicit(t *testing.T) { frozenTest := ` aidl_interface { name: "xxx", srcs: ["IFoo.aidl"], frozen: false, versions: ["1"], } aidl_interface { name: "foo", imports: ["xxx"], frozen: true, versions_with_info: [ {version: "1", imports: ["xxx-V1"]}, ], srcs: ["IFoo.aidl"], }` files := withFiles(map[string][]byte{ "aidl_api/foo/1/foo.1.aidl": nil, "aidl_api/foo/1/.hash": nil, "aidl_api/xxx/1/foo.1.aidl": nil, "aidl_api/xxx/1/.hash": nil, }) expectedError := `"foo" imports "xxx" which is not frozen. Either "foo" must` testAidlError(t, expectedError, frozenTest, files, setReleaseEnv()) testAidlError(t, expectedError, frozenTest, files, setTestFreezeEnv()) testAidlError(t, expectedError, frozenTest, files) } func TestImportingOwned(t *testing.T) { frozenTest := ` aidl_interface { name: "xxx", srcs: ["IFoo.aidl"], owner: "unknown-owner", frozen: false, } aidl_interface { name: "foo", imports: ["xxx-V1"], frozen: false, versions_with_info: [ {version: "1", imports: []}, ], srcs: ["IFoo.aidl"], }` files := withFiles(map[string][]byte{ "aidl_api/foo/1/foo.1.aidl": nil, "aidl_api/foo/1/.hash": nil, }) expectedError := "Android.bp:10:10: module \"foo_interface\": imports: \"foo\" imports \"xxx\" which is an interface owned by \"unknown-owner\". This is not allowed because the owned interface will not be frozen at the same time." testAidlError(t, expectedError, frozenTest, files, setReleaseEnv()) testAidlError(t, expectedError, frozenTest, files, setTestFreezeEnv()) testAidlError(t, expectedError, frozenTest, files) } func TestImportingOwnedBothOwned(t *testing.T) { frozenTest := ` aidl_interface { name: "xxx", srcs: ["IFoo.aidl"], owner: "unknown-owner", frozen: false, } aidl_interface { name: "foo", imports: ["xxx-V1"], frozen: false, versions_with_info: [ {version: "1", imports: []}, ], srcs: ["IFoo.aidl"], owner: "unknown-owner-any", }` files := withFiles(map[string][]byte{ "aidl_api/foo/1/foo.1.aidl": nil, "aidl_api/foo/1/.hash": nil, }) testAidl(t, frozenTest, files, setReleaseEnv()) testAidl(t, frozenTest, files, setTestFreezeEnv()) testAidl(t, frozenTest, files) } func TestFrozenImportingNewExplicit(t *testing.T) { frozenTest := ` aidl_interface { name: "xxx", srcs: ["IFoo.aidl"], frozen: false, versions: ["1"], } aidl_interface { name: "foo", imports: ["xxx-V2"], frozen: true, versions_with_info: [ {version: "1", imports: ["xxx-V1"]}, ], srcs: ["IFoo.aidl"], }` files := withFiles(map[string][]byte{ "aidl_api/foo/1/foo.1.aidl": nil, "aidl_api/foo/1/.hash": nil, "aidl_api/xxx/1/foo.1.aidl": nil, "aidl_api/xxx/1/.hash": nil, }) expectedError := "This interface is 'frozen: true' but the imports have changed. Set 'frozen: false' to allow changes: \\n Version current imports: map\\[xxx:2\\]\\n Version 1 imports: map\\[xxx:1\\]\\n" testAidlError(t, expectedError, frozenTest, files, setReleaseEnv()) testAidlError(t, expectedError, frozenTest, files, setTestFreezeEnv()) testAidlError(t, expectedError, frozenTest, files) } func TestNonFrozenImportingNewImplicit(t *testing.T) { frozenTest := ` aidl_interface { name: "xxx", srcs: ["IFoo.aidl"], frozen: false, versions: ["1"], } aidl_interface { name: "foo", imports: ["xxx-V1"], frozen: false, versions_with_info: [ {version: "1", imports: ["xxx-V1"]}, ], srcs: ["IFoo.aidl"], }` files := withFiles(map[string][]byte{ "aidl_api/foo/1/foo.1.aidl": nil, "aidl_api/foo/1/.hash": nil, "aidl_api/xxx/1/foo.1.aidl": nil, "aidl_api/xxx/1/.hash": nil, }) testAidl(t, frozenTest, files, setReleaseEnv()) testAidl(t, frozenTest, files, setTestFreezeEnv()) testAidl(t, frozenTest, files) } // The module which has never been frozen and is not "unstable" is not allowed in release version. func TestNonVersionedModuleUsageInRelease(t *testing.T) { nonVersionedModuleUsageInJavaBp := ` aidl_interface { name: "foo", srcs: [ "IFoo.aidl", ], owner: "test", } java_library { name: "bar", libs: ["foo-V1-java"], }` expectedError := `"foo_interface": versions: must be set \(need to be frozen\) because` testAidlError(t, expectedError, nonVersionedModuleUsageInJavaBp, setTestFreezeEnv()) testAidl(t, nonVersionedModuleUsageInJavaBp, setReleaseEnv()) testAidl(t, nonVersionedModuleUsageInJavaBp) nonVersionedUnstableModuleUsageInJavaBp := ` aidl_interface { name: "foo", srcs: [ "IFoo.aidl", ], unstable: true, } java_library { name: "bar", libs: ["foo-java"], }` testAidl(t, nonVersionedUnstableModuleUsageInJavaBp, setReleaseEnv()) testAidl(t, nonVersionedUnstableModuleUsageInJavaBp, setTestFreezeEnv()) testAidl(t, nonVersionedUnstableModuleUsageInJavaBp) } func TestNonVersionedModuleOwnedByTestUsageInRelease(t *testing.T) { nonVersionedModuleUsageInJavaBp := ` aidl_interface { name: "foo", owner: "test", srcs: [ "IFoo.aidl", ], } java_library { name: "bar", libs: ["foo-V1-java"], }` expectedError := `"foo_interface": versions: must be set \(need to be frozen\) because` testAidl(t, nonVersionedModuleUsageInJavaBp, setReleaseEnv()) testAidlError(t, expectedError, nonVersionedModuleUsageInJavaBp, setTestFreezeEnv()) testAidl(t, nonVersionedModuleUsageInJavaBp) } func TestNonVersionedModuleOwnedByOtherUsageInRelease(t *testing.T) { nonVersionedModuleUsageInJavaBp := ` aidl_interface { name: "foo", owner: "unknown-owner", srcs: [ "IFoo.aidl", ], } java_library { name: "bar", libs: ["foo-V1-java"], }` testAidl(t, nonVersionedModuleUsageInJavaBp, setReleaseEnv()) testAidl(t, nonVersionedModuleUsageInJavaBp, setTestFreezeEnv()) testAidl(t, nonVersionedModuleUsageInJavaBp) } func TestImportInRelease(t *testing.T) { importInRelease := ` aidl_interface { name: "foo", srcs: [ "IFoo.aidl", ], imports: ["bar-V1"], versions: ["1"], } aidl_interface { name: "bar", srcs: [ "IBar.aidl", ], versions: ["1"], } ` files := withFiles(map[string][]byte{ "aidl_api/foo/1/foo.1.aidl": nil, "aidl_api/foo/1/.hash": nil, "aidl_api/bar/1/bar.1.aidl": nil, "aidl_api/bar/1/.hash": nil, }) testAidl(t, importInRelease, setReleaseEnv(), files) testAidl(t, importInRelease, setTestFreezeEnv(), files) testAidl(t, importInRelease, files) } func TestUnstableVersionedModuleUsageInRelease(t *testing.T) { nonVersionedModuleUsageInJavaBp := ` aidl_interface { name: "foo", srcs: [ "IFoo.aidl", ], versions: ["1"], } java_library { name: "bar", libs: ["foo-V2-java"], }` expectedError := `module \"bar\" variant \"android_common\": foo-V2-java is an unfrozen development version` testAidlError(t, expectedError, nonVersionedModuleUsageInJavaBp, setTestFreezeEnv()) testAidl(t, nonVersionedModuleUsageInJavaBp, withFiles(map[string][]byte{ "aidl_api/foo/1/foo.1.aidl": nil, "aidl_api/foo/1/.hash": nil, }), setReleaseEnv()) testAidl(t, nonVersionedModuleUsageInJavaBp, withFiles(map[string][]byte{ "aidl_api/foo/1/foo.1.aidl": nil, "aidl_api/foo/1/.hash": nil, })) } func TestUnstableVersionedModuleOwnedByTestUsageInRelease(t *testing.T) { nonVersionedModuleUsageInJavaBp := ` aidl_interface { name: "foo", owner: "test", srcs: [ "IFoo.aidl", ], versions: ["1"], } java_library { name: "bar", libs: ["foo-V2-java"], }` files := withFiles(map[string][]byte{ "aidl_api/foo/1/foo.1.aidl": nil, "aidl_api/foo/1/.hash": nil, }) expectedError := `Android.bp:11:2: module \"bar\" variant \"android_common\": foo-V2-java is an unfrozen development version` testAidl(t, nonVersionedModuleUsageInJavaBp, setReleaseEnv(), files) testAidlError(t, expectedError, nonVersionedModuleUsageInJavaBp, setTestFreezeEnv(), files) testAidl(t, nonVersionedModuleUsageInJavaBp, files) } func TestFrozenModuleUsageInAllEnvs(t *testing.T) { bp := ` aidl_interface { name: "foo", frozen: true, srcs: [ "IFoo.aidl", ], versions: ["1"], } java_library { name: "bar", libs: ["foo-V2-java"], }` files := withFiles(map[string][]byte{ "aidl_api/foo/1/foo.1.aidl": nil, "aidl_api/foo/1/.hash": nil, }) expectedError := `Android.bp:11:2: module \"bar\" variant \"android_common\": foo-V2-java is an unfrozen development version` testAidlError(t, expectedError, bp, setReleaseEnv(), files) testAidlError(t, expectedError, bp, setTestFreezeEnv(), files) testAidlError(t, expectedError, bp, files) } func TestUnstableVersionedModuleOwnedByOtherUsageInRelease(t *testing.T) { nonVersionedModuleUsageInJavaBp := ` aidl_interface { name: "foo", owner: "unknown-owner", srcs: [ "IFoo.aidl", ], versions: ["1"], } java_library { name: "bar", libs: ["foo-V2-java"], }` files := withFiles(map[string][]byte{ "aidl_api/foo/1/foo.1.aidl": nil, "aidl_api/foo/1/.hash": nil, }) testAidl(t, nonVersionedModuleUsageInJavaBp, setReleaseEnv(), files) testAidl(t, nonVersionedModuleUsageInJavaBp, setTestFreezeEnv(), files) testAidl(t, nonVersionedModuleUsageInJavaBp, files) } func TestUnstableModules(t *testing.T) { testAidlError(t, `module "foo_interface": stability: must be empty when "unstable" is true`, ` aidl_interface { name: "foo", stability: "vintf", unstable: true, srcs: [ "IFoo.aidl", ], backend: { rust: { enabled: true, }, }, } `) testAidlError(t, `module "foo_interface": versions: cannot have versions for an unstable interface`, ` aidl_interface { name: "foo", versions: [ "1", ], unstable: true, srcs: [ "IFoo.aidl", ], backend: { rust: { enabled: true, }, }, } `) ctx, _ := testAidl(t, ` aidl_interface { name: "foo", unstable: true, srcs: [ "IFoo.aidl", ], backend: { rust: { enabled: true, }, }, } `) assertModulesExists(t, ctx, "foo-java", "foo-rust", "foo-cpp", "foo-ndk") } func TestCreatesModulesWithNoVersions(t *testing.T) { ctx, _ := testAidl(t, ` aidl_interface { name: "foo", srcs: [ "IFoo.aidl", ], backend: { rust: { enabled: true, }, }, } `) assertModulesExists(t, ctx, "foo-V1-java", "foo-V1-rust", "foo-V1-cpp", "foo-V1-ndk") } func TestCreatesModulesWithFrozenVersions(t *testing.T) { // Each version should be under aidl_api// testAidlError(t, `No sources for a previous version in aidl_api/foo/1. Was a version manually added to .bp file?`, ` aidl_interface { name: "foo", srcs: [ "IFoo.aidl", ], versions: [ "1", ], backend: { rust: { enabled: true, }, }, } `) ctx, _ := testAidl(t, ` aidl_interface { name: "foo", srcs: [ "IFoo.aidl", ], versions: [ "1", ], backend: { rust: { enabled: true, }, }, } `, withFiles(map[string][]byte{ "aidl_api/foo/1/foo.1.aidl": nil, "aidl_api/foo/1/.hash": nil, })) // For frozen version "1" assertModulesExists(t, ctx, "foo-V1-java", "foo-V1-rust", "foo-V1-cpp", "foo-V1-ndk") // For ToT (current) assertModulesExists(t, ctx, "foo-V2-java", "foo-V2-rust", "foo-V2-cpp", "foo-V2-ndk") } func TestErrorsWithUnsortedVersions(t *testing.T) { testAidlError(t, `versions: should be sorted`, ` aidl_interface { name: "foo", srcs: [ "IFoo.aidl", ], versions: [ "2", "1", ], backend: { rust: { enabled: true, }, }, } `) } func TestErrorsWithDuplicateVersions(t *testing.T) { testAidlError(t, `versions: duplicate`, ` aidl_interface { name: "foo", srcs: [ "IFoo.aidl", ], versions: [ "1", "1", ], } `) } func TestErrorsWithNonPositiveVersions(t *testing.T) { testAidlError(t, `versions: should be > 0`, ` aidl_interface { name: "foo", srcs: [ "IFoo.aidl", ], versions: [ "-1", "1", ], } `) } func TestErrorsWithNonIntegerVersions(t *testing.T) { testAidlError(t, `versions: "first" is not an integer`, ` aidl_interface { name: "foo", srcs: [ "IFoo.aidl", ], versions: [ "first", ], } `) } const ( androidVariant = "android_common" nativeVariant = "android_arm_armv7-a-neon_shared" nativeRustVariant = "android_arm_armv7-a-neon_dylib" ) func TestNativeOutputIsAlwaysVersioned(t *testing.T) { var ctx *android.TestContext assertOutput := func(moduleName, variant, outputFilename string) { t.Helper() producer, ok := ctx.ModuleForTests(moduleName, variant).Module().(android.OutputFileProducer) if !ok { t.Errorf("%s(%s): should be OutputFileProducer.", moduleName, variant) } paths, err := producer.OutputFiles("") if err != nil { t.Errorf("%s(%s): failed to get OutputFiles: %v", moduleName, variant, err) } if len(paths) != 1 || paths[0].Base() != outputFilename { t.Errorf("%s(%s): expected output %q, but got %v", moduleName, variant, outputFilename, paths) } } // No versions ctx, _ = testAidl(t, ` aidl_interface { name: "foo", srcs: [ "IFoo.aidl", ], backend: { rust: { enabled: true, }, }, } `) // Even though there is no version, generated modules have version(V1) unless it isn't an unstable interface. assertOutput("foo-V1-java", androidVariant, "foo-V1-java.jar") assertOutput("foo-V1-cpp", nativeVariant, "foo-V1-cpp.so") assertOutput("foo-V1-rust", nativeRustVariant, "libfoo_V1.dylib.so") // With versions: "1", "2" ctx, _ = testAidl(t, ` aidl_interface { name: "foo", srcs: [ "IFoo.aidl", ], versions: [ "1", "2", ], backend: { rust: { enabled: true, }, }, } `, withFiles(map[string][]byte{ "aidl_api/foo/1/foo.1.aidl": nil, "aidl_api/foo/1/.hash": nil, "aidl_api/foo/2/foo.2.aidl": nil, "aidl_api/foo/2/.hash": nil, })) // alias for the latest frozen version (=2) assertOutput("foo-V2-java", androidVariant, "foo-V2-java.jar") assertOutput("foo-V2-cpp", nativeVariant, "foo-V2-cpp.so") assertOutput("foo-V2-rust", nativeRustVariant, "libfoo_V2.dylib.so") // frozen "1" assertOutput("foo-V1-java", androidVariant, "foo-V1-java.jar") assertOutput("foo-V1-cpp", nativeVariant, "foo-V1-cpp.so") assertOutput("foo-V1-rust", nativeRustVariant, "libfoo_V1.dylib.so") // tot assertOutput("foo-V3-java", androidVariant, "foo-V3-java.jar") assertOutput("foo-V3-cpp", nativeVariant, "foo-V3-cpp.so") assertOutput("foo-V3-rust", nativeRustVariant, "libfoo_V3.dylib.so") // skip ndk since they follow the same rule with cpp } func TestImports(t *testing.T) { testAidlError(t, `Import does not exist:`, ` aidl_interface { name: "foo", srcs: [ "IFoo.aidl", ], imports: [ "bar", ] } `) testAidlError(t, `backend.java.enabled: Java backend not enabled in the imported AIDL interface "bar"`, ` aidl_interface { name: "foo", srcs: [ "IFoo.aidl", ], imports: [ "bar-V1", ] } aidl_interface { name: "bar", srcs: [ "IBar.aidl", ], backend: { java: { enabled: false, }, }, } `) testAidlError(t, `backend.cpp.enabled: C\+\+ backend not enabled in the imported AIDL interface "bar"`, ` aidl_interface { name: "foo", srcs: [ "IFoo.aidl", ], imports: [ "bar-V1", ] } aidl_interface { name: "bar", srcs: [ "IBar.aidl", ], backend: { cpp: { enabled: false, }, }, } `) testAidlError(t, `imports: "foo" depends on "bar" but does not specify a version`, ` aidl_interface { name: "foo", unstable: true, srcs: [ "IFoo.aidl", ], imports: [ "bar", ] } aidl_interface { name: "bar", srcs: [ "IBar.aidl", ], } `) ctx, _ := testAidl(t, ` aidl_interface_defaults { name: "foo-defaults", srcs: [ "IFoo.aidl", ], backend: { rust: { enabled: true, }, }, imports: [ "bar.1-V1", ] } aidl_interface { name: "foo", defaults: ["foo-defaults"], } aidl_interface { name: "bar.1", srcs: [ "IBar.aidl", ], backend: { rust: { enabled: true, }, }, } `) ldRule := ctx.ModuleForTests("foo-V1-cpp", nativeVariant).Rule("ld") libFlags := ldRule.Args["libFlags"] libBar := filepath.Join("bar.1-V1-cpp", nativeVariant, "bar.1-V1-cpp.so") if !strings.Contains(libFlags, libBar) { t.Errorf("%q is not found in %q", libBar, libFlags) } rustcRule := ctx.ModuleForTests("foo-V1-rust", nativeRustVariant).Rule("rustc") libFlags = rustcRule.Args["libFlags"] libBar = filepath.Join("out", "soong", ".intermediates", "bar.1-V1-rust", nativeRustVariant, "unstripped", "libbar_1_V1.dylib.so") libBarFlag := "--extern bar_1=" + libBar if !strings.Contains(libFlags, libBarFlag) { t.Errorf("%q is not found in %q", libBarFlag, libFlags) } } func TestDuplicatedVersions(t *testing.T) { // foo depends on myiface-V2-ndk via direct dep and also on // myiface-V1-ndk via indirect dep. This should be prohibited. testAidlError(t, `depends on multiple versions of the same aidl_interface: myiface-V1-.*, myiface-V2-.*`, ` aidl_interface { name: "myiface", srcs: ["IFoo.aidl"], versions: ["1", "2"], } cc_library { name: "foo", shared_libs: ["myiface-V2-ndk", "bar"], } cc_library { name: "bar", shared_libs: ["myiface-V1-ndk"], } `, withFiles(map[string][]byte{ "aidl_api/myiface/1/myiface.1.aidl": nil, "aidl_api/myiface/1/.hash": nil, "aidl_api/myiface/2/myiface.2.aidl": nil, "aidl_api/myiface/2/.hash": nil, })) testAidlError(t, `depends on multiple versions of the same aidl_interface: myiface-V1-.*, myiface-V2-.*`, ` aidl_interface { name: "myiface", srcs: ["IFoo.aidl"], versions: ["1"], } aidl_interface { name: "myiface2", srcs: ["IBar.aidl"], imports: ["myiface-V2"] } cc_library { name: "foobar", shared_libs: ["myiface-V1-ndk", "myiface2-V1-ndk"], } `, withFiles(map[string][]byte{ "aidl_api/myiface/1/myiface.1.aidl": nil, "aidl_api/myiface/1/.hash": nil, })) testAidlError(t, `depends on multiple versions of the same aidl_interface: myiface-V1-.*, myiface-V2-.*`, ` aidl_interface { name: "myiface", srcs: ["IFoo.aidl"], versions: ["1"], } aidl_interface { name: "myiface2", srcs: ["IBar.aidl"], imports: ["myiface-V2"] } cc_library { name: "foobar", srcs: [":myiface-V1-ndk-source"], shared_libs: ["myiface2-V1-ndk"], } `, withFiles(map[string][]byte{ "aidl_api/myiface/1/myiface.1.aidl": nil, "aidl_api/myiface/1/.hash": nil, })) // Okay to reference two different testAidl(t, ` aidl_interface { name: "myiface", srcs: ["IFoo.aidl"], versions: ["1"], } cc_library { name: "foobar", shared_libs: ["myiface-V1-cpp", "myiface-V1-ndk"], } `, withFiles(map[string][]byte{ "aidl_api/myiface/1/myiface.1.aidl": nil, "aidl_api/myiface/1/.hash": nil, })) testAidl(t, ` aidl_interface { name: "myiface", srcs: ["IFoo.aidl"], versions: ["1"], } aidl_interface { name: "myiface2", srcs: ["IBar.aidl"], imports: ["myiface-V2"] } cc_library { name: "foobar", srcs: [":myiface-V2-ndk-source"], shared_libs: ["myiface2-V1-ndk"], } `, withFiles(map[string][]byte{ "aidl_api/myiface/1/myiface.1.aidl": nil, "aidl_api/myiface/1/.hash": nil, })) testAidl(t, ` aidl_interface { name: "myiface", srcs: ["IFoo.aidl"], versions: ["1"], } aidl_interface { name: "myiface2", srcs: ["IBar.aidl"], imports: ["myiface-V2"] } cc_library { name: "foobar", shared_libs: ["myiface-V2-ndk", "myiface2-V1-ndk"], } `, withFiles(map[string][]byte{ "aidl_api/myiface/1/myiface.1.aidl": nil, "aidl_api/myiface/1/.hash": nil, })) } func TestRecoveryAvailable(t *testing.T) { ctx, _ := testAidl(t, ` aidl_interface { name: "myiface", recovery_available: true, srcs: ["IFoo.aidl"], } `) ctx.ModuleForTests("myiface-V1-ndk", "android_recovery_arm64_armv8-a_shared") ctx.ModuleForTests("myiface-V1-cpp", "android_recovery_arm64_armv8-a_shared") } func TestRustDuplicateNames(t *testing.T) { testAidl(t, ` aidl_interface { name: "myiface", srcs: ["dir/a/Foo.aidl", "dir/b/Foo.aidl"], backend: { rust: { enabled: true, }, }, } `) } func TestAidlImportFlagsForImportedModules(t *testing.T) { customizer := withFiles(map[string][]byte{ "foo/Android.bp": []byte(` aidl_interface { name: "foo-iface", srcs: ["a/Foo.aidl"], imports: ["bar-iface-V2"], versions: ["1"], headers: ["boq-iface-headers"], } `), "foo/a/Foo.aidl": nil, "foo/aidl_api/foo-iface/current/a/Foo.aidl": nil, "foo/aidl_api/foo-iface/1/a/Foo.aidl": nil, "foo/aidl_api/foo-iface/1/.hash": nil, "bar/Android.bp": []byte(` aidl_interface { name: "bar-iface", srcs: ["b/Bar.aidl"], imports: ["baz-iface-V1"], versions: ["1"], } `), "bar/b/Bar.aidl": nil, "bar/aidl_api/bar-iface/current/b/Bar.aidl": nil, "bar/aidl_api/bar-iface/1/b/Bar.aidl": nil, "bar/aidl_api/bar-iface/1/.hash": nil, "baz/Android.bp": []byte(` aidl_interface { name: "baz-iface", srcs: ["b/Baz.aidl"], include_dirs: ["baz-include"], versions: ["1"], } `), "baz/b/Baz.aidl": nil, "baz/aidl_api/baz-iface/current/b/Baz.aidl": nil, "baz/aidl_api/baz-iface/1/b/Baz.aidl": nil, "baz/aidl_api/baz-iface/1/.hash": nil, "boq/Android.bp": []byte(` aidl_library { name: "boq-iface-headers", srcs: ["b/Boq.aidl"], } `), "boq/b/Baz.aidl": nil, }) ctx, _ := testAidl(t, ``, customizer) // checkapidump rule is to compare "compatibility" between ToT(dump) and "current" { rule := ctx.ModuleForTests("foo-iface-api", "").Output("checkapi_dump.timestamp") android.AssertStringEquals(t, "checkapi(dump == current) imports", "-Iboq", rule.Args["imports"]) android.AssertStringDoesContain(t, "checkapi(dump == current) optionalFlags", rule.Args["optionalFlags"], "-pout/soong/.intermediates/bar/bar-iface_interface/2/preprocessed.aidl") } // has_development rule runs --checkapi for equality between latest("1") // and ToT { rule := ctx.ModuleForTests("foo-iface-api", "").Output("has_development") android.AssertStringDoesContain(t, "checkapi(dump == latest(1)) should import import's preprocessed", rule.RuleParams.Command, "-pout/soong/.intermediates/bar/bar-iface_interface/2/preprocessed.aidl") } // compile (v1) { rule := ctx.ModuleForTests("foo-iface-V1-cpp-source", "").Output("a/Foo.cpp") android.AssertStringEquals(t, "compile(old=1) should import aidl_api/1", "-Iboq -Nfoo/aidl_api/foo-iface/1", rule.Args["imports"]+" "+rule.Args["nextImports"]) android.AssertStringDoesContain(t, "compile(old=1) should import bar.preprocessed", rule.Args["optionalFlags"], "-pout/soong/.intermediates/bar/bar-iface_interface/2/preprocessed.aidl") } // compile ToT(v2) { rule := ctx.ModuleForTests("foo-iface-V2-cpp-source", "").Output("a/Foo.cpp") android.AssertStringEquals(t, "compile(tot=2) should import base dirs of srcs", "-Iboq -Nfoo", rule.Args["imports"]+" "+rule.Args["nextImports"]) android.AssertStringDoesContain(t, "compile(tot=2) should import bar.preprocessed", rule.Args["optionalFlags"], "-pout/soong/.intermediates/bar/bar-iface_interface/2/preprocessed.aidl") } } func TestAidlPreprocess(t *testing.T) { customizer := withFiles(map[string][]byte{ "foo/Android.bp": []byte(` aidl_interface { name: "foo-iface", local_include_dir: "src", include_dirs: [ "path1", "path2/sub", ], srcs: [ "src/foo/Foo.aidl", ], imports: [ "bar-iface", ], unstable: true, } aidl_interface { name: "bar-iface", local_include_dir: "src", srcs: [ "src/bar/Bar.aidl", ], unstable: true, } `), "foo/src/foo/Foo.aidl": nil, "foo/src/bar/Bar.aidl": nil, }) ctx, _ := testAidl(t, ``, customizer) rule := ctx.ModuleForTests("foo-iface_interface", "").Output("preprocessed.aidl") android.AssertStringDoesContain(t, "preprocessing should import srcs and include_dirs", rule.RuleParams.Command, "-Ifoo/src -Ipath1 -Ipath2/sub") android.AssertStringDoesContain(t, "preprocessing should import import's preprocess", rule.RuleParams.Command, "-pout/soong/.intermediates/foo/bar-iface_interface/preprocessed.aidl") } func TestAidlImportFlagsForUnstable(t *testing.T) { customizer := withFiles(map[string][]byte{ "foo/Android.bp": []byte(` aidl_interface { name: "foo-iface", local_include_dir: "src", include_dirs: [ "path1", "path2/sub", ], srcs: [ "src/foo/Foo.aidl", ], imports: [ "bar-iface", ], unstable: true, } aidl_interface { name: "bar-iface", local_include_dir: "src", srcs: [ "src/bar/Bar.aidl", ], unstable: true, } `), "foo/src/foo/Foo.aidl": nil, "foo/src/bar/Bar.aidl": nil, }) ctx, _ := testAidl(t, ``, customizer) rule := ctx.ModuleForTests("foo-iface-cpp-source", "").Output("foo/Foo.cpp") android.AssertStringEquals(t, "compile(unstable) should import foo/base_dirs(target) and bar/base_dirs(imported)", "-Ipath1 -Ipath2/sub -Nfoo/src", rule.Args["imports"]+" "+rule.Args["nextImports"]) android.AssertStringDoesContain(t, "compile(unstable) should import bar.preprocessed", rule.Args["optionalFlags"], "-pout/soong/.intermediates/foo/bar-iface_interface/preprocessed.aidl") } func TestSupportsGenruleAndFilegroup(t *testing.T) { customizer := withFiles(map[string][]byte{ "foo/Android.bp": []byte(` aidl_interface { name: "foo-iface", local_include_dir: "src", include_dirs: [ "path1", "path2/sub", ], srcs: [ "src/foo/Foo.aidl", ":filegroup1", ":gen1", ], imports: [ "bar-iface-V1", ], versions: ["1"], } filegroup { name: "filegroup1", path: "filegroup/sub", srcs: [ "filegroup/sub/pkg/Bar.aidl", ], } genrule { name: "gen1", cmd: "generate baz/Baz.aidl", out: [ "baz/Baz.aidl", ] } aidl_interface { name: "bar-iface", local_include_dir: "src", srcs: [ "src/bar/Bar.aidl", ":gen-bar", ], } genrule { name: "gen-bar", cmd: "generate gen/GenBar.aidl", out: [ "gen/GenBar.aidl", ] } `), "foo/aidl_api/foo-iface/1/foo/Foo.aidl": nil, "foo/aidl_api/foo-iface/1/.hash": nil, "foo/filegroup/sub/pkg/Bar.aidl": nil, "foo/src/foo/Foo.aidl": nil, }) ctx, _ := testAidl(t, ``, customizer) // aidlCompile for snapshots (v1) { rule := ctx.ModuleForTests("foo-iface-V1-cpp-source", "").Output("foo/Foo.cpp") android.AssertStringEquals(t, "compile(1) should import foo/aidl_api/1", "-Ipath1 -Ipath2/sub -Nfoo/aidl_api/foo-iface/1", rule.Args["imports"]+" "+rule.Args["nextImports"]) android.AssertStringDoesContain(t, "compile(1) should import bar.preprocessed", rule.Args["optionalFlags"], "-pout/soong/.intermediates/foo/bar-iface_interface/1/preprocessed.aidl") } // aidlCompile for ToT (v2) { rule := ctx.ModuleForTests("foo-iface-V2-cpp-source", "").Output("foo/Foo.cpp") android.AssertStringEquals(t, "compile(tot=2) should import foo.base_dirs", "-Ipath1 -Ipath2/sub -Nfoo/src -Nfoo/filegroup/sub -Nout/soong/.intermediates/foo/gen1/gen", rule.Args["imports"]+" "+rule.Args["nextImports"]) android.AssertStringDoesContain(t, "compile(tot=2) should import bar.preprocessed", rule.Args["optionalFlags"], "-pout/soong/.intermediates/foo/bar-iface_interface/1/preprocessed.aidl") } // dumpapi { rule := ctx.ModuleForTests("foo-iface-api", "").Rule("aidlDumpApiRule") android.AssertPathsRelativeToTopEquals(t, "dumpapi should dump srcs/filegroups/genrules", []string{ "foo/src/foo/Foo.aidl", "foo/filegroup/sub/pkg/Bar.aidl", "out/soong/.intermediates/foo/gen1/gen/baz/Baz.aidl", }, rule.Inputs) dumpDir := "out/soong/.intermediates/foo/foo-iface-api/dump" android.AssertPathsRelativeToTopEquals(t, "dumpapi should dump with rel paths", []string{ dumpDir + "/foo/Foo.aidl", dumpDir + "/pkg/Bar.aidl", dumpDir + "/baz/Baz.aidl", dumpDir + "/.hash", }, rule.Outputs.Paths()) android.AssertStringEquals(t, "dumpapi should import base_dirs and include_dirs", "-Ifoo/src -Ifoo/filegroup/sub -Iout/soong/.intermediates/foo/gen1/gen -Ipath1 -Ipath2/sub", rule.Args["imports"]) android.AssertStringDoesContain(t, "dumpapi should import bar.preprocessed", rule.Args["optionalFlags"], "-pout/soong/.intermediates/foo/bar-iface_interface/1/preprocessed.aidl") } } func TestAidlFlags(t *testing.T) { ctx, _ := testAidl(t, ` aidl_interface { name: "myiface", srcs: ["a/Foo.aidl", "b/Bar.aidl"], flags: ["-Weverything", "-Werror"], backend: { rust: { enabled: true }} } `) for module, outputs := range map[string][]string{ "myiface-V1-cpp-source": {"a/Foo.h", "b/Bar.h"}, "myiface-V1-java-source": {"a/Foo.java", "b/Bar.java"}, "myiface-V1-ndk-source": {"aidl/a/Foo.h", "aidl/b/Bar.h"}, "myiface-V1-rust-source": {"a/Foo.rs", "b/Bar.rs"}, } { for _, output := range outputs { t.Run(module+"/"+output, func(t *testing.T) { params := ctx.ModuleForTests(module, "").Output(output) assertContains(t, params.Args["optionalFlags"], "-Weverything") assertContains(t, params.Args["optionalFlags"], "-Werror") }) } } } func TestAidlModuleJavaSdkVersionDeterminesMinSdkVersion(t *testing.T) { ctx, _ := testAidl(t, ` aidl_interface { name: "myiface", srcs: ["a/Foo.aidl"], backend: { java: { sdk_version: "28", }, }, } `, java.FixtureWithPrebuiltApis(map[string][]string{"28": {"foo"}})) params := ctx.ModuleForTests("myiface-V1-java-source", "").Output("a/Foo.java") assertContains(t, params.Args["optionalFlags"], "--min_sdk_version 28") } func TestAidlModuleNameContainsVersion(t *testing.T) { testAidlError(t, "aidl_interface should not have '-V suffix", ` aidl_interface { name: "myiface-V2", srcs: ["a/Foo.aidl", "b/Bar.aidl"], } `) // Ugly, but okay testAidl(t, ` aidl_interface { name: "myiface-V2aa", srcs: ["a/Foo.aidl", "b/Bar.aidl"], } `) } func TestExplicitAidlModuleImport(t *testing.T) { for _, importVersion := range []string{"V1", "V2"} { ctx, _ := testAidl(t, ` aidl_interface { name: "foo", srcs: ["Foo.aidl"], versions: [ "1", ], imports: ["bar-`+importVersion+`"] } aidl_interface { name: "bar", srcs: ["Bar.aidl"], versions: [ "1", ], } `, withFiles(map[string][]byte{ "aidl_api/foo/1/Foo.aidl": nil, "aidl_api/foo/1/.hash": nil, "aidl_api/bar/1/Bar.aidl": nil, "aidl_api/bar/1/.hash": nil, })) for _, foo := range []string{"foo-V1-cpp", "foo-V2-cpp"} { ldRule := ctx.ModuleForTests(foo, nativeVariant).Rule("ld") libFlags := ldRule.Args["libFlags"] libBar := filepath.Join("bar-"+importVersion+"-cpp", nativeVariant, "bar-"+importVersion+"-cpp.so") if !strings.Contains(libFlags, libBar) { t.Errorf("%q is not found in %q", libBar, libFlags) } } } testAidlError(t, "module \"foo_interface\": imports: \"foo\" depends on \"bar\" version \"3\"", ` aidl_interface { name: "foo", srcs: ["Foo.aidl"], versions: [ "1", ], imports: ["bar-V3"] } aidl_interface { name: "bar", srcs: ["Bar.aidl"], versions: [ "1", ], } `, withFiles(map[string][]byte{ "aidl_api/foo/1/Foo.aidl": nil, "aidl_api/foo/1/.hash": nil, "aidl_api/bar/1/Bar.aidl": nil, "aidl_api/bar/1/.hash": nil, })) } func TestUseVersionedPreprocessedWhenImporotedWithVersions(t *testing.T) { ctx, _ := testAidl(t, ` aidl_interface { name: "unstable-foo", srcs: ["foo/Foo.aidl"], imports: [ "bar-V2", "baz-V1", "unstable-bar", ], unstable: true, } aidl_interface { name: "foo", srcs: ["foo/Foo.aidl"], imports: [ "bar-V1", "baz-V1", ], versions: ["1"], } aidl_interface { name: "foo-no-versions", srcs: ["foo/Foo.aidl"], imports: [ "bar-V2", ], } aidl_interface { name: "bar", srcs: ["bar/Bar.aidl"], versions: ["1"], } aidl_interface { name: "unstable-bar", srcs: ["bar/Bar.aidl"], unstable: true, } aidl_interface { name: "baz", srcs: ["baz/Baz.aidl"], versions: ["1"], } `, withFiles(map[string][]byte{ "foo/Foo.aidl": nil, "bar/Bar.aidl": nil, "baz/Baz.aidl": nil, "aidl_api/foo/1/foo/Foo.aidl": nil, "aidl_api/foo/1/.hash": nil, "aidl_api/bar/1/bar/Bar.aidl": nil, "aidl_api/bar/1/.hash": nil, "aidl_api/baz/1/baz/Baz.aidl": nil, "aidl_api/baz/1/.hash": nil, })) { rule := ctx.ModuleForTests("foo-V2-java-source", "").Output("foo/Foo.java") android.AssertStringDoesContain(t, "foo-V2(tot) imports bar-V1 for 'bar-V1'", rule.Args["optionalFlags"], "-pout/soong/.intermediates/bar_interface/1/preprocessed.aidl") android.AssertStringDoesContain(t, "foo-V2(tot) imports baz-V1 for 'baz-V1'", rule.Args["optionalFlags"], "-pout/soong/.intermediates/baz_interface/1/preprocessed.aidl") } { rule := ctx.ModuleForTests("foo-V1-java-source", "").Output("foo/Foo.java") android.AssertStringDoesContain(t, "foo-V1 imports bar-V1(latest) for 'bar'", rule.Args["optionalFlags"], "-pout/soong/.intermediates/bar_interface/1/preprocessed.aidl") android.AssertStringDoesContain(t, "foo-V1 imports baz-V1 for 'baz-V1'", rule.Args["optionalFlags"], "-pout/soong/.intermediates/baz_interface/1/preprocessed.aidl") } { rule := ctx.ModuleForTests("unstable-foo-java-source", "").Output("foo/Foo.java") android.AssertStringDoesContain(t, "unstable-foo imports bar-V2(latest) for 'bar'", rule.Args["optionalFlags"], "-pout/soong/.intermediates/bar_interface/2/preprocessed.aidl") android.AssertStringDoesContain(t, "unstable-foo imports baz-V1 for 'baz-V1'", rule.Args["optionalFlags"], "-pout/soong/.intermediates/baz_interface/1/preprocessed.aidl") android.AssertStringDoesContain(t, "unstable-foo imports unstable-bar(ToT) for 'unstable-bar'", rule.Args["optionalFlags"], "-pout/soong/.intermediates/unstable-bar_interface/preprocessed.aidl") } { rule := ctx.ModuleForTests("foo-no-versions-V1-java-source", "").Output("foo/Foo.java") android.AssertStringDoesContain(t, "foo-no-versions-V1(latest) imports bar-V2(latest) for 'bar'", rule.Args["optionalFlags"], "-pout/soong/.intermediates/bar_interface/2/preprocessed.aidl") } } func FindModule(ctx *android.TestContext, name, variant, dir string) android.Module { var module android.Module ctx.VisitAllModules(func(m blueprint.Module) { if ctx.ModuleName(m) == name && ctx.ModuleSubDir(m) == variant && ctx.ModuleDir(m) == dir { module = m.(android.Module) } }) if module == nil { m := ctx.ModuleForTests(name, variant).Module() panic(fmt.Errorf("failed to find module %q variant %q dir %q, but found one in %q", name, variant, dir, ctx.ModuleDir(m))) } return module } func TestDuplicateInterfacesWithTheSameNameInDifferentSoongNamespaces(t *testing.T) { ctx, _ := testAidl(t, ``, withFiles(map[string][]byte{ "common/Android.bp": []byte(` aidl_interface { name: "common", srcs: ["ICommon.aidl"], versions: ["1", "2"], } `), "common/aidl_api/common/1/ICommon.aidl": nil, "common/aidl_api/common/1/.hash": nil, "common/aidl_api/common/2/ICommon.aidl": nil, "common/aidl_api/common/2/.hash": nil, "vendor/a/Android.bp": []byte(` soong_namespace {} `), "vendor/a/foo/Android.bp": []byte(` aidl_interface { name: "foo", owner: "vendor", srcs: ["IFoo.aidl"], imports: ["common-V1"], } `), "vendor/b/Android.bp": []byte(` soong_namespace {} `), "vendor/b/foo/Android.bp": []byte(` aidl_interface { name: "foo", owner: "vendor", srcs: ["IFoo.aidl"], imports: ["common-V2"], } `), })) aFooV1Java := FindModule(ctx, "foo-V1-java", "android_common", "vendor/a/foo").(*java.Library) android.AssertStringListContains(t, "a/foo deps", aFooV1Java.CompilerDeps(), "common-V1-java") bFooV1Java := FindModule(ctx, "foo-V1-java", "android_common", "vendor/b/foo").(*java.Library) android.AssertStringListContains(t, "a/foo deps", bFooV1Java.CompilerDeps(), "common-V2-java") } func TestUnstableChecksForAidlInterfacesInDifferentNamespaces(t *testing.T) { files := withFiles(map[string][]byte{ "vendor/a/Android.bp": []byte(` soong_namespace {} `), "vendor/a/foo/Android.bp": []byte(` aidl_interface { name: "foo", owner: "vendor", srcs: ["IFoo.aidl"], versions: ["1", "2"], } java_library { name: "bar", libs: ["foo-V2-java"], // OK } `), "vendor/a/foo/aidl_api/foo/1/IFoo.aidl": nil, "vendor/a/foo/aidl_api/foo/1/.hash": nil, "vendor/a/foo/aidl_api/foo/2/IFoo.aidl": nil, "vendor/a/foo/aidl_api/foo/2/.hash": nil, "vendor/b/Android.bp": []byte(` soong_namespace {} `), "vendor/b/foo/Android.bp": []byte(` aidl_interface { name: "foo", owner: "vendor", srcs: ["IFoo.aidl"], versions: ["1"], } java_library { name: "bar", libs: ["foo-V1-java"], // OK } `), "vendor/b/foo/aidl_api/foo/1/IFoo.aidl": nil, "vendor/b/foo/aidl_api/foo/1/.hash": nil, }) testAidl(t, ``, files, setReleaseEnv()) testAidl(t, ``, files, setTestFreezeEnv()) testAidl(t, ``, files) } func TestVersionsWithInfoAndVersions(t *testing.T) { conflictingFields := ` aidl_interface { name: "foo", versions: [ "1", ], versions_with_info: [ { version: "1", } ], } ` files := withFiles(map[string][]byte{ "aidl_api/foo/1/foo.1.aidl": nil, "aidl_api/foo/1/.hash": nil, }) expectedError := `Use versions_with_info instead of versions.` testAidlError(t, expectedError, conflictingFields, files) } func TestVersionsWithInfo(t *testing.T) { ctx, _ := testAidl(t, ``, withFiles(map[string][]byte{ "common/Android.bp": []byte(` aidl_interface { name: "common", srcs: ["ICommon.aidl"], versions: ["1", "2"], } `), "common/aidl_api/common/1/ICommon.aidl": nil, "common/aidl_api/common/1/.hash": nil, "common/aidl_api/common/2/ICommon.aidl": nil, "common/aidl_api/common/2/.hash": nil, "foo/Android.bp": []byte(` aidl_interface { name: "foo", srcs: ["IFoo.aidl"], imports: ["common-V3"], versions_with_info: [ {version: "1", imports: ["common-V1"]}, {version: "2", imports: ["common-V2"]}, ] } `), "foo/aidl_api/foo/1/IFoo.aidl": nil, "foo/aidl_api/foo/1/.hash": nil, "foo/aidl_api/foo/2/IFoo.aidl": nil, "foo/aidl_api/foo/2/.hash": nil, })) fooV1Java := FindModule(ctx, "foo-V1-java", "android_common", "foo").(*java.Library) android.AssertStringListContains(t, "a/foo-v1 deps", fooV1Java.CompilerDeps(), "common-V1-java") fooV2Java := FindModule(ctx, "foo-V2-java", "android_common", "foo").(*java.Library) android.AssertStringListContains(t, "a/foo-v2 deps", fooV2Java.CompilerDeps(), "common-V2-java") fooV3Java := FindModule(ctx, "foo-V3-java", "android_common", "foo").(*java.Library) android.AssertStringListContains(t, "a/foo-v3 deps", fooV3Java.CompilerDeps(), "common-V3-java") } func TestVersionsWithInfoImport(t *testing.T) { testAidlError(t, "imports in versions_with_info must specify its version", ``, withFiles(map[string][]byte{ "common/Android.bp": []byte(` aidl_interface { name: "common", srcs: ["ICommon.aidl"], versions: ["1", "2"], } `), "common/aidl_api/common/1/ICommon.aidl": nil, "common/aidl_api/common/1/.hash": nil, "common/aidl_api/common/2/ICommon.aidl": nil, "common/aidl_api/common/2/.hash": nil, "foo/Android.bp": []byte(` aidl_interface { name: "foo", srcs: ["IFoo.aidl"], imports: ["common"], versions_with_info: [ {version: "1", imports: ["common"]}, {version: "2", imports: ["common-V2"]}, ] } `), "foo/aidl_api/foo/1/IFoo.aidl": nil, "foo/aidl_api/foo/1/.hash": nil, "foo/aidl_api/foo/2/IFoo.aidl": nil, "foo/aidl_api/foo/2/.hash": nil, })) } func TestFreezeApiDeps(t *testing.T) { for _, transitive := range []bool{true, false} { for _, testcase := range []struct { string bool }{{"common-V3", true}, {"common-V2", false}} { im := testcase.string customizers := []android.FixturePreparer{ withFiles(map[string][]byte{ "common/Android.bp": []byte(` aidl_interface { name: "common", frozen: false, srcs: ["ICommon.aidl"], versions: ["1", "2"], } `), "common/aidl_api/common/1/ICommon.aidl": nil, "common/aidl_api/common/1/.hash": nil, "common/aidl_api/common/2/ICommon.aidl": nil, "common/aidl_api/common/2/.hash": nil, "foo/Android.bp": []byte(fmt.Sprintf(` aidl_interface { name: "foo", srcs: ["IFoo.aidl"], imports: ["%s"], frozen: false, versions_with_info: [ {version: "1", imports: ["common-V1"]}, {version: "2", imports: ["common-V2"]}, ] } `, im)), "foo/aidl_api/foo/1/IFoo.aidl": nil, "foo/aidl_api/foo/1/.hash": nil, "foo/aidl_api/foo/2/IFoo.aidl": nil, "foo/aidl_api/foo/2/.hash": nil, }), } if transitive { customizers = append(customizers, setTransitiveFreezeEnv()) } ctx, _ := testAidl(t, ``, customizers...) shouldHaveDep := transitive && testcase.bool fooFreezeApiRule := ctx.ModuleForTests("foo-api", "").Output("update_or_freeze_api_3.timestamp") commonFreezeApiOutput := ctx.ModuleForTests("common-api", "").Output("update_or_freeze_api_3.timestamp").Output.String() testMethod := android.AssertStringListDoesNotContain if shouldHaveDep { testMethod = android.AssertStringListContains } testMethod(t, "Only if AIDL_TRANSITIVE_FREEZE is set and an aidl_interface depends on an another aidl_interface's ToT version, an imported aidl_interface should be frozen as well.", fooFreezeApiRule.Implicits.Strings(), commonFreezeApiOutput) } } } func TestAidlNoUnfrozen(t *testing.T) { customizer := withFiles(map[string][]byte{ "foo/Android.bp": []byte(` aidl_interface { name: "foo-iface", srcs: ["a/Foo.aidl"], versions: ["1", "2"], } `), "foo/a/Foo.aidl": nil, "foo/aidl_api/foo-iface/current/a/Foo.aidl": nil, "foo/aidl_api/foo-iface/1/a/Foo.aidl": nil, "foo/aidl_api/foo-iface/1/.hash": nil, "foo/aidl_api/foo-iface/2/a/Foo.aidl": nil, "foo/aidl_api/foo-iface/2/.hash": nil, }) // setReleaseEnv() to set RELEASE_AIDL_USE_UNFROZEN to false ctx, _ := testAidl(t, ``, setReleaseEnv(), customizer) // compile (v1) { rule := ctx.ModuleForTests("foo-iface-V1-cpp-source", "").Output("a/Foo.cpp") android.AssertStringDoesNotContain(t, "Frozen versions should not have the -previous_api_dir set", rule.Args["optionalFlags"], "-previous") } // compile (v2) { rule := ctx.ModuleForTests("foo-iface-V2-cpp-source", "").Output("a/Foo.cpp") android.AssertStringDoesNotContain(t, "Frozen versions should not have the -previous_api_dir set", rule.Args["optionalFlags"], "-previous") } // compile ToT(v3) { rule := ctx.ModuleForTests("foo-iface-V3-cpp-source", "").Output("a/Foo.cpp") android.AssertStringDoesContain(t, "An unfrozen interface with previously frozen version must have --previous_api_dir when RELEASE_AIDL_USE_UNFROZEN is false (setReleaseEnv())", rule.Args["optionalFlags"], "-previous_api_dir") android.AssertStringDoesContain(t, "An unfrozen interface with previously frozen version must have --previous_hash when RELEASE_AIDL_USE_UNFROZEN is false (setReleaseEnv())", rule.Args["optionalFlags"], "-previous_hash") android.AssertStringDoesContain(t, "--previous_hash must use the last frozen version's hash file", rule.Args["optionalFlags"], "foo-iface/2/.hash") } } func TestAidlUsingUnfrozen(t *testing.T) { customizer := withFiles(map[string][]byte{ "foo/Android.bp": []byte(` aidl_interface { name: "foo-iface", srcs: ["a/Foo.aidl"], versions: ["1", "2"], } `), "foo/a/Foo.aidl": nil, "foo/aidl_api/foo-iface/current/a/Foo.aidl": nil, "foo/aidl_api/foo-iface/1/a/Foo.aidl": nil, "foo/aidl_api/foo-iface/1/.hash": nil, "foo/aidl_api/foo-iface/2/a/Foo.aidl": nil, "foo/aidl_api/foo-iface/2/.hash": nil, }) ctx, _ := testAidl(t, ``, customizer) // compile (v2) { rule := ctx.ModuleForTests("foo-iface-V2-cpp-source", "").Output("a/Foo.cpp") android.AssertStringDoesNotContain(t, "Frozen versions should not have the -previous_api_dir set", rule.Args["optionalFlags"], "-previous") } // compile ToT(v3) { rule := ctx.ModuleForTests("foo-iface-V3-cpp-source", "").Output("a/Foo.cpp") android.AssertStringDoesNotContain(t, "Unfrozen versions should not have the -previous options when RELEASE_AIDL_USE_UNFROZEN is true (default)", rule.Args["optionalFlags"], "-previous") } } func TestAidlUseUnfrozenOverrideFalse(t *testing.T) { customizer := withFiles(map[string][]byte{ "foo/Android.bp": []byte(` aidl_interface { name: "foo-iface", srcs: ["a/Foo.aidl"], versions: ["1"], } `), "foo/a/Foo.aidl": nil, "foo/aidl_api/foo-iface/current/a/Foo.aidl": nil, "foo/aidl_api/foo-iface/1/a/Foo.aidl": nil, "foo/aidl_api/foo-iface/1/.hash": nil, }) ctx, _ := testAidl(t, ``, setUseUnfrozenOverrideEnvFalse(), customizer) rule := ctx.ModuleForTests("foo-iface-V2-cpp-source", "").Output("a/Foo.cpp") android.AssertStringDoesContain(t, "Unfrozen interfaces should have -previous_api_dir set when overriding the RELEASE_AIDL_USE_UNFROZEN flag", rule.Args["optionalFlags"], "-previous") } func TestAidlUseUnfrozenOverrideTrue(t *testing.T) { customizer := withFiles(map[string][]byte{ "foo/Android.bp": []byte(` aidl_interface { name: "foo-iface", srcs: ["a/Foo.aidl"], versions: ["1"], } `), "foo/a/Foo.aidl": nil, "foo/aidl_api/foo-iface/current/a/Foo.aidl": nil, "foo/aidl_api/foo-iface/1/a/Foo.aidl": nil, "foo/aidl_api/foo-iface/1/.hash": nil, }) ctx, _ := testAidl(t, ``, setUseUnfrozenOverrideEnvTrue(), customizer) rule := ctx.ModuleForTests("foo-iface-V2-cpp-source", "").Output("a/Foo.cpp") android.AssertStringDoesNotContain(t, "Unfrozen interfaces should not have -previous_api_dir set when overriding the RELEASE_AIDL_USE_UNFROZEN flag", rule.Args["optionalFlags"], "-previous") } ./PaxHeaders.X/build_aidl_to_jni.py0100644 0000000 0000000 00000000034 15172120304 016300 xustar000000000 0000000 28 mtime=1776853188.3280000 build/aidl_to_jni.py0100755 0000000 0000000 00000005443 15172120304 013535 0ustar000000000 0000000 #!/usr/bin/env python3 # # Copyright (C) 2019 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. # import sys DEFAULT_TYPES_TO_JNI = { "boolean": "Z", "byte": "B", "char": "C", "short": "S", "int": "I", "long": "J", "float": "F", "double": "D", "void": "V", "String": "Ljava/lang/String;" } class AIDLMalformedSignatureException(Exception): """Line containing AIDL signature is invalid""" def convert_type(aidl_type): if aidl_type.endswith("[]"): return "[" + convert_type(aidl_type[:-2]) if aidl_type in DEFAULT_TYPES_TO_JNI: return DEFAULT_TYPES_TO_JNI[aidl_type] elif aidl_type.startswith("List<") | aidl_type.startswith("java.util.List<"): return "Ljava/util/List;" else: return "L" + aidl_type.replace(".", "/") + ";" def convert_method(aidl_signature): aidl_signature = aidl_signature.split("|") if len(aidl_signature) != 4: raise AIDLMalformedSignatureException() class_name, method_name, args, return_type = aidl_signature # Filter out empty arguments since there will be trailing commas args = [x for x in args.split(",") if x] jni_signature = convert_type(class_name) jni_signature += "->" jni_signature += method_name jni_signature += "(" params = [convert_type(x) for x in args] jni_signature += "".join(params) jni_signature += ")" jni_signature += convert_type(return_type) return jni_signature def main(argv): if len(argv) != 3: print("Usage: %s " % argv[0]) return -1 aidl_mappings, jni_signature_mappings = argv[1:] line_index = 0 skip_line = False with open(aidl_mappings) as input_file: with open(jni_signature_mappings, "w") as output_file: for line in input_file: if skip_line: skip_line = False elif line_index % 2 == 1: output_file.write(line) else: try: stripped_line = line.strip() output_file.write(convert_method(line.strip())) output_file.write("\n") except AIDLMalformedSignatureException: print("Malformed signature %s . Skipping..." % stripped_line) # The next line contains the location, need to skip it skip_line = True line_index += 1 if __name__ == "__main__": sys.exit(main(sys.argv)) ./PaxHeaders.X/build_aidl_utils.go0100644 0000000 0000000 00000000034 15172120304 016133 xustar000000000 0000000 28 mtime=1776853188.3290000 build/aidl_utils.go0100644 0000000 0000000 00000002663 15172120304 013366 0ustar000000000 0000000 // Copyright (C) 2021 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. package aidl import ( "strings" ) // wrap(p, a, s) = [p + v + s for v in a] func wrap(prefix string, strs []string, suffix string) []string { ret := make([]string, len(strs)) for i, v := range strs { ret[i] = prefix + v + suffix } return ret } // wrapFunc(p, a, s, f) = [p + f(v) + s for v in a] func wrapFunc(prefix string, strs []string, suffix string, f func(string) string) []string { ret := make([]string, len(strs)) for i, v := range strs { ret[i] = prefix + f(v) + suffix } return ret } // concat(a...) = sum((i for i in a), []) func concat(sstrs ...[]string) []string { var ret []string for _, v := range sstrs { ret = append(ret, v...) } return ret } func fixRustName(name string) string { return strings.Map(func(r rune) rune { switch r { case '-', '.': return '_' default: return r } }, name) } ./PaxHeaders.X/build_client-using-test-piece-3.cpp0100644 0000000 0000000 00000000034 15172120304 020760 xustar000000000 0000000 28 mtime=1776853188.3290000 build/client-using-test-piece-3.cpp0100644 0000000 0000000 00000000232 15172120304 016201 0ustar000000000 0000000 #include // Enum type should be available here since IBaz.h includes Enum.h void acceptEnum(other_package::Enum n) { (void)n; } ./PaxHeaders.X/build_go.mod0100644 0000000 0000000 00000000034 15172120304 014561 xustar000000000 0000000 28 mtime=1776853188.3290000 build/go.mod0100644 0000000 0000000 00000002046 15172120304 012007 0ustar000000000 0000000 module android/soong/aidl go 1.21 require ( android/soong v0.0.0 github.com/google/blueprint v0.0.0 ) require ( go.starlark.net v0.0.0 // indirect google.golang.org/protobuf v1.25.0 // indirect prebuilts/bazel/common/proto/analysis_v2 v0.0.0 // indirect prebuilts/bazel/common/proto/build v0.0.0 // indirect ) replace android/soong v0.0.0 => ../../../../build/soong replace google.golang.org/protobuf v0.0.0 => ../../../../external/golang-protobuf replace github.com/google/blueprint v0.0.0 => ../../../../build/blueprint // Indirect deps from golang-protobuf exclude github.com/golang/protobuf v1.5.0 replace github.com/google/go-cmp v0.5.5 => ../../../../external/go-cmp // Indirect dep from go-cmp exclude golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 replace prebuilts/bazel/common/proto/analysis_v2 v0.0.0 => ../../../../prebuilts/bazel/common/proto/analysis_v2 replace prebuilts/bazel/common/proto/build v0.0.0 => ../../../../prebuilts/bazel/common/proto/build replace go.starlark.net v0.0.0 => ../../../../external/starlark-go ./PaxHeaders.X/build_hash_gen.sh0100644 0000000 0000000 00000000034 15172120304 015563 xustar000000000 0000000 28 mtime=1776853188.3290000 build/hash_gen.sh0100755 0000000 0000000 00000002033 15172120304 013010 0ustar000000000 0000000 #!/usr/bin/env bash # Copyright (C) 2021 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. set -e if [ $# != 3 ]; then echo "Usage: hash_gen.sh " exit 1 fi # This adds a new hash to the file if one already exists. # We can have multiple hashes in a hash file so we can still identify previous # iterations of this interfaces that were released. (cd $1 && find ./ -name "*.aidl" -print0 | LC_ALL=C sort -z | xargs -0 sha1sum && echo $2) | sha1sum | cut -d " " -f 1 >> $3 ./PaxHeaders.X/build_message_check_compatibility.txt0100644 0000000 0000000 00000000034 15172120304 021726 xustar000000000 0000000 28 mtime=1776853188.3290000 build/message_check_compatibility.txt0100644 0000000 0000000 00000001044 15172120304 017151 0ustar000000000 0000000 ############################################################################### # ERROR: Backward incompatible change detected on AIDL API # ############################################################################### Above AIDL file(s) has changed in a backward-incompatible way, e.g. removing a method from an interface or a field from a parcelable. If a device is shipped with this change by ignoring this message, it has a high risk of breaking later when a module using the interface is updated, e.g., Maineline modules. ./PaxHeaders.X/build_message_check_equality.txt0100644 0000000 0000000 00000000034 15172120304 020712 xustar000000000 0000000 28 mtime=1776853188.3290000 build/message_check_equality.txt0100644 0000000 0000000 00000000746 15172120304 016145 0ustar000000000 0000000 ############################################################################### # ERROR: AIDL API change detected # ############################################################################### Above AIDL file(s) has changed. Run `m %s-update-api` to reflect the changes to the current version so that it is reviewed by android-aidl-api-council@google.com And then you need to change dependency on %s-V(n)-* to %s-V(n+1)-* to use new APIs. ./PaxHeaders.X/build_message_check_equality_frozen.txt0100644 0000000 0000000 00000000034 15172120304 022275 xustar000000000 0000000 28 mtime=1776853188.3290000 build/message_check_equality_frozen.txt0100644 0000000 0000000 00000001114 15172120304 017516 0ustar000000000 0000000 ############################################################################### # ERROR: AIDL API change detected on frozen interface # ############################################################################### Above AIDL file(s) has changed. The AIDL API is marked `frozen: true` so it cannot be modified. Change this to `frozen: false`, then run `m %s-update-api` to reflect the changes to the current version so that it is reviewed by android-aidl-api-council@google.com. And then you need to change dependency on %s-V(n)-* to %s-V(n+1)-* to use new APIs. ./PaxHeaders.X/build_message_check_integrity.txt0100644 0000000 0000000 00000000034 15172120304 021073 xustar000000000 0000000 28 mtime=1776853188.3290000 build/message_check_integrity.txt0100644 0000000 0000000 00000001041 15172120304 016313 0ustar000000000 0000000 ############################################################################### # ERROR: Modification detected of stable AIDL API file # ############################################################################### Above AIDL file(s) has changed, resulting in a different hash. Hash values may be checked at runtime to verify interface stability. If a device is shipped with this change by ignoring this message, it has a high risk of breaking later when a module using the interface is updated, e.g., Mainline modules. ./PaxHeaders.X/build_properties.go0100644 0000000 0000000 00000000034 15172120304 016176 xustar000000000 0000000 28 mtime=1776853188.3290000 build/properties.go0100644 0000000 0000000 00000005620 15172120304 013425 0ustar000000000 0000000 // Copyright (C) 2017 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. package aidl type nameProperties struct { Name *string } type hostProperties struct { Cflags []string } type darwinProperties struct { Enabled *bool } type imageProperties struct { Shared_libs []string Header_libs []string Exclude_shared_libs []string Cflags []string } type ccTargetProperties struct { Host hostProperties Darwin darwinProperties Platform imageProperties Vendor imageProperties Product imageProperties } type rustTargetProperties struct { Darwin darwinProperties } type ccProperties struct { Name *string Owner *string Defaults []string Double_loadable *bool Vendor_available *bool Odm_available *bool Product_available *bool Recovery_available *bool Host_supported *bool Installable *bool Generated_sources []string Generated_headers []string Shared_libs []string Static_libs []string Export_shared_lib_headers []string Export_generated_headers []string Header_libs []string Sdk_version *string Stl *string Cpp_std *string Cflags []string Ldflags []string Stem *string Apex_available []string Min_sdk_version *string Target ccTargetProperties Tidy *bool Tidy_flags []string Tidy_checks_as_errors []string Include_build_directory *bool } type javaProperties struct { Name *string Owner *string Defaults []string Installable *bool Sdk_version *string Srcs []string Static_libs []string Apex_available []string Min_sdk_version *string } type rustProperties struct { Name *string Crate_name string Owner *string Defaults []string Host_supported *bool Vendor_available *bool Product_available *bool Srcs []string Rustlibs []string Stem *string Target rustTargetProperties Apex_available []string Min_sdk_version *string } type phonyProperties struct { Name *string Required []string } ./PaxHeaders.X/build_test_package_0100644 0000000 0000000 00000000034 15172120304 016167 xustar000000000 0000000 28 mtime=1776853188.3290000 build/test_package/0040755 0000000 0000000 00000000000 15172120304 013334 5ustar000000000 0000000 ./PaxHeaders.X/build_test_package_IBaz.aidl0100644 0000000 0000000 00000000034 15172120304 017645 xustar000000000 0000000 28 mtime=1776853188.3290000 build/test_package/IBaz.aidl0100644 0000000 0000000 00000002175 15172120304 015016 0ustar000000000 0000000 /* * Copyright (C) 2018 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package test_package; import some_package.IBar; @SuppressWarnings(value={"mixed-oneway", "inout-parameter", "out-array"}) interface IBaz { oneway void CanYouDealWithThisBar(in IBar bar); void MethodAddedInVersion2(); ParcelFileDescriptor readPFD(); void writePFD(in ParcelFileDescriptor fd); void readWritePFD(inout ParcelFileDescriptor fd); ParcelFileDescriptor[] readPFDArray(); void writePFDArray(in ParcelFileDescriptor[] fds); void readWritePFDArray(inout ParcelFileDescriptor[] fds); } ./PaxHeaders.X/build_test_unfrozen_iface.cpp0100644 0000000 0000000 00000000034 15172120304 020213 xustar000000000 0000000 28 mtime=1776853188.3290000 build/test_unfrozen_iface.cpp0100644 0000000 0000000 00000001316 15172120304 015440 0ustar000000000 0000000 /* * Copyright (C) 2023 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 static_assert(vendor::IFoo::VERSION == 2, "version must always be 2"); ./PaxHeaders.X/build_tests_1_0100644 0000000 0000000 00000000034 15172120304 015117 xustar000000000 0000000 28 mtime=1776853188.3290000 build/tests_1/0040755 0000000 0000000 00000000000 15172120304 012264 5ustar000000000 0000000 ./PaxHeaders.X/build_tests_1_INoPackage.aidl0100644 0000000 0000000 00000000034 15172120304 017711 xustar000000000 0000000 28 mtime=1776853188.3290000 build/tests_1/INoPackage.aidl0100644 0000000 0000000 00000001316 15172120304 015056 0ustar000000000 0000000 /* * Copyright (C) 2018 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ import some_package.IBar; interface INoPackage { void CanYouDealWithThisBar(in IBar bar); } ./PaxHeaders.X/build_tests_1_other_package_0100644 0000000 0000000 00000000034 15172120304 017773 xustar000000000 0000000 28 mtime=1776853188.3290000 build/tests_1/other_package/0040755 0000000 0000000 00000000000 15172120304 015060 5ustar000000000 0000000 ./PaxHeaders.X/build_tests_1_other_package_Enum.aidl0100644 0000000 0000000 00000000034 15172120304 021530 xustar000000000 0000000 28 mtime=1776853188.3300000 build/tests_1/other_package/Enum.aidl0100644 0000000 0000000 00000001235 15172120304 016615 0ustar000000000 0000000 /* * Copyright (C) 2022 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. */ package other_package; enum Enum { ZERO, ONE } ./PaxHeaders.X/build_tests_1_other_package_IBaz.aidl0100644 0000000 0000000 00000000034 15172120304 021451 xustar000000000 0000000 28 mtime=1776853188.3300000 build/tests_1/other_package/IBaz.aidl0100644 0000000 0000000 00000001433 15172120304 016536 0ustar000000000 0000000 /* * Copyright (C) 2018 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package other_package; import other_package.Enum; import some_package.IBar; interface IBaz { const int ZERO = Enum.ZERO; void CanYouDealWithThisBar(in IBar bar); } ./PaxHeaders.X/build_tests_1_some_package_0100644 0000000 0000000 00000000034 15172120304 017615 xustar000000000 0000000 28 mtime=1776853188.3300000 build/tests_1/some_package/0040755 0000000 0000000 00000000000 15172120304 014702 5ustar000000000 0000000 ./PaxHeaders.X/build_tests_1_some_package_IBar.aidl0100644 0000000 0000000 00000000034 15172120304 021263 xustar000000000 0000000 28 mtime=1776853188.3300000 build/tests_1/some_package/IBar.aidl0100644 0000000 0000000 00000001346 15172120304 016353 0ustar000000000 0000000 /* * Copyright (C) 2018 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package some_package; import some_package.IFoo; oneway interface IBar { void CanYouDealWithThisFoo(in IFoo foo); } ./PaxHeaders.X/build_tests_1_some_package_IFoo.aidl0100644 0000000 0000000 00000000034 15172120304 021302 xustar000000000 0000000 28 mtime=1776853188.3300000 build/tests_1/some_package/IFoo.aidl0100644 0000000 0000000 00000001574 15172120304 016375 0ustar000000000 0000000 /* * Copyright (C) 2018 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package some_package; import some_package.Thing; import some_package.sub_package.SubThing; @SuppressWarnings(value={"inout-parameter"}) interface IFoo { void CanYouDealWithThisThing(inout Thing parcel); void CanYouDealWithThisSubThing(inout SubThing parcel); } ./PaxHeaders.X/build_tests_1_some_package_Thing.aidl0100644 0000000 0000000 00000000034 15172120304 021517 xustar000000000 0000000 28 mtime=1776853188.3300000 build/tests_1/some_package/Thing.aidl0100644 0000000 0000000 00000001257 15172120304 016610 0ustar000000000 0000000 /* * Copyright (C) 2018 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package some_package; parcelable Thing { int a; int b; } ./PaxHeaders.X/build_tests_1_some_package_sub_package_0100644 0000000 0000000 00000000034 15172120304 022141 xustar000000000 0000000 28 mtime=1776853188.3300000 build/tests_1/some_package/sub_package/0040755 0000000 0000000 00000000000 15172120304 017146 5ustar000000000 0000000 ./PaxHeaders.X/build_tests_1_some_package_sub_package_IFoo.aidl0100644 0000000 0000000 00000000034 15172120304 023626 xustar000000000 0000000 28 mtime=1776853188.3300000 build/tests_1/some_package/sub_package/IFoo.aidl0100644 0000000 0000000 00000001610 15172120304 020630 0ustar000000000 0000000 /* * Copyright (C) 2018 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package some_package.sub_package; import some_package.Thing; import some_package.sub_package.SubThing; @SuppressWarnings(value={"inout-parameter"}) interface IFoo { void CanYouDealWithThisThing(inout Thing parcel); void CanYouDealWithThisSubThing(inout SubThing parcel); } ./PaxHeaders.X/build_tests_1_some_package_sub_package_SubThing.aidl0100644 0000000 0000000 00000000034 15172120304 024515 xustar000000000 0000000 28 mtime=1776853188.3300000 build/tests_1/some_package/sub_package/SubThing.aidl0100644 0000000 0000000 00000001276 15172120304 021527 0ustar000000000 0000000 /* * Copyright (C) 2018 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package some_package.sub_package; parcelable SubThing { int a; int b; } ./PaxHeaders.X/build_tests_2_0100644 0000000 0000000 00000000034 15172120304 015120 xustar000000000 0000000 28 mtime=1776853188.3300000 build/tests_2/0040755 0000000 0000000 00000000000 15172120304 012265 5ustar000000000 0000000 ./PaxHeaders.X/build_tests_2_another_package_0100644 0000000 0000000 00000000034 15172120304 020313 xustar000000000 0000000 28 mtime=1776853188.3300000 build/tests_2/another_package/0040755 0000000 0000000 00000000000 15172120304 015400 5ustar000000000 0000000 ./PaxHeaders.X/build_tests_2_another_package_IFaz.aidl0100644 0000000 0000000 00000000034 15172120304 021775 xustar000000000 0000000 28 mtime=1776853188.3300000 build/tests_2/another_package/IFaz.aidl0100644 0000000 0000000 00000001342 15172120304 017061 0ustar000000000 0000000 /* * Copyright (C) 2018 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package another_package; import some_package.IFoo; interface IFaz { void CanYouDealWithThisFoo(in IFoo foo); } ./PaxHeaders.X/build_tests_3_0100644 0000000 0000000 00000000034 15172120304 015121 xustar000000000 0000000 28 mtime=1776853188.3300000 build/tests_3/0040755 0000000 0000000 00000000000 15172120304 012266 5ustar000000000 0000000 ./PaxHeaders.X/build_tests_3_EmptyParcelable.aidl0100644 0000000 0000000 00000000034 15172120304 021023 xustar000000000 0000000 28 mtime=1776853188.3300000 build/tests_3/EmptyParcelable.aidl0100644 0000000 0000000 00000000036 15172120304 016166 0ustar000000000 0000000 parcelable EmptyParcelable {} ./PaxHeaders.X/build_tests_3_IEmptyInterface.aidl0100644 0000000 0000000 00000000034 15172120304 021002 xustar000000000 0000000 28 mtime=1776853188.3300000 build/tests_3/IEmptyInterface.aidl0100644 0000000 0000000 00000000035 15172120304 016144 0ustar000000000 0000000 interface IEmptyInterface {} ./PaxHeaders.X/build_tests_6_0100644 0000000 0000000 00000000034 15172120304 015124 xustar000000000 0000000 28 mtime=1776853188.3300000 build/tests_6/0040755 0000000 0000000 00000000000 15172120304 012271 5ustar000000000 0000000 ./PaxHeaders.X/build_tests_6_test6_0100644 0000000 0000000 00000000034 15172120304 016251 xustar000000000 0000000 28 mtime=1776853188.3300000 build/tests_6/test6/0040755 0000000 0000000 00000000000 15172120304 013336 5ustar000000000 0000000 ./PaxHeaders.X/build_tests_6_test6_Bar.aidl0100644 0000000 0000000 00000000034 15172120304 017606 xustar000000000 0000000 28 mtime=1776853188.3300000 build/tests_6/test6/Bar.aidl0100644 0000000 0000000 00000000106 15172120304 014667 0ustar000000000 0000000 package test6; import test6.Foo; parcelable Bar { Foo[] foos; } ./PaxHeaders.X/build_tests_6_test6_Foo.aidl0100644 0000000 0000000 00000000034 15172120304 017625 xustar000000000 0000000 28 mtime=1776853188.3300000 build/tests_6/test6/Foo.aidl0100644 0000000 0000000 00000000155 15172120304 014712 0ustar000000000 0000000 package test6; parcelable Foo { ParcelableHolder ph; ParcelFileDescriptor[] pfds; // not moveable } ./PaxHeaders.X/build_tests_transitive_parcel_0100644 0000000 0000000 00000000034 15172120304 020475 xustar000000000 0000000 28 mtime=1776853188.3300000 build/tests_transitive_parcel/0040755 0000000 0000000 00000000000 15172120304 015642 5ustar000000000 0000000 ./PaxHeaders.X/build_tests_transitive_parcel_a_0100644 0000000 0000000 00000000034 15172120304 020775 xustar000000000 0000000 28 mtime=1776853188.3300000 build/tests_transitive_parcel/a/0040755 0000000 0000000 00000000000 15172120304 016062 5ustar000000000 0000000 ./PaxHeaders.X/build_tests_transitive_parcel_a_IA.aidl0100644 0000000 0000000 00000000034 15172120304 022117 xustar000000000 0000000 28 mtime=1776853188.3300000 build/tests_transitive_parcel/a/IA.aidl0100644 0000000 0000000 00000001325 15172120304 017204 0ustar000000000 0000000 /* * 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. */ package tests_transitive_parcel.a; import tests_transitive_parcel.b.B; interface IA { B getB(); } ./PaxHeaders.X/build_tests_transitive_parcel_b_0100644 0000000 0000000 00000000034 15172120304 020776 xustar000000000 0000000 28 mtime=1776853188.3300000 build/tests_transitive_parcel/b/0040755 0000000 0000000 00000000000 15172120304 016063 5ustar000000000 0000000 ./PaxHeaders.X/build_tests_transitive_parcel_b_B.aidl0100644 0000000 0000000 00000000034 15172120304 022010 xustar000000000 0000000 28 mtime=1776853188.3300000 build/tests_transitive_parcel/b/B.aidl0100644 0000000 0000000 00000001333 15172120304 017074 0ustar000000000 0000000 /* * 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. */ package tests_transitive_parcel.b; import tests_transitive_parcel.c.C; parcelable B { int i; C c; } ./PaxHeaders.X/build_tests_transitive_parcel_c_0100644 0000000 0000000 00000000034 15172120304 020777 xustar000000000 0000000 28 mtime=1776853188.3300000 build/tests_transitive_parcel/c/0040755 0000000 0000000 00000000000 15172120304 016064 5ustar000000000 0000000 ./PaxHeaders.X/build_tests_transitive_parcel_c_C.aidl0100644 0000000 0000000 00000000034 15172120304 022012 xustar000000000 0000000 28 mtime=1776853188.3300000 build/tests_transitive_parcel/c/C.aidl0100644 0000000 0000000 00000001255 15172120304 017101 0ustar000000000 0000000 /* * 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. */ package tests_transitive_parcel.c; parcelable C { int i; } ./PaxHeaders.X/build_tests_unfrozen_vendor_0100644 0000000 0000000 00000000034 15172120304 020202 xustar000000000 0000000 28 mtime=1776853188.3300000 build/tests_unfrozen_vendor/0040755 0000000 0000000 00000000000 15172120304 015347 5ustar000000000 0000000 ./PaxHeaders.X/build_tests_unfrozen_vendor_vendor_0100644 0000000 0000000 00000000034 15172120304 021557 xustar000000000 0000000 28 mtime=1776853188.3300000 build/tests_unfrozen_vendor/vendor/0040755 0000000 0000000 00000000000 15172120304 016644 5ustar000000000 0000000 ./PaxHeaders.X/build_tests_unfrozen_vendor_vendor_IFoo.aidl0100644 0000000 0000000 00000000034 15172120304 023244 xustar000000000 0000000 28 mtime=1776853188.3300000 build/tests_unfrozen_vendor/vendor/IFoo.aidl0100644 0000000 0000000 00000000137 15172120304 020331 0ustar000000000 0000000 package vendor; interface IFoo { void foo(); // V1 void bar(); // V2 ** UNFROZEN ** } ./PaxHeaders.X/build_tests_vintf_0100644 0000000 0000000 00000000034 15172120304 016105 xustar000000000 0000000 28 mtime=1776853188.3300000 build/tests_vintf/0040755 0000000 0000000 00000000000 15172120304 013252 5ustar000000000 0000000 ./PaxHeaders.X/build_tests_vintf_vintf_0100644 0000000 0000000 00000000034 15172120304 017313 xustar000000000 0000000 28 mtime=1776853188.3310000 build/tests_vintf/vintf/0040755 0000000 0000000 00000000000 15172120304 014400 5ustar000000000 0000000 ./PaxHeaders.X/build_tests_vintf_vintf_IFoo.aidl0100644 0000000 0000000 00000000034 15172120304 021000 xustar000000000 0000000 28 mtime=1776853188.3310000 build/tests_vintf/vintf/IFoo.aidl0100644 0000000 0000000 00000001623 15172120304 016066 0ustar000000000 0000000 /* * Copyright (C) 2022 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. */ package vintf; @VintfStability interface IFoo { parcelable Foo { String a; } union A { String a; int b; } enum E { A, B, C } Foo[] abar(in Foo[] f); ParcelFileDescriptor afd(in ParcelFileDescriptor fd); E ae(in E e); A aa(in A a); } ./PaxHeaders.X/check_valid.cpp0100644 0000000 0000000 00000000034 15172120304 015234 xustar000000000 0000000 28 mtime=1776853188.3310000 check_valid.cpp0100644 0000000 0000000 00000013652 15172120304 012547 0ustar000000000 0000000 /* * Copyright (C) 2021, 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 "check_valid.h" #include "aidl.h" #include namespace android { namespace aidl { using TypePredicate = std::function; using DefinedTypePredicate = std::function; namespace { bool IsListOf(const AidlTypeSpecifier& type, TypePredicate pred) { return type.GetName() == "List" && type.IsGeneric() && type.GetTypeParameters().size() == 1 && pred(*type.GetTypeParameters().at(0)); } bool IsArrayOf(const AidlTypeSpecifier& type, TypePredicate pred) { return type.IsArray() && pred(type); } bool IsInterface(const AidlTypeSpecifier& type) { return type.GetDefinedType() && type.GetDefinedType()->AsInterface(); } } // namespace struct CheckTypeVisitor : AidlVisitor { bool success = true; std::vector checkers; std::vector defined_checkers; void Visit(const AidlTypeSpecifier& type) override { for (auto& checker : checkers) { if (!checker(type)) { success = false; } } } void Visit(const AidlInterface& t) override { CheckDefinedType(t); } void Visit(const AidlEnumDeclaration& t) override { CheckDefinedType(t); } void Visit(const AidlStructuredParcelable& t) override { CheckDefinedType(t); } void Visit(const AidlUnionDecl& t) override { CheckDefinedType(t); } void Visit(const AidlParcelable& t) override { CheckDefinedType(t); } void Check(TypePredicate checker) { checkers.push_back(std::move(checker)); } void Check(DefinedTypePredicate checker) { defined_checkers.push_back(std::move(checker)); } private: void CheckDefinedType(const AidlDefinedType& type) { for (auto& checker : defined_checkers) { if (!checker(type)) { success = false; } } } }; bool CheckValid(const AidlDocument& doc, const Options& options) { const auto lang = options.TargetLanguage(); const auto min_sdk_version = options.GetMinSdkVersion(); CheckTypeVisitor v; v.Check([&](const AidlTypeSpecifier& type) { const auto valid_version = MinSdkVersionFromString("Tiramisu").value(); if ((IsListOf(type, IsInterface) || IsArrayOf(type, IsInterface)) && lang == Options::Language::JAVA && min_sdk_version < valid_version) { const auto kind = IsListOf(type, IsInterface) ? "List" : "Array"; AIDL_ERROR(type) << kind << " of interfaces is available since SDK = " << valid_version << " in Java. Current min_sdk_version is " << min_sdk_version << "."; return false; } return true; }); v.Check([&](const AidlTypeSpecifier& type) { const auto valid_version = MinSdkVersionFromString("S").value(); if (type.GetName() == "ParcelableHolder" && min_sdk_version < valid_version) { AIDL_ERROR(type) << " ParcelableHolder is available since SDK = " << valid_version << ". Current min_sdk_version is " << min_sdk_version << "."; return false; } return true; }); // Check all nested types for potential #include cycles that would contain // them. The algorithm performs a depth-first search on a graph with the // following properties: // // * Graph nodes are top-level (non-nested) types, under the assumption that // there is a 1:1 mapping between top-level types and included headers. This // implies that a cycle between these types will be equivalent to a cycle // between headers. // // * Each edge U -> V represents a "declare V before U" relationship between // types. This means that V.h needs to be included by U.h, or the V type // needs to be forward-declared before U. For any type U, its neighbors // are all nodes V such that U or its nested types have a reference to V // or any type nested in it. // // * The algorithm tries to find a cycle containing start_type. Such a // cycle exists if the following hold true: // * There exists a path from start_type to another top-level type T // (different from start_type) // * There is a back edge from T to start_type which closes the cycle v.Check([&](const AidlDefinedType& start_type) { if (start_type.GetParentType() == nullptr) { return true; } std::set visited; std::function dfs = [&](const AidlDefinedType* type) { if (!visited.insert(type).second) { // Already visited return false; } for (const auto& t : Collect(*type)) { auto defined_type = t->GetDefinedType(); if (!defined_type) { // Skip primitive/builtin types continue; } auto top_type = defined_type->GetRootType(); if (top_type == type) { // Skip type references within the same top-level type continue; } if (defined_type == &start_type) { // Found a cycle back to the starting nested type return true; } if (dfs(top_type)) { // Found a cycle while visiting the top type for the next node return true; } } return false; }; bool has_cycle = dfs(start_type.GetRootType()); if (has_cycle) { AIDL_ERROR(start_type) << "has cyclic references to nested types."; return false; } return true; }); VisitTopDown(v, doc); return v.success; } } // namespace aidl } // namespace android ./PaxHeaders.X/check_valid.h0100644 0000000 0000000 00000000034 15172120304 014701 xustar000000000 0000000 28 mtime=1776853188.3310000 check_valid.h0100644 0000000 0000000 00000001456 15172120304 012213 0ustar000000000 0000000 /* * Copyright (C) 2021, 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. */ #pragma once #include "aidl_language.h" #include "options.h" namespace android { namespace aidl { bool CheckValid(const AidlDocument& doc, const Options& options); } } // namespace android./PaxHeaders.X/code_writer.cpp0100644 0000000 0000000 00000000034 15172120304 015306 xustar000000000 0000000 28 mtime=1776853188.3310000 code_writer.cpp0100644 0000000 0000000 00000010023 15172120304 012606 0ustar000000000 0000000 /* * Copyright (C) 2015, 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 "code_writer.h" #include "logging.h" #include #include #include #include #include #include namespace android { namespace aidl { CodeWriter::CodeWriter(std::unique_ptr ostream) : ostream_(std::move(ostream)) {} std::string CodeWriter::ApplyIndent(const std::string& str) { std::string output; if (!start_of_line_ || str == "\n") { output = str; } else { output = std::string(indent_level_ * 2, ' ') + str; } start_of_line_ = !output.empty() && output.back() == '\n'; return output; } bool CodeWriter::WriteString(const std::string& str) { // extract lines. empty line is preserved. std::vector lines; size_t pos = 0; while (pos < str.size()) { size_t line_end = str.find('\n', pos); if (line_end != std::string::npos) { lines.push_back(str.substr(pos, (line_end - pos) + 1)); pos = line_end + 1; } else { lines.push_back(str.substr(pos)); break; } } std::string indented; for (const auto& line : lines) { indented.append(ApplyIndent(line)); } (*ostream_) << indented; return !ostream_->fail(); } void CodeWriter::Indent() { indent_level_++; } void CodeWriter::Dedent() { AIDL_FATAL_IF(indent_level_ <= 0, "Mismatched dedent"); indent_level_--; } bool CodeWriter::Close() { if (ostream_.get()->rdbuf() != std::cout.rdbuf()) { // if the steam is for file (not stdout), do the close. static_cast(ostream_.get())->close(); return !ostream_->fail(); } return true; } CodeWriter& CodeWriter::operator<<(const char* s) { Write("%s", s); return *this; } CodeWriter& CodeWriter::operator<<(const std::string& str) { Write("%s", str.c_str()); return *this; } CodeWriterPtr CodeWriter::ForFile(const std::string& filename) { std::unique_ptr stream; if (filename == "-") { stream = std::unique_ptr(new std::ostream(std::cout.rdbuf())); } else { stream = std::unique_ptr( new std::fstream(filename, std::fstream::out | std::fstream::binary)); } return CodeWriterPtr(new CodeWriter(std::move(stream))); } CodeWriterPtr CodeWriter::ForString(std::string* buf) { // This class is defined inside this static function of CodeWriter // in order to have access to private constructor and private member // ostream_. class StringCodeWriter : public CodeWriter { public: StringCodeWriter(std::string* buf) : CodeWriter(std::unique_ptr(new std::stringstream())), buf_(buf) {} ~StringCodeWriter() override { Close(); } bool Close() override { // extract whats written to the stringstream to the external buffer. // we are sure that ostream_ is indeed stringstream. *buf_ = static_cast(ostream_.get())->str(); return true; } private: std::string* buf_; }; return CodeWriterPtr(new StringCodeWriter(buf)); } std::string QuotedEscape(const std::string& str) { std::string result; result += '"'; static const std::unordered_map escape = { {'"', "\\\""}, {'\\', "\\\\"}, {'\n', "\\n"}, {'\r', "\\r"}, {'\t', "\\t"}, {'\v', "\\v"}, }; for (auto c : str) { auto it = escape.find(c); if (it != escape.end()) { result += it->second; } else { result += c; } } result += '"'; return result; } } // namespace aidl } // namespace android ./PaxHeaders.X/code_writer.h0100644 0000000 0000000 00000000034 15172120304 014753 xustar000000000 0000000 28 mtime=1776853188.3310000 code_writer.h0100644 0000000 0000000 00000004415 15172120304 012263 0ustar000000000 0000000 /* * Copyright (C) 2015, 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. */ #pragma once #include #include #include #include #include #include #include namespace android { namespace aidl { class CodeWriter; using CodeWriterPtr = std::unique_ptr; class CodeWriter { public: // Get a CodeWriter that writes to a file. When filename is "-", // it is written to stdout. static CodeWriterPtr ForFile(const std::string& filename); // Get a CodeWriter that writes to a string buffer. // The buffer gets updated only after Close() is called or the CodeWriter // is deleted -- much like a real file. static CodeWriterPtr ForString(std::string* buf); // Write a formatted string to this writer in the usual printf sense. // Returns false on error. template bool Write(const char* format, Args... args) __attribute__((format(printf, 2, 0))) { std::string formatted; android::base::StringAppendF(&formatted, format, args...); return WriteString(formatted); } template <> bool Write(const char* str) { return WriteString(str); } virtual bool WriteString(const std::string&); void Indent(); void Dedent(); virtual bool Close(); virtual ~CodeWriter() = default; CodeWriter() = default; CodeWriter& operator<<(const char* s); CodeWriter& operator<<(const std::string& str); private: CodeWriter(std::unique_ptr ostream); std::string ApplyIndent(const std::string& str); const std::unique_ptr ostream_; int indent_level_ {0}; bool start_of_line_ {true}; }; std::string QuotedEscape(const std::string& str); } // namespace aidl } // namespace android ./PaxHeaders.X/code_writer_unittest.cpp0100644 0000000 0000000 00000000034 15172120304 017245 xustar000000000 0000000 28 mtime=1776853188.3320000 code_writer_unittest.cpp0100644 0000000 0000000 00000003162 15172120304 014553 0ustar000000000 0000000 /* * Copyright (C) 2018, The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "code_writer.h" #include #include using android::aidl::CodeWriter; using std::string; using std::unique_ptr; namespace android { namespace aidl { TEST(CodeWriterTest, AppendOperator) { string str; CodeWriterPtr ptr = CodeWriter::ForString(&str); CodeWriter& writer = *ptr; writer << "Write this"; writer.Close(); EXPECT_EQ(str, "Write this"); } TEST(CodeWriterTest, AppendOperatorCascade) { string str; CodeWriterPtr ptr = CodeWriter::ForString(&str); CodeWriter& writer = *ptr; writer << "Write this " << "and that"; writer.Close(); EXPECT_EQ(str, "Write this and that"); } TEST(CodeWriterTest, WorksWithNonAscii) { // Due to b/174366536(basic_stringbuf implicit-conversion), the following snippet crashes // std::stringstream s; // s << "ê°€"; std::string str; CodeWriterPtr ptr = CodeWriter::ForString(&str); CodeWriter& writer = *ptr; writer << "ê°€"; writer.Close(); EXPECT_EQ(str, "ê°€"); } } // namespace aidl } // namespace android ./PaxHeaders.X/comments.cpp0100644 0000000 0000000 00000000034 15172120304 014625 xustar000000000 0000000 28 mtime=1776853188.3320000 comments.cpp0100644 0000000 0000000 00000015476 15172120304 012146 0ustar000000000 0000000 /* * Copyright (C) 2021, 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 "comments.h" #include #include #include #include #include #include #include "logging.h" using android::base::EndsWith; using android::base::Error; using android::base::Join; using android::base::Result; using android::base::Split; using android::base::StartsWith; using android::base::Trim; namespace android { namespace aidl { namespace { static const std::string_view kLineCommentBegin = "//"; static const std::string_view kBlockCommentBegin = "/*"; static const std::string_view kBlockCommentMid = " *"; static const std::string_view kBlockCommentEnd = "*/"; static const std::string_view kDocCommentBegin = "/**"; static const std::string kTagDeprecated = "@deprecated"; static const std::regex kTagHideRegex{"@hide\\b"}; std::string ConsumePrefix(const std::string& s, std::string_view prefix) { AIDL_FATAL_IF(!StartsWith(s, prefix), AIDL_LOCATION_HERE) << "'" << s << "' has no prefix '" << prefix << "'"; return s.substr(prefix.size()); } std::string ConsumeSuffix(const std::string& s, std::string_view suffix) { AIDL_FATAL_IF(!EndsWith(s, suffix), AIDL_LOCATION_HERE); return s.substr(0, s.size() - suffix.size()); } struct BlockTag { std::string name; std::string description; }; // Removes comment markers: //, /*, */, optional leading "*" in block comments // - keeps leading spaces, but trims trailing spaces // - keeps empty lines std::vector TrimmedLines(const Comment& c) { if (c.type == Comment::Type::LINE) { return std::vector{ConsumePrefix(c.body, kLineCommentBegin)}; } std::string stripped = ConsumeSuffix(ConsumePrefix(c.body, kBlockCommentBegin), kBlockCommentEnd); std::vector lines; bool found_first_line = false; for (auto& line : Split(stripped, "\n")) { // Delete prefixes like " * ", " *", or " ". size_t idx = 0; for (; idx < line.size() && isspace(line[idx]); idx++) ; if (idx < line.size() && line[idx] == '*') idx++; if (idx < line.size() && line[idx] == ' ') idx++; const std::string& sanitized_line = line.substr(idx); size_t i = sanitized_line.size(); for (; i > 0 && isspace(sanitized_line[i - 1]); i--) ; // Either the size is 0 or everything was whitespace. bool is_empty_line = i == 0; found_first_line = found_first_line || !is_empty_line; if (!found_first_line) continue; // if is_empty_line, i == 0 so substr == "" lines.push_back(sanitized_line.substr(0, i)); } // remove trailing empty lines while (!lines.empty() && Trim(lines.back()).empty()) { lines.pop_back(); } return lines; } // Parses a block comment and returns block tags in the comment. std::vector BlockTags(const Comment& c) { AIDL_FATAL_IF(c.type != Comment::Type::BLOCK, AIDL_LOCATION_HERE); std::vector tags; // current tag and paragraph std::string tag; std::vector paragraph; auto end_paragraph = [&]() { if (tag.empty()) { paragraph.clear(); return; } // paragraph lines are trimed at both ends tags.push_back({tag, Join(paragraph, " ")}); tag.clear(); paragraph.clear(); }; for (const auto& line : TrimmedLines(c)) { size_t idx = 0; // skip leading spaces for (; idx < line.size() && isspace(line[idx]); idx++) ; if (idx == line.size()) { // skip empty lines } else if (line[idx] == '@') { // end the current paragraph before reading a new block tag (+ description paragraph) end_paragraph(); size_t end_idx = idx + 1; for (; end_idx < line.size() && isalpha(line[end_idx]); end_idx++) ; tag = line.substr(idx, end_idx - idx); if (end_idx < line.size() && line[end_idx] == ' ') end_idx++; // skip empty line if (end_idx < line.size()) { paragraph.push_back(line.substr(end_idx)); } } else { // gather paragraph lines with leading spaces trimmed paragraph.push_back(line.substr(idx)); } } end_paragraph(); return tags; } } // namespace Comment::Comment(const std::string& body) : body(body) { if (StartsWith(body, kLineCommentBegin)) { type = Type::LINE; } else if (StartsWith(body, kBlockCommentBegin) && EndsWith(body, kBlockCommentEnd)) { type = Type::BLOCK; } else { AIDL_FATAL(AIDL_LOCATION_HERE) << "invalid comments body:" << body; } } // Sees if comments have the @hide tag. // Example: /** @hide */ bool HasHideInComments(const Comments& comments) { for (const Comment& comment : comments) { if (comment.type != Comment::Type::BLOCK) continue; if (!std::regex_search(comment.body, kTagHideRegex)) continue; return true; } return false; } // Finds the @deprecated tag in comments and returns it with optional note which // follows the tag. // Example: /** @deprecated reason */ std::optional FindDeprecated(const Comments& comments) { for (const Comment& comment : comments) { if (comment.type != Comment::Type::BLOCK) continue; for (const auto& [name, description] : BlockTags(comment)) { // take the first @deprecated if (kTagDeprecated == name) { return Deprecated{description}; } } } return std::nullopt; } // Formats comments for the Java backend. // The last/block comment is transformed into javadoc(/** */) // and others are used as they are. std::string FormatCommentsForJava(const Comments& comments) { std::stringstream out; for (auto it = begin(comments); it != end(comments); it++) { const bool last = next(it) == end(comments); auto lines = TrimmedLines(*it); if (it->type == Comment::Type::LINE) { for (const auto& line : lines) { out << kLineCommentBegin << line; } } else { if (last || StartsWith(it->body, kDocCommentBegin)) { out << kDocCommentBegin; } else { out << kBlockCommentBegin; } bool multiline = lines.size() > 1; if (multiline) out << "\n"; for (const auto& line : lines) { if (multiline) out << kBlockCommentMid; out << " " << line; if (multiline) out << "\n"; } out << " " << kBlockCommentEnd << "\n"; } } return out.str(); } } // namespace aidl } // namespace android ./PaxHeaders.X/comments.h0100644 0000000 0000000 00000000034 15172120304 014272 xustar000000000 0000000 28 mtime=1776853188.3320000 comments.h0100644 0000000 0000000 00000003027 15172120304 011600 0ustar000000000 0000000 /* * Copyright (C) 2021, 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. */ #pragma once #include #include #include #include namespace android { namespace aidl { // Represents a single comment struct Comment { enum class Type { LINE, BLOCK }; Type type; std::string body; Comment(const std::string& body); // for GTest assertions friend inline bool operator==(const Comment& lhs, const Comment& rhs) { return lhs.body == rhs.body; } friend std::ostream& operator<<(std::ostream& out, const Comment& c) { return out << c.body; } }; // TODO: smoreland says don't do this - instead use 'std::vector' everywhere using Comments = std::vector; bool HasHideInComments(const Comments& comments); struct Deprecated { std::string note; // can be empty("") }; std::optional FindDeprecated(const Comments& comments); std::string FormatCommentsForJava(const Comments& comments); } // namespace aidl } // namespace android ./PaxHeaders.X/diagnostics.cpp0100644 0000000 0000000 00000000034 15172120304 015307 xustar000000000 0000000 28 mtime=1776853188.3320000 diagnostics.cpp0100644 0000000 0000000 00000041442 15172120304 012620 0ustar000000000 0000000 /* * 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 "diagnostics.h" #include #include #include "aidl_language.h" #include "logging.h" using std::placeholders::_1; namespace android { namespace aidl { const std::map kAllDiagnostics = { #define DIAG(ENUM, NAME, ENABLED) {NAME, DiagnosticOption{DiagnosticID::ENUM, NAME, ENABLED}}, #include "diagnostics.inc" #undef DIAG }; static const std::map kDiagnosticsNames = { #define DIAG(ENUM, NAME, ENABLED) {DiagnosticID::ENUM, NAME}, #include "diagnostics.inc" #undef DIAG }; void DiagnosticMapping::Severity(DiagnosticID id, DiagnosticSeverity severity) { mapping_[id] = severity; } DiagnosticSeverity DiagnosticMapping::Severity(DiagnosticID id) const { return mapping_.at(id); } std::string to_string(DiagnosticID id) { return kDiagnosticsNames.at(id); } static std::string ToUpper(const std::string& name) { std::string nameCopy(name); for (auto& c : nameCopy) c = std::toupper(c); return nameCopy; } class DiagnosticsContext { public: DiagnosticsContext(DiagnosticMapping mapping) : mapping_({std::move(mapping)}) {} AidlErrorLog Report(const AidlLocation& loc, DiagnosticID id, DiagnosticSeverity force_severity = DiagnosticSeverity::DISABLED) { if (loc.IsInternal()) { return AidlErrorLog(AidlErrorLog::NO_OP, loc); } const std::string suffix = " [-W" + to_string(id) + "]"; auto severity = std::max(force_severity, mapping_.top().Severity(id)); switch (severity) { case DiagnosticSeverity::DISABLED: return AidlErrorLog(AidlErrorLog::NO_OP, loc); case DiagnosticSeverity::WARNING: return AidlErrorLog(AidlErrorLog::WARNING, loc, suffix); case DiagnosticSeverity::ERROR: error_count_++; return AidlErrorLog(AidlErrorLog::ERROR, loc, suffix); } } size_t ErrorCount() const { return error_count_; } void Suppress(const AidlAnnotatable& a) { const auto& warnings = a.SuppressWarnings(); DiagnosticMapping new_mapping = mapping_.top(); for (const auto& w : warnings) { auto it = kAllDiagnostics.find(w); if (it == kAllDiagnostics.end()) { Report(a.GetLocation(), DiagnosticID::unknown_warning, DiagnosticSeverity::ERROR) << "unknown warning: " << w; continue; } new_mapping.Severity(it->second.id, DiagnosticSeverity::DISABLED); } mapping_.push(std::move(new_mapping)); } void Restore(const AidlAnnotatable&) { mapping_.pop(); } private: std::stack mapping_; size_t error_count_ = {}; }; class DiagnosticsVisitor : public AidlVisitor { public: DiagnosticsVisitor(DiagnosticsContext& diag) : diag(diag) {} void Check(const AidlDocument& doc) { DiagnosticsVisitor* visitor = this; using Fun = std::function; struct Hook : public AidlVisitor { Fun fun; Hook(Fun fun) : fun(fun) {} void Visit(const AidlInterface& a) override { fun(a); } void Visit(const AidlEnumDeclaration& a) override { fun(a); } void Visit(const AidlStructuredParcelable& a) override { fun(a); } void Visit(const AidlUnionDecl& a) override { fun(a); } void Visit(const AidlParcelable& a) override { fun(a); } void Visit(const AidlMethod& a) override { fun(a.GetType()); } }; Hook suppress{std::bind(&DiagnosticsContext::Suppress, &diag, _1)}; Hook restore{std::bind(&DiagnosticsContext::Restore, &diag, _1)}; std::function top_down = [&top_down, &suppress, &restore, visitor](const AidlNode& a) { a.DispatchVisit(suppress); a.DispatchVisit(*visitor); a.TraverseChildren(top_down); a.DispatchVisit(restore); }; top_down(doc); } protected: DiagnosticsContext& diag; }; struct DiagnoseInterfaceName : DiagnosticsVisitor { DiagnoseInterfaceName(DiagnosticsContext& diag) : DiagnosticsVisitor(diag) {} void Visit(const AidlInterface& i) override { if (auto name = i.GetName(); name.size() < 1 || name[0] != 'I') { diag.Report(i.GetLocation(), DiagnosticID::interface_name) << "Interface names should start with I."; } } }; struct DiagnoseInoutParameter : DiagnosticsVisitor { DiagnoseInoutParameter(DiagnosticsContext& diag) : DiagnosticsVisitor(diag) {} void Visit(const AidlArgument& a) override { if (a.GetDirection() == AidlArgument::INOUT_DIR) { diag.Report(a.GetLocation(), DiagnosticID::inout_parameter) << a.GetName() << " is 'inout'. Avoid inout parameters. This is somewhat confusing for clients " "because although the parameters are 'in', they look out 'out' parameters."; } } }; struct DiagnoseConstName : DiagnosticsVisitor { DiagnoseConstName(DiagnosticsContext& diag) : DiagnosticsVisitor(diag) {} void Visit(const AidlEnumerator& e) override { if (ToUpper(e.GetName()) != e.GetName()) { diag.Report(e.GetLocation(), DiagnosticID::const_name) << "Enum values should be named in upper case: " << e.GetName(); } } void Visit(const AidlConstantDeclaration& c) override { if (ToUpper(c.GetName()) != c.GetName()) { diag.Report(c.GetLocation(), DiagnosticID::const_name) << "Constants should be named in upper case: " << c.GetName(); } } }; struct DiagnoseExplicitDefault : DiagnosticsVisitor { DiagnoseExplicitDefault(DiagnosticsContext& diag) : DiagnosticsVisitor(diag) {} void Visit(const AidlStructuredParcelable& p) override { for (const auto& var : p.GetFields()) { CheckExplicitDefault(*var); } } void Visit(const AidlUnionDecl& u) override { AIDL_FATAL_IF(u.GetFields().empty(), u) << "The union '" << u.GetName() << "' has no fields."; const auto& first = u.GetFields()[0]; CheckExplicitDefault(*first); } void CheckExplicitDefault(const AidlVariableDeclaration& v) { if (v.IsDefaultUserSpecified()) return; if (v.GetType().IsNullable()) return; if (v.GetType().IsArray()) return; const auto defined_type = v.GetType().GetDefinedType(); if (defined_type && defined_type->AsEnumDeclaration()) { diag.Report(v.GetLocation(), DiagnosticID::enum_explicit_default) << "The enum field '" << v.GetName() << "' has no explicit value."; return; } } }; struct DiagnoseMixedOneway : DiagnosticsVisitor { DiagnoseMixedOneway(DiagnosticsContext& diag) : DiagnosticsVisitor(diag) {} void Visit(const AidlInterface& i) override { bool has_oneway = false; bool has_twoway = false; for (const auto& m : i.GetMethods()) { if (!m->IsUserDefined()) continue; if (Suppressed(*m)) continue; if (m->IsOneway()) { has_oneway = true; } else { has_twoway = true; } } if (has_oneway && has_twoway) { diag.Report(i.GetLocation(), DiagnosticID::mixed_oneway) << "The interface '" << i.GetName() << "' has both one-way and two-way methods. This makes it hard to reason about threading " "of client code."; } } bool Suppressed(const AidlMethod& m) const { for (const auto& w : m.GetType().SuppressWarnings()) { if (w == to_string(DiagnosticID::mixed_oneway)) { return true; } } return false; } }; struct DiagnoseRedundantOneway : DiagnosticsVisitor { DiagnoseRedundantOneway(DiagnosticsContext& diag) : DiagnosticsVisitor(diag) {} void Visit(const AidlInterface& i) override { if (i.HasOnewayAnnotation()) { for (const auto& m : i.GetMethods()) { if (!m->IsUserDefined()) continue; if (Suppressed(*m)) continue; if (m->HasOnewayAnnotation()) { diag.Report(i.GetLocation(), DiagnosticID::redundant_oneway) << "The interface '" << i.GetName() << "' is oneway. Redundant oneway annotation for method '" << m->GetName() << "'."; } } } } bool Suppressed(const AidlMethod& m) const { for (const auto& w : m.GetType().SuppressWarnings()) { if (w == to_string(DiagnosticID::redundant_oneway)) { return true; } } return false; } }; struct DiagnoseOutArray : DiagnosticsVisitor { DiagnoseOutArray(DiagnosticsContext& diag) : DiagnosticsVisitor(diag) {} void Visit(const AidlMethod& m) override { for (const auto& a : m.GetArguments()) { if (a->GetType().IsArray() && a->IsOut()) { diag.Report(m.GetLocation(), DiagnosticID::out_array) << "The method '" << m.GetName() << "' an array output parameter '" << a->GetName() << "'. Instead prefer APIs like '" << a->GetType().Signature() << " " << m.GetName() << "(...)."; } } } }; struct DiagnoseFileDescriptor : DiagnosticsVisitor { DiagnoseFileDescriptor(DiagnosticsContext& diag) : DiagnosticsVisitor(diag) {} void Visit(const AidlTypeSpecifier& t) override { if (t.GetName() == "FileDescriptor") { diag.Report(t.GetLocation(), DiagnosticID::file_descriptor) << "Please use ParcelFileDescriptor instead of FileDescriptor."; } } }; struct DiagnoseOutNullable : DiagnosticsVisitor { DiagnoseOutNullable(DiagnosticsContext& diag) : DiagnosticsVisitor(diag) {} void Visit(const AidlArgument& a) override { if (a.GetType().IsArray()) return; if (a.IsOut() && a.GetType().IsNullable()) { diag.Report(a.GetLocation(), DiagnosticID::out_nullable) << "'" << a.GetName() << "' is an " << a.GetDirectionSpecifier() << " parameter and also nullable. Some backends don't support setting null value to out " "parameters. Please use it as return value or drop @nullable to avoid potential " "errors."; } } }; struct DiagnoseImports : DiagnosticsVisitor { DiagnoseImports(DiagnosticsContext& diag) : DiagnosticsVisitor(diag) {} void Visit(const AidlDocument& doc) override { auto collide_with_decls = [&](const auto& import) { for (const auto& type : doc.DefinedTypes()) { if (type->GetCanonicalName() != import && type->GetName() == SimpleName(import)) { return true; } } return false; }; std::set imported_names; for (const auto& import : doc.Imports()) { if (collide_with_decls(import)) { diag.Report(doc.GetLocation(), DiagnosticID::unique_import) << SimpleName(import) << " is already defined in this file."; } auto [_, inserted] = imported_names.insert(SimpleName(import)); if (!inserted) { diag.Report(doc.GetLocation(), DiagnosticID::unique_import) << SimpleName(import) << " is already imported."; } } } }; struct DiagnoseUntypedCollection : DiagnosticsVisitor { DiagnoseUntypedCollection(DiagnosticsContext& diag) : DiagnosticsVisitor(diag) {} void Visit(const AidlTypeSpecifier& t) override { if (t.GetName() == "List" || t.GetName() == "Map") { if (!t.IsGeneric()) { diag.Report(t.GetLocation(), DiagnosticID::untyped_collection) << "Use List or Map instead."; } } } }; struct DiagnosePermissionAnnotations : DiagnosticsVisitor { DiagnosePermissionAnnotations(DiagnosticsContext& diag) : DiagnosticsVisitor(diag) {} void Visit(const AidlInterface& intf) override { const std::string diag_message = " is not annotated for permissions. Declare which permissions are " "required using @EnforcePermission. If permissions are manually " "verified within the implementation, use @PermissionManuallyEnforced. " "If no permissions are required, use @RequiresNoPermission."; if (intf.IsPermissionAnnotated()) { return; } const auto& methods = intf.GetMethods(); std::vector methods_without_annotations; size_t num_user_defined_methods = 0; for (size_t i = 0; i < methods.size(); ++i) { auto& m = methods[i]; if (!m->IsUserDefined()) continue; num_user_defined_methods++; if (m->GetType().IsPermissionAnnotated()) { continue; } methods_without_annotations.push_back(i); } if (methods_without_annotations.size() == num_user_defined_methods) { diag.Report(intf.GetLocation(), DiagnosticID::missing_permission_annotation) << intf.GetName() << diag_message << " This can be done for the whole interface or for each method."; } else { for (size_t i : methods_without_annotations) { auto& m = methods[i]; diag.Report(m->GetLocation(), DiagnosticID::missing_permission_annotation) << m->GetName() << diag_message; } } } }; struct DiagnoseRedundantNames : DiagnosticsVisitor { DiagnoseRedundantNames(DiagnosticsContext& diag) : DiagnosticsVisitor(diag) {} // tokenize the name with either capital letters or '_' being the delimiters static std::vector TokenizeName(const std::string& name) { // if a name is all capitals with no '_', then we don't want to tokenize it. if (std::all_of(name.begin(), name.end(), [](unsigned char c) { return isupper(c); })) { return {name}; } // if a name has an `_` in it, it will be tokenized based on '_', // otherwise based on capital letters if (name.find('_') != std::string::npos) { return base::Tokenize(name, "_"); } std::vector tokens; size_t size = name.size(); std::string tmp{name.front()}; // Skip the first character to avoid an empty substring for common cases for (size_t i = 1; i < size; i++) { if (std::isupper(name[i])) { tokens.push_back(tmp); tmp.clear(); // This uppercase letter belongs to the next token tmp += name[i]; } else { tmp += name[i]; } } if (!tmp.empty()) tokens.push_back(tmp); return tokens; } void Visit(const AidlEnumDeclaration& e) override { const std::vector parent = TokenizeName(e.GetName()); for (const auto& enumerator : e.GetEnumerators()) { const std::vector child = TokenizeName(enumerator->GetName()); for (const auto& parentSubStr : parent) { for (const auto& childSubStr : child) { if (ToUpper(parentSubStr) == ToUpper(childSubStr)) { diag.Report(e.GetLocation(), DiagnosticID::redundant_name) << "The enumerator '" << enumerator->GetName() << "' has a redundant substring '" << childSubStr << "' being defined in '" << e.GetName() << "'"; } } } } } void CheckConstantDeclarations( const std::string& name, const std::vector>& consts) { const std::vector parent = TokenizeName(name); for (const auto& member : consts) { const std::vector child = TokenizeName(member->GetName()); for (const auto& parentSubStr : parent) { for (const auto& childSubStr : child) { if (ToUpper(parentSubStr) == ToUpper(childSubStr)) { diag.Report(member->GetLocation(), DiagnosticID::redundant_name) << "The constant '" << member->GetName() << "' has a redundant substring '" << childSubStr << "' being defined in '" << name << "'"; } } } } } void Visit(const AidlInterface& t) override { CheckConstantDeclarations(t.GetName(), t.GetConstantDeclarations()); } void Visit(const AidlUnionDecl& t) override { CheckConstantDeclarations(t.GetName(), t.GetConstantDeclarations()); } void Visit(const AidlStructuredParcelable& t) override { CheckConstantDeclarations(t.GetName(), t.GetConstantDeclarations()); } }; bool Diagnose(const AidlDocument& doc, const DiagnosticMapping& mapping) { DiagnosticsContext diag(mapping); DiagnoseInterfaceName{diag}.Check(doc); DiagnoseInoutParameter{diag}.Check(doc); DiagnoseConstName{diag}.Check(doc); DiagnoseExplicitDefault{diag}.Check(doc); DiagnoseMixedOneway{diag}.Check(doc); DiagnoseOutArray{diag}.Check(doc); DiagnoseFileDescriptor{diag}.Check(doc); DiagnoseOutNullable{diag}.Check(doc); DiagnoseImports{diag}.Check(doc); DiagnoseUntypedCollection{diag}.Check(doc); DiagnosePermissionAnnotations{diag}.Check(doc); DiagnoseRedundantNames{diag}.Check(doc); DiagnoseRedundantOneway{diag}.Check(doc); return diag.ErrorCount() == 0; } } // namespace aidl } // namespace android ./PaxHeaders.X/diagnostics.h0100644 0000000 0000000 00000000034 15172120304 014754 xustar000000000 0000000 28 mtime=1776853188.3330000 diagnostics.h0100644 0000000 0000000 00000003154 15172120304 012263 0ustar000000000 0000000 /* * 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. */ #pragma once #include #include #include #include #include #include class AidlDocument; class AidlLocation; class AidlErrorLog; namespace android { namespace aidl { enum class DiagnosticSeverity { DISABLED, WARNING, ERROR, }; enum class DiagnosticID { #define DIAG(ENUM, NAME, ENABLED) ENUM, #include "diagnostics.inc" #undef DIAG }; class DiagnosticMapping { public: DiagnosticSeverity Severity(DiagnosticID id) const; void Severity(DiagnosticID id, DiagnosticSeverity severity); private: std::map mapping_; }; struct DiagnosticOption { DiagnosticID id; const std::string name; bool default_enabled; }; extern const std::map kAllDiagnostics; // relying on Argument-dependent lookup std::string to_string(DiagnosticID id); bool Diagnose(const AidlDocument& doc, const DiagnosticMapping& mapping); } // namespace aidl } // namespace android ./PaxHeaders.X/diagnostics.inc0100644 0000000 0000000 00000000034 15172120304 015276 xustar000000000 0000000 28 mtime=1776853188.3330000 diagnostics.inc0100644 0000000 0000000 00000001315 15172120304 012602 0ustar000000000 0000000 // DIAG(enum, name, enable-by-default) DIAG(const_name, "const-name", false) DIAG(enum_explicit_default, "enum-explicit-default", false) DIAG(file_descriptor, "file-descriptor", false) DIAG(inout_parameter, "inout-parameter", false) DIAG(interface_name, "interface-name", false) DIAG(missing_permission_annotation, "missing-permission-annotation", false) DIAG(mixed_oneway, "mixed-oneway", false) DIAG(out_array, "out-array", false) DIAG(out_nullable, "out-nullable", false) DIAG(unique_import, "unique-import", false) DIAG(unknown_warning, "unknown-warning", false) DIAG(untyped_collection, "untyped-collection", false) DIAG(redundant_name, "redundant-name", false) DIAG(redundant_oneway, "redundant-oneway", false) ./PaxHeaders.X/diagnostics_unittest.cpp0100644 0000000 0000000 00000000034 15172120304 017246 xustar000000000 0000000 28 mtime=1776853188.3330000 diagnostics_unittest.cpp0100644 0000000 0000000 00000030235 15172120304 014555 0ustar000000000 0000000 /* * 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 "diagnostics.h" #include #include #include #include #include "aidl.h" #include "parser.h" #include "tests/fake_io_delegate.h" using android::aidl::AidlTypenames; using android::aidl::DiagnosticID; using android::aidl::Options; using android::aidl::internals::load_and_validate_aidl; using android::aidl::test::FakeIoDelegate; using testing::internal::CaptureStderr; using testing::internal::GetCapturedStderr; struct DiagnosticsTest : testing::Test { void ParseFiles(std::vector>&& files) { ASSERT_TRUE(files.size() > 0); const std::string main = files.begin()->first; for (const auto& [file, contents] : files) { io.SetFileContents(file, contents); } if (!enable_diagnostic) { ASSERT_TRUE(expect_diagnostic); enable_diagnostic = expect_diagnostic; } // emit diagnostics as warnings. // "java" has no specific meaning here because we're testing CheckValid() const Options options = Options::From("aidl " + optional_args + " -I . --lang java -o out -W" + to_string(*enable_diagnostic) + " " + main); CaptureStderr(); load_and_validate_aidl(main, options, io, &typenames, nullptr); const std::string err = GetCapturedStderr(); if (expect_diagnostic) { EXPECT_THAT(err, testing::HasSubstr("-W" + to_string(*expect_diagnostic))); } else { EXPECT_EQ("", err); } } AidlTypenames typenames; FakeIoDelegate io; std::string optional_args; // The type of diagnostic to enable for the test. If expect_diagnostic is // set, use the same value. std::optional enable_diagnostic; // The expected diagnostic. Must be set. std::optional expect_diagnostic; }; TEST_F(DiagnosticsTest, const_name_ForEnumerator) { expect_diagnostic = DiagnosticID::const_name; ParseFiles({{"Foo.aidl", "enum Foo { foo }"}}); } TEST_F(DiagnosticsTest, const_name_ForConstants) { expect_diagnostic = DiagnosticID::const_name; ParseFiles({{"IFoo.aidl", "interface IFoo { const int foo = 1; }"}}); } TEST_F(DiagnosticsTest, interface_name) { expect_diagnostic = DiagnosticID::interface_name; ParseFiles({{"Foo.aidl", "interface Foo { }"}}); } TEST_F(DiagnosticsTest, enum_explicit_default) { expect_diagnostic = DiagnosticID::enum_explicit_default; ParseFiles({{"Foo.aidl", "parcelable Foo { E e; }"}, {"E.aidl", "enum E { A }"}}); } TEST_F(DiagnosticsTest, inout_parameter) { expect_diagnostic = DiagnosticID::inout_parameter; ParseFiles({{"IFoo.aidl", "interface IFoo { void foo(inout Bar bar); }"}, {"Bar.aidl", "parcelable Bar {}"}}); } TEST_F(DiagnosticsTest, inout_parameter_SuppressAtMethodLevel) { enable_diagnostic = DiagnosticID::inout_parameter; expect_diagnostic = {}; ParseFiles({ {"IFoo.aidl", "interface IFoo { @SuppressWarnings(value={\"inout-parameter\"}) void foo(inout Bar b); }"}, {"Bar.aidl", "parcelable Bar {}"}, }); } TEST_F(DiagnosticsTest, inout_parameter_SuppressAtDeclLevel) { enable_diagnostic = DiagnosticID::inout_parameter; expect_diagnostic = {}; ParseFiles({ {"IFoo.aidl", "@SuppressWarnings(value={\"inout-parameter\"}) interface IFoo { void foo(inout Bar b); }"}, {"Bar.aidl", "parcelable Bar {}"}, }); } TEST_F(DiagnosticsTest, UnknownWarning) { expect_diagnostic = DiagnosticID::unknown_warning; ParseFiles({ {"IFoo.aidl", "@SuppressWarnings(value={\"blahblah\"}) interface IFoo { void foo(); }"}, }); } TEST_F(DiagnosticsTest, CantSuppressUnknownWarning) { expect_diagnostic = DiagnosticID::unknown_warning; ParseFiles({ {"IFoo.aidl", "@SuppressWarnings(value={\"unknown-warning\"})\n" "interface IFoo { @SuppressWarnings(value={\"blah-blah\"}) void foo(); }"}, }); } TEST_F(DiagnosticsTest, DontMixOnewayWithTwowayMethods) { expect_diagnostic = DiagnosticID::mixed_oneway; ParseFiles({ {"IFoo.aidl", "interface IFoo { void foo(); oneway void bar(); }"}, }); } TEST_F(DiagnosticsTest, DontMixOnewayWithTwowayMethodsSuppressedAtMethod) { enable_diagnostic = DiagnosticID::mixed_oneway; expect_diagnostic = {}; ParseFiles({ {"IFoo.aidl", "interface IFoo {\n" " void foo();\n" " @SuppressWarnings(value={\"mixed-oneway\"}) oneway void bar();\n" "}"}, }); } TEST_F(DiagnosticsTest, OnewayInterfaceIsOkayWithSyntheticMethods) { optional_args = "--version 2"; // will add getInterfaceVersion() synthetic method enable_diagnostic = DiagnosticID::mixed_oneway; expect_diagnostic = {}; ParseFiles({ {"IFoo.aidl", "oneway interface IFoo { void foo(); }"}, }); } TEST_F(DiagnosticsTest, RedundantOnewayMethodAnnotationInOnewayInterface) { expect_diagnostic = DiagnosticID::redundant_oneway; ParseFiles({ {"IFoo.aidl", "oneway interface IFoo { oneway void foo(int a); }"}, }); } TEST_F(DiagnosticsTest, RedundantOnewayMethodSuppressedAtMethod) { enable_diagnostic = DiagnosticID::redundant_oneway; expect_diagnostic = {}; ParseFiles({ {"IFoo.aidl", "oneway interface IFoo {\n" " @SuppressWarnings(value={\"redundant-oneway\"}) oneway void bar();\n" "}"}, }); } TEST_F(DiagnosticsTest, ArraysAsOutputParametersConsideredHarmful) { expect_diagnostic = DiagnosticID::out_array; ParseFiles({ {"IFoo.aidl", "interface IFoo { void foo(out String[] ret); }"}, }); } TEST_F(DiagnosticsTest, file_descriptor) { expect_diagnostic = DiagnosticID::file_descriptor; ParseFiles({{"IFoo.aidl", "interface IFoo {\n" " void foo(in FileDescriptor fd);\n" "}"}}); } TEST_F(DiagnosticsTest, out_nullable) { expect_diagnostic = DiagnosticID::out_nullable; ParseFiles({{"IFoo.aidl", "interface IFoo {\n" " void foo(out @nullable Bar bar);\n" "}"}, {"Bar.aidl", "parcelable Bar {}"}}); } TEST_F(DiagnosticsTest, inout_nullable) { expect_diagnostic = DiagnosticID::out_nullable; ParseFiles({{"IFoo.aidl", "interface IFoo {\n" " void foo(inout @nullable Bar bar);\n" "}"}, {"Bar.aidl", "parcelable Bar {}"}}); } TEST_F(DiagnosticsTest, out_nullable_OkayForArrays) { expect_diagnostic = DiagnosticID::out_array; // not triggering out_nullable ParseFiles({{"IFoo.aidl", "interface IFoo {\n" " void foo(inout @nullable Bar[] bar1, out @nullable Bar[] bar2);\n" "}"}, {"Bar.aidl", "parcelable Bar {}"}}); } TEST_F(DiagnosticsTest, RejectImportsCollisionWithTopLevelDecl) { expect_diagnostic = DiagnosticID::unique_import; ParseFiles({{"p/IFoo.aidl", "package p;\n" "import q.IFoo;\n" // should collide with previous import "interface IFoo{}"}, {"q/IFoo.aidl", "package q; interface IFoo{}"}}); } TEST_F(DiagnosticsTest, RejectImportsCollision) { expect_diagnostic = DiagnosticID::unique_import; ParseFiles({{"p/IFoo.aidl", "package p;\n" "import q.IBar;\n" "import r.IBar;\n" // should collide with previous import "interface IFoo{}"}, {"q/IBar.aidl", "package q; interface IBar{}"}, {"r/IBar.aidl", "package r; interface IBar{}"}}); } TEST_F(DiagnosticsTest, AllowImportingSelf) { enable_diagnostic = DiagnosticID::unique_import; expect_diagnostic = {}; ParseFiles({{"p/IFoo.aidl", "package p;\n" "import p.IFoo;\n" "interface IFoo{}"}}); } TEST_F(DiagnosticsTest, RedundantImports) { expect_diagnostic = DiagnosticID::unique_import; ParseFiles({{"p/IFoo.aidl", "package p;\n" "import q.IBar;\n" "import q.IBar;\n" "interface IFoo{}"}, {"q/IBar.aidl", "package q; interface IBar{}"}}); } TEST_F(DiagnosticsTest, UntypedCollectionInterface) { expect_diagnostic = DiagnosticID::untyped_collection; ParseFiles({{"IFoo.aidl", "interface IFoo { void foo(in Map m); }"}}); } TEST_F(DiagnosticsTest, UntypedCollectionParcelable) { expect_diagnostic = DiagnosticID::untyped_collection; ParseFiles({{"Foo.aidl", "parcelable Foo { Map m; }"}}); } TEST_F(DiagnosticsTest, UntypedCollectionUnion) { expect_diagnostic = DiagnosticID::untyped_collection; ParseFiles({{"Foo.aidl", "union Foo { List l; }"}}); } TEST_F(DiagnosticsTest, UntypedCollectionInTypeArg) { expect_diagnostic = DiagnosticID::untyped_collection; ParseFiles({{"IFoo.aidl", "interface IFoo { void foo(in Bar m); }"}, {"Bar.aidl", "parcelable Bar {}"}}); } TEST_F(DiagnosticsTest, PermissionMissing) { expect_diagnostic = DiagnosticID::missing_permission_annotation; ParseFiles({{"IFoo.aidl", "interface IFoo { void food(); }"}}); } TEST_F(DiagnosticsTest, PermissionMethod) { enable_diagnostic = DiagnosticID::missing_permission_annotation; expect_diagnostic = {}; ParseFiles({{"IFoo.aidl", "interface IFoo { @EnforcePermission(\"INTERNET\") void food(); }"}}); } TEST_F(DiagnosticsTest, PermissionMethodMissing) { expect_diagnostic = DiagnosticID::missing_permission_annotation; ParseFiles({{"IFoo.aidl", "interface IFoo { @EnforcePermission(\"INTERNET\") void food(); void foo2(); }"}}); } TEST_F(DiagnosticsTest, PermissionInterface) { enable_diagnostic = DiagnosticID::missing_permission_annotation; expect_diagnostic = {}; ParseFiles({{"IFoo.aidl", "@EnforcePermission(\"INTERNET\") interface IFoo { void food(); }"}}); } TEST_F(DiagnosticsTest, RedundantPrefixConstantInterface) { enable_diagnostic = DiagnosticID::redundant_name; expect_diagnostic = DiagnosticID::redundant_name; ParseFiles({{"SomethingStatus.aidl", "interface SomethingStatus { const int STATUS_ONE = 1; }"}}); } TEST_F(DiagnosticsTest, RedundantPrefixConstantParcelable) { enable_diagnostic = DiagnosticID::redundant_name; expect_diagnostic = DiagnosticID::redundant_name; ParseFiles( {{"SomethingStatus.aidl", "parcelable SomethingStatus { const int STATUS_ONE = 1; }"}}); } TEST_F(DiagnosticsTest, RedundantSuffixConstantParcelable) { enable_diagnostic = DiagnosticID::redundant_name; expect_diagnostic = DiagnosticID::redundant_name; ParseFiles( {{"SomethingStatus.aidl", "parcelable SomethingStatus { const int ONE_STATUS = 1; }"}}); } TEST_F(DiagnosticsTest, RedundantSuffixConstantParcelable2) { enable_diagnostic = DiagnosticID::redundant_name; expect_diagnostic = DiagnosticID::redundant_name; ParseFiles( {{"SomethingStatus.aidl", "parcelable SomethingStatus { const int ONE_SOMETHING = 1; }"}}); } TEST_F(DiagnosticsTest, RedundantConstantUnion) { enable_diagnostic = DiagnosticID::redundant_name; expect_diagnostic = DiagnosticID::redundant_name; ParseFiles({{"SomethingStatus.aidl", "union SomethingStatus { const int ONE_SOMETHING = 1; int a; int b;}"}}); } TEST_F(DiagnosticsTest, RedundantPrefixEnum) { enable_diagnostic = DiagnosticID::redundant_name; expect_diagnostic = DiagnosticID::redundant_name; ParseFiles({{"SomethingStatus.aidl", "enum SomethingStatus { STATUS_ONE = 1, }"}}); } TEST_F(DiagnosticsTest, RedundantSuffixEnum) { enable_diagnostic = DiagnosticID::redundant_name; expect_diagnostic = DiagnosticID::redundant_name; ParseFiles({{"SomethingStatus.aidl", "enum SomethingStatus { ONE_STATUS = 1, }"}}); } TEST_F(DiagnosticsTest, RedundantSuffixEnum2) { enable_diagnostic = DiagnosticID::redundant_name; expect_diagnostic = DiagnosticID::redundant_name; ParseFiles({{"SomethingStatus.aidl", "enum SomethingStatus { ONE_SOMETHING = 1, }"}}); } ./PaxHeaders.X/generate_aidl_mappings.cpp0100644 0000000 0000000 00000000034 15172120304 017461 xustar000000000 0000000 28 mtime=1776853188.3330000 generate_aidl_mappings.cpp0100644 0000000 0000000 00000003177 15172120304 014775 0ustar000000000 0000000 /* * Copyright (C) 2019, 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_aidl_mappings.h" #include "aidl_to_java.h" #include namespace android { namespace aidl { namespace mappings { std::string dump_location(const AidlNode& method) { return method.PrintLine(); } SignatureMap generate_mappings(const AidlDefinedType* defined_type) { const AidlInterface* interface = defined_type->AsInterface(); SignatureMap mappings; if (interface == nullptr) { return mappings; } for (const auto& method : interface->GetMethods()) { if (method->IsUserDefined()) { std::stringstream signature; signature << interface->GetCanonicalName() << "|"; signature << method->GetName() << "|"; for (const auto& arg : method->GetArguments()) { signature << java::JavaSignatureOf(arg->GetType()) << ","; } signature << "|"; signature << java::JavaSignatureOf(method->GetType()); mappings[signature.str()] = dump_location(*method); } } return mappings; } } // namespace mappings } // namespace aidl } // namespace android ./PaxHeaders.X/generate_aidl_mappings.h0100644 0000000 0000000 00000000034 15172120304 017126 xustar000000000 0000000 28 mtime=1776853188.3330000 generate_aidl_mappings.h0100644 0000000 0000000 00000001705 15172120304 014435 0ustar000000000 0000000 /* * Copyright (C) 2019, 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. */ #pragma once #include #include #include "aidl_language.h" namespace android { namespace aidl { namespace mappings { using SignatureMap = std::unordered_map; SignatureMap generate_mappings(const AidlDefinedType* iface); } // namespace mappings } // namespace aidl } // namespace android ./PaxHeaders.X/generate_cpp.cpp0100644 0000000 0000000 00000000034 15172120304 015434 xustar000000000 0000000 28 mtime=1776853188.3340000 generate_cpp.cpp0100644 0000000 0000000 00000202161 15172120304 012742 0ustar000000000 0000000 /** * Copyright (C) 2015, 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_cpp.h" #include "aidl.h" #include #include #include #include #include #include #include #include #include #include #include "aidl_language.h" #include "aidl_to_common.h" #include "aidl_to_cpp.h" #include "aidl_typenames.h" #include "logging.h" #include "os.h" using android::base::Join; using android::base::StringPrintf; using std::set; using std::string; using std::unique_ptr; using std::vector; namespace android { namespace aidl { namespace cpp { namespace internals { namespace { const char kAndroidStatusVarName[] = "_aidl_ret_status"; const char kCodeVarName[] = "_aidl_code"; const char kFlagsVarName[] = "_aidl_flags"; const char kDataVarName[] = "_aidl_data"; const char kErrorLabel[] = "_aidl_error"; const char kImplVarName[] = "_aidl_impl"; const char kDelegateImplVarName[] = "_aidl_delegate"; const char kParcelVarName[] = "_aidl_parcel"; const char kReplyVarName[] = "_aidl_reply"; const char kReturnVarName[] = "_aidl_return"; const char kStatusVarName[] = "_aidl_status"; const char kTraceVarName[] = "_aidl_trace"; const char kAndroidParcelLiteral[] = "::android::Parcel"; const char kAndroidStatusLiteral[] = "::android::status_t"; const char kAndroidStatusOk[] = "::android::OK"; const char kAndroidStatusBadValue[] = "::android::BAD_VALUE"; const char kBinderStatusLiteral[] = "::android::binder::Status"; const char kIBinderHeader[] = "binder/IBinder.h"; const char kIInterfaceHeader[] = "binder/IInterface.h"; const char kBinderDelegateHeader[] = "binder/Delegate.h"; const char kParcelHeader[] = "binder/Parcel.h"; const char kStabilityHeader[] = "binder/Stability.h"; const char kStatusHeader[] = "binder/Status.h"; const char kString16Header[] = "utils/String16.h"; const char kTraceHeader[] = "binder/Trace.h"; const char kStrongPointerHeader[] = "utils/StrongPointer.h"; void GenerateBreakOnStatusNotOk(CodeWriter& out) { out.Write("if (((%s) != (%s))) {\n", kAndroidStatusVarName, kAndroidStatusOk); out.Write(" break;\n"); out.Write("}\n"); } void GenerateGotoErrorOnBadStatus(CodeWriter& out) { out.Write("if (((%s) != (%s))) {\n", kAndroidStatusVarName, kAndroidStatusOk); out.Write(" goto %s;\n", kErrorLabel); out.Write("}\n"); } // Format three types of arg list for method. // for_declaration & !type_name_only: int a // for method decl with type and arg // for_declaration & type_name_only: int /*a*/ // for method decl with type // !for_declaration : a // for method call with arg (with direction) string GenerateArgList(const AidlTypenames& typenames, const AidlMethod& method, bool for_declaration, bool type_name_only) { vector method_arguments; for (const unique_ptr& a : method.GetArguments()) { string literal; // b/144943748: CppNameOf FileDescriptor is unique_fd. Don't pass it by // const reference but by value to make it easier for the user to keep // it beyond the scope of the call. unique_fd is a thin wrapper for an // int (fd) so passing by value is not expensive. const bool non_copyable = IsNonCopyableType(a->GetType(), typenames); if (for_declaration) { // Method declarations need typenames, pointers to out params, and variable // names that match the .aidl specification. literal = CppNameOf(a->GetType(), typenames); if (a->IsOut()) { literal = literal + "*"; } else { const auto defined_type = typenames.TryGetDefinedType(a->GetType().GetName()); const bool is_enum = defined_type && defined_type->AsEnumDeclaration() != nullptr; const bool is_primitive = AidlTypenames::IsPrimitiveTypename(a->GetType().GetName()); // We pass in parameters that are not primitives by const reference. // Arrays of primitives are not primitives. if (!(is_primitive || is_enum || non_copyable) || a->GetType().IsArray()) { literal = "const " + literal + "&"; } } if (type_name_only) { literal += " /*" + a->GetName() + "*/"; } else { literal += " " + a->GetName(); } } else { std::string var_name = BuildVarName(*a); if (a->IsOut()) { literal = "&" + var_name; } else if (non_copyable) { literal = "std::move(" + var_name + ")"; } else { literal = var_name; } } method_arguments.push_back(literal); } if (method.GetType().GetName() != "void") { string literal; if (for_declaration) { literal = CppNameOf(method.GetType(), typenames) + "*"; if (type_name_only) { literal += " /*" + string(kReturnVarName) + "*/"; } else { literal += " " + string(kReturnVarName); } } else { literal = string{"&"} + kReturnVarName; } method_arguments.push_back(literal); } return Join(method_arguments, ", "); } void GenerateMethodDecl(CodeWriter& out, const AidlTypenames& types, const AidlMethod& method, const string& clazz) { string clazz_prefix = clazz.empty() ? "" : clazz + "::"; out << "::android::binder::Status " << clazz_prefix << method.GetName() << "(" << GenerateArgList(types, method, /*for_declartion=*/true, /*type_name_only=*/false) << ")"; } void GenerateClientTransaction(CodeWriter& out, const AidlTypenames& typenames, const AidlInterface& interface, const AidlMethod& method, const Options& options) { const string i_name = ClassName(interface, ClassNames::INTERFACE); const string bp_name = GetQualifiedName(interface, ClassNames::CLIENT); const string bn_name = GetQualifiedName(interface, ClassNames::SERVER); GenerateMethodDecl(out, typenames, method, bp_name); out << " {\n"; out.Indent(); // Declare parcels to hold our query and the response. out.Write("%s %s;\n", kAndroidParcelLiteral, kDataVarName); if (interface.IsSensitiveData()) { out.Write("%s.markSensitive();\n", kDataVarName); } out.Write("%s.markForBinder(remoteStrong());\n", kDataVarName); // Even if we're oneway, the transact method still takes a parcel. out.Write("%s %s;\n", kAndroidParcelLiteral, kReplyVarName); // Declare the status_t variable we need for error handling. out.Write("%s %s = %s;\n", kAndroidStatusLiteral, kAndroidStatusVarName, kAndroidStatusOk); // We unconditionally return a Status object. out.Write("%s %s;\n", kBinderStatusLiteral, kStatusVarName); if (options.GenTraces()) { out.Write( "::android::binder::ScopedTrace %s(ATRACE_TAG_AIDL, \"AIDL::cpp::%s::%s::cppClient\");\n", kTraceVarName, interface.GetName().c_str(), method.GetName().c_str()); } if (options.GenLog()) { out << GenLogBeforeExecute(bp_name, method, false /* isServer */, false /* isNdk */); } if (method.IsNew() && ShouldForceDowngradeFor(CommunicationSide::WRITE)) { out << "if (true) {\n"; out.Write(" %s = ::android::UNKNOWN_TRANSACTION;\n", kAndroidStatusVarName); out << "} else {\n"; out.Indent(); } // Add the name of the interface we're hoping to call. out.Write("%s = %s.writeInterfaceToken(getInterfaceDescriptor());\n", kAndroidStatusVarName, kDataVarName); GenerateGotoErrorOnBadStatus(out); for (const auto& a : method.GetArguments()) { const string var_name = ((a->IsOut()) ? "*" : "") + a->GetName(); if (a->IsIn()) { // Serialization looks roughly like: // _aidl_ret_status = _aidl_data.WriteInt32(in_param_name); // if (_aidl_ret_status != ::android::OK) { goto error; } out.Write("%s = %s.%s(%s);\n", kAndroidStatusVarName, kDataVarName, ParcelWriteMethodOf(a->GetType(), typenames).c_str(), ParcelWriteCastOf(a->GetType(), typenames, var_name).c_str()); GenerateGotoErrorOnBadStatus(out); } else if (a->IsOut() && a->GetType().IsDynamicArray()) { // Special case, the length of the out array is written into the parcel. // _aidl_ret_status = _aidl_data.writeVectorSize(&out_param_name); // if (_aidl_ret_status != ::android::OK) { goto error; } out.Write("%s = %s.writeVectorSize(%s);\n", kAndroidStatusVarName, kDataVarName, var_name.c_str()); GenerateGotoErrorOnBadStatus(out); } } // Invoke the transaction on the remote binder and confirm status. std::vector flags; if (method.IsOneway()) flags.push_back("::android::IBinder::FLAG_ONEWAY"); if (interface.IsSensitiveData()) flags.push_back("::android::IBinder::FLAG_CLEAR_BUF"); out.Write("%s = remote()->transact(%s, %s, &%s, %s);\n", kAndroidStatusVarName, GetTransactionIdFor(bn_name, method).c_str(), kDataVarName, kReplyVarName, flags.empty() ? "0" : Join(flags, " | ").c_str()); // If the method is not implemented in the remote side, try to call the // default implementation, if provided. vector arg_names; for (const auto& a : method.GetArguments()) { if (IsNonCopyableType(a->GetType(), typenames)) { arg_names.emplace_back(StringPrintf("std::move(%s)", a->GetName().c_str())); } else { arg_names.emplace_back(a->GetName()); } } if (method.GetType().GetName() != "void") { arg_names.emplace_back(kReturnVarName); } if (method.IsNew() && ShouldForceDowngradeFor(CommunicationSide::WRITE)) { out.Dedent(); out << "}\n"; } out.Write("if (%s == ::android::UNKNOWN_TRANSACTION && %s::getDefaultImpl()) [[unlikely]] {\n", kAndroidStatusVarName, i_name.c_str()); out.Write(" return %s::getDefaultImpl()->%s(%s);\n", i_name.c_str(), method.GetName().c_str(), Join(arg_names, ", ").c_str()); out.Write("}\n"); GenerateGotoErrorOnBadStatus(out); if (!method.IsOneway()) { // Strip off the exception header and fail if we see a remote exception. // _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); // if (_aidl_ret_status != ::android::OK) { goto error; } // if (!_aidl_status.isOk()) { return _aidl_ret_status; } out.Write("%s = %s.readFromParcel(%s);\n", kAndroidStatusVarName, kStatusVarName, kReplyVarName); GenerateGotoErrorOnBadStatus(out); out.Write("if (!%s.isOk()) {\n", kStatusVarName); out.Write(" return %s;\n", kStatusVarName); out.Write("}\n"); } // Type checking should guarantee that nothing below emits code until "return // status" if we are a oneway method, so no more fear of accessing reply. // If the method is expected to return something, read it first by convention. if (method.GetType().GetName() != "void") { out.Write("%s = %s.%s(%s);\n", kAndroidStatusVarName, kReplyVarName, ParcelReadMethodOf(method.GetType(), typenames).c_str(), ParcelReadCastOf(method.GetType(), typenames, kReturnVarName).c_str()); GenerateGotoErrorOnBadStatus(out); } for (const AidlArgument* a : method.GetOutArguments()) { // Deserialization looks roughly like: // _aidl_ret_status = _aidl_reply.ReadInt32(out_param_name); // if (_aidl_status != ::android::OK) { goto _aidl_error; } out.Write("%s = %s.%s(%s);\n", kAndroidStatusVarName, kReplyVarName, ParcelReadMethodOf(a->GetType(), typenames).c_str(), ParcelReadCastOf(a->GetType(), typenames, a->GetName()).c_str()); GenerateGotoErrorOnBadStatus(out); } // If we've gotten to here, one of two things is true: // 1) We've read some bad status_t // 2) We've only read status_t == OK and there was no exception in the // response. // In both cases, we're free to set Status from the status_t and return. out.Write("%s:\n", kErrorLabel); out.Write("%s.setFromStatusT(%s);\n", kStatusVarName, kAndroidStatusVarName); if (options.GenLog()) { out << GenLogAfterExecute(bp_name, interface, method, kStatusVarName, kReturnVarName, false /* isServer */, false /* isNdk */); } out.Write("return %s;\n", kStatusVarName); out.Dedent(); out << "}\n"; } void GenerateClientMetaTransaction(CodeWriter& out, const AidlInterface& interface, const AidlMethod& method, const Options& options) { AIDL_FATAL_IF(method.IsUserDefined(), method); const string bp_name = GetQualifiedName(interface, ClassNames::CLIENT); const string bn_name = GetQualifiedName(interface, ClassNames::SERVER); if (method.GetName() == kGetInterfaceVersion && options.Version() > 0) { // Note: race condition can happen here, but no locking is required // because 1) writing an interger is atomic and 2) this transaction // will always return the same value, i.e., competing threads will // give write the same value to cached_version_. out << "int32_t " << bp_name << "::" << kGetInterfaceVersion << "() {\n" << " if (cached_version_ == -1) {\n" << " ::android::Parcel data;\n" << " ::android::Parcel reply;\n" << " data.writeInterfaceToken(getInterfaceDescriptor());\n" << " ::android::status_t err = remote()->transact(" << GetTransactionIdFor(bn_name, method) << ", data, &reply);\n" << " if (err == ::android::OK) {\n" << " ::android::binder::Status _aidl_status;\n" << " err = _aidl_status.readFromParcel(reply);\n" << " if (err == ::android::OK && _aidl_status.isOk()) {\n" << " cached_version_ = reply.readInt32();\n" << " }\n" << " }\n" << " }\n" << " return cached_version_;\n" << "}\n"; out << "\n"; } if (method.GetName() == kGetInterfaceHash && !options.Hash().empty()) { out << "std::string " << bp_name << "::" << kGetInterfaceHash << "() {\n" << " std::lock_guard lockGuard(cached_hash_mutex_);\n" << " if (cached_hash_ == \"-1\") {\n" << " ::android::Parcel data;\n" << " ::android::Parcel reply;\n" << " data.writeInterfaceToken(getInterfaceDescriptor());\n" << " ::android::status_t err = remote()->transact(" << GetTransactionIdFor(bn_name, method) << ", data, &reply);\n" << " if (err == ::android::OK) {\n" << " ::android::binder::Status _aidl_status;\n" << " err = _aidl_status.readFromParcel(reply);\n" << " if (err == ::android::OK && _aidl_status.isOk()) {\n" << " reply.readUtf8FromUtf16(&cached_hash_);\n" << " }\n" << " }\n" << " }\n" << " return cached_hash_;\n" << "}\n"; } } } // namespace void GenerateClientSource(CodeWriter& out, const AidlInterface& interface, const AidlTypenames& typenames, const Options& options) { vector include_list = { HeaderFile(interface, ClassNames::CLIENT, false), HeaderFile(interface, ClassNames::SERVER, false), // for TRANSACTION_* consts kParcelHeader}; if (options.GenLog()) { include_list.emplace_back("chrono"); include_list.emplace_back("functional"); } for (const auto& path : include_list) { out << "#include <" << path << ">\n"; } out << "\n"; const string i_name = ClassName(interface, ClassNames::INTERFACE); const string bp_name = ClassName(interface, ClassNames::CLIENT); const string q_name = GetQualifiedName(interface, ClassNames::CLIENT); EnterNamespace(out, interface); out << "\n"; // The constructor just passes the IBinder instance up to the super // class. out << q_name << "::" << bp_name << "(const ::android::sp<::android::IBinder>& _aidl_impl)\n"; out << " : BpInterface<" + i_name + ">(_aidl_impl){\n"; out << "}\n"; out << "\n"; if (options.GenLog()) { out << "std::function " << q_name << "::logFunc;\n"; out << "\n"; } // Clients define a method per transaction. for (const auto& method : interface.GetMethods()) { if (method->IsUserDefined()) { GenerateClientTransaction(out, typenames, interface, *method, options); } else { GenerateClientMetaTransaction(out, interface, *method, options); } out << "\n"; } LeaveNamespace(out, interface); } namespace { void GenerateConstantDefinitions(CodeWriter& out, const AidlDefinedType& type, const AidlTypenames& typenames, const string& template_decl, const string& q_name) { for (const auto& constant : type.GetConstantDeclarations()) { const AidlConstantValue& value = constant->GetValue(); if (value.GetType() != AidlConstantValue::Type::STRING) continue; std::string cpp_type = CppNameOf(constant->GetType(), typenames); out << template_decl; out << "const " << cpp_type << "& " << q_name << "::" << constant->GetName() << "() {\n"; out << " static const " << cpp_type << " value(" << constant->ValueString(ConstantValueDecorator) << ");\n"; out << " return value;\n"; out << "}\n"; } } void GenerateConstantDeclarations(CodeWriter& out, const AidlDefinedType& type, const AidlTypenames& typenames) { for (const auto& constant : type.GetConstantDeclarations()) { const AidlTypeSpecifier& type = constant->GetType(); const auto cpp_type = CppNameOf(type, typenames); if (type.Signature() == "String") { out << "static const " << cpp_type << "& " << constant->GetName() << "()"; GenerateDeprecated(out, *constant); out << ";\n"; } else if (type.Signature() == "float" || type.Signature() == "double") { out << "static constexpr " << cpp_type << " " << constant->GetName(); GenerateDeprecated(out, *constant); out << " = " << constant->ValueString(ConstantValueDecorator) << ";\n"; } else { out << "enum : " << cpp_type << " { " << constant->GetName(); GenerateDeprecated(out, *constant); out << " = " << constant->ValueString(ConstantValueDecorator) << " };\n"; } } } void GenerateServerTransaction(CodeWriter& out, const AidlInterface& interface, const AidlMethod& method, const AidlTypenames& typenames, const Options& options) { const string bn_name = GetQualifiedName(interface, ClassNames::SERVER); if (method.IsNew() && ShouldForceDowngradeFor(CommunicationSide::READ)) { out << "if (true) {\n"; out << " _aidl_ret_status = ::android::UNKNOWN_TRANSACTION;\n"; out << " break;\n"; out << "}\n"; } // Declare all the parameters now. In the common case, we expect no errors // in serialization. for (const unique_ptr& a : method.GetArguments()) { out.Write("%s %s;\n", CppNameOf(a->GetType(), typenames).c_str(), BuildVarName(*a).c_str()); } // Declare a variable to hold the return value. if (method.GetType().GetName() != "void") { out.Write("%s %s;\n", CppNameOf(method.GetType(), typenames).c_str(), kReturnVarName); } // Check that the client is calling the correct interface. out.Write("if (!(%s.checkInterface(this))) {\n", kDataVarName); out.Write(" %s = ::android::BAD_TYPE;\n", kAndroidStatusVarName); out.Write(" break;\n"); out.Write("}\n"); if (options.GenTraces()) { out.Write( "::android::binder::ScopedTrace %s(ATRACE_TAG_AIDL, \"AIDL::cpp::%s::%s::cppServer\");\n", kTraceVarName, interface.GetName().c_str(), method.GetName().c_str()); } if (interface.EnforceExpression() || method.GetType().EnforceExpression()) { out.Write("#error Permission checks not implemented for the cpp backend\n"); } // Deserialize each "in" parameter to the transaction. for (const auto& a: method.GetArguments()) { // Deserialization looks roughly like: // _aidl_ret_status = _aidl_data.ReadInt32(&in_param_name); // if (_aidl_ret_status != ::android::OK) { break; } const string& var_name = "&" + BuildVarName(*a); if (a->IsIn()) { out.Write("%s = %s.%s(%s);\n", kAndroidStatusVarName, kDataVarName, ParcelReadMethodOf(a->GetType(), typenames).c_str(), ParcelReadCastOf(a->GetType(), typenames, var_name).c_str()); GenerateBreakOnStatusNotOk(out); } else if (a->IsOut() && a->GetType().IsDynamicArray()) { // Special case, the length of the out array is written into the parcel. // _aidl_ret_status = _aidl_data.resizeOutVector(&out_param_name); // if (_aidl_ret_status != ::android::OK) { break; } out.Write("%s = %s.resizeOutVector(%s);\n", kAndroidStatusVarName, kDataVarName, var_name.c_str()); GenerateBreakOnStatusNotOk(out); } } if (options.GenLog()) { out << GenLogBeforeExecute(bn_name, method, true /* isServer */, false /* isNdk */); } if (!method.GetArguments().empty() && options.GetMinSdkVersion() >= SDK_VERSION_Tiramisu) { out << "if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) {\n"; out << " _aidl_ret_status = st.writeToParcel(_aidl_reply);\n"; out << " break;\n"; out << "}\n"; } // Call the actual method. This is implemented by the subclass. out.Write("%s %s(%s(%s));\n", kBinderStatusLiteral, kStatusVarName, method.GetName().c_str(), GenerateArgList(typenames, method, /*for_declaration=*/false, /*type_name_only=*/false) .c_str()); if (options.GenLog()) { out << GenLogAfterExecute(bn_name, interface, method, kStatusVarName, kReturnVarName, true /* isServer */, false /* isNdk */); } // Write exceptions during transaction handling to parcel. if (!method.IsOneway()) { out.Write("%s = %s.writeToParcel(%s);\n", kAndroidStatusVarName, kStatusVarName, kReplyVarName); GenerateBreakOnStatusNotOk(out); out.Write("if (!%s.isOk()) {\n", kStatusVarName); out.Write(" break;\n"); out.Write("}\n"); } // If we have a return value, write it first. if (method.GetType().GetName() != "void") { out.Write("%s = %s->%s(%s);\n", kAndroidStatusVarName, kReplyVarName, ParcelWriteMethodOf(method.GetType(), typenames).c_str(), ParcelWriteCastOf(method.GetType(), typenames, kReturnVarName).c_str()); GenerateBreakOnStatusNotOk(out); } // Write each out parameter to the reply parcel. for (const AidlArgument* a : method.GetOutArguments()) { // Serialization looks roughly like: // _aidl_ret_status = data.WriteInt32(out_param_name); // if (_aidl_ret_status != ::android::OK) { break; } out.Write("%s = %s->%s(%s);\n", kAndroidStatusVarName, kReplyVarName, ParcelWriteMethodOf(a->GetType(), typenames).c_str(), ParcelWriteCastOf(a->GetType(), typenames, BuildVarName(*a)).c_str()); GenerateBreakOnStatusNotOk(out); } } void GenerateServerMetaTransaction(CodeWriter& out, const AidlInterface& interface, const AidlMethod& method, const Options& options) { AIDL_FATAL_IF(method.IsUserDefined(), method); string iface = ClassName(interface, ClassNames::INTERFACE); if (method.GetName() == kGetInterfaceVersion && options.Version() > 0) { out << "_aidl_data.checkInterface(this);\n" << "_aidl_reply->writeNoException();\n"; out << "_aidl_reply->writeInt32(" << iface << "::VERSION);\n"; } if (method.GetName() == kGetInterfaceHash && !options.Hash().empty()) { out << "_aidl_data.checkInterface(this);\n" << "_aidl_reply->writeNoException();\n"; out << "_aidl_reply->writeUtf8AsUtf16(" << iface << "::HASH);\n"; } } } // namespace void GenerateServerOnTransact(CodeWriter& out, const AidlInterface& interface, const AidlTypenames& typenames, const Options& options) { const string bn_name = ClassName(interface, ClassNames::SERVER); const string q_name = GetQualifiedName(interface, ClassNames::SERVER); bool deprecated = interface.IsDeprecated() || std::any_of(interface.GetMethods().begin(), interface.GetMethods().end(), [](const auto& m) { return m->IsDeprecated(); }); if (deprecated) { out << "#pragma clang diagnostic push\n"; out << "#pragma clang diagnostic ignored \"-Wdeprecated\"\n"; out << "\n"; } out.Write("%s %s::onTransact(uint32_t %s, const %s& %s, %s* %s, uint32_t %s) {\n", kAndroidStatusLiteral, q_name.c_str(), kCodeVarName, kAndroidParcelLiteral, kDataVarName, kAndroidParcelLiteral, kReplyVarName, kFlagsVarName); out.Indent(); // Declare the status_t variable out.Write("%s %s = %s;\n", kAndroidStatusLiteral, kAndroidStatusVarName, kAndroidStatusOk); // Add the all important switch statement out.Write("switch (%s) {\n", kCodeVarName); // The switch statement has a case statement for each transaction code. for (const auto& method : interface.GetMethods()) { out.Write("case %s:\n", GetTransactionIdFor(bn_name, *method).c_str()); out << "{\n"; out.Indent(); if (method->IsUserDefined()) { GenerateServerTransaction(out, interface, *method, typenames, options); } else { GenerateServerMetaTransaction(out, interface, *method, options); } out.Dedent(); out << "}\n"; out << "break;\n"; } // The switch statement has a default case which defers to the super class. // The superclass handles a few pre-defined transactions. out << "default:\n"; out << "{\n"; out.Write(" %s = ::android::BBinder::onTransact(%s, %s, %s, %s);\n", kAndroidStatusVarName, kCodeVarName, kDataVarName, kReplyVarName, kFlagsVarName); out << "}\n"; out << "break;\n"; out << "}\n"; // switch // If we saw a null reference, we can map that to an appropriate exception. out.Write("if (%s == ::android::UNEXPECTED_NULL) {\n", kAndroidStatusVarName); out.Write(" %s = %s::fromExceptionCode(%s::EX_NULL_POINTER).writeOverParcel(%s);\n", kAndroidStatusVarName, kBinderStatusLiteral, kBinderStatusLiteral, kReplyVarName); out.Write("}\n"); // Finally, the server's onTransact method just returns a status code. out.Write("return %s;\n", kAndroidStatusVarName); out.Dedent(); out << "}\n"; out << "\n"; if (deprecated) { out << "#pragma clang diagnostic pop\n"; out << "\n"; } } void GenerateServerSource(CodeWriter& out, const AidlInterface& interface, const AidlTypenames& typenames, const Options& options) { vector include_list{ HeaderFile(interface, ClassNames::SERVER, false), kParcelHeader, kStabilityHeader, }; if (options.GenLog()) { include_list.emplace_back("chrono"); include_list.emplace_back("functional"); } for (const auto& include : include_list) { out << "#include <" << include << ">\n"; } out << "\n"; const string i_name = ClassName(interface, ClassNames::INTERFACE); const string bn_name = ClassName(interface, ClassNames::SERVER); const string q_name = GetQualifiedName(interface, ClassNames::SERVER); EnterNamespace(out, interface); out << "\n"; // constructor out.Write("%s::%s()\n", q_name.c_str(), bn_name.c_str()); out << "{\n"; out.Indent(); if (interface.IsVintfStability()) { out << "::android::internal::Stability::markVintf(this);\n"; } else { out << "::android::internal::Stability::markCompilationUnit(this);\n"; } out.Dedent(); out << "}\n"; out << "\n"; GenerateServerOnTransact(out, interface, typenames, options); if (options.Version() > 0) { out << "int32_t " << q_name << "::" << kGetInterfaceVersion << "() {\n" << " return " << i_name << "::VERSION;\n" << "}\n"; } if (!options.Hash().empty()) { out << "std::string " << q_name << "::" << kGetInterfaceHash << "() {\n" << " return " << i_name << "::HASH;\n" << "}\n"; } if (options.GenLog()) { out << "std::function " << q_name << "::logFunc;\n"; } LeaveNamespace(out, interface); } void GenerateInterfaceSource(CodeWriter& out, const AidlInterface& interface, const AidlTypenames& typenames, const Options&) { out << "#include <" << HeaderFile(interface, ClassNames::RAW, false) << ">\n"; out << "#include <" << HeaderFile(interface, ClassNames::CLIENT, false) << ">\n"; EnterNamespace(out, interface); if (auto parent = interface.GetParentType(); parent) { out << fmt::format("DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_NESTED_INTERFACE({}, {}, \"{}\")\n", GetQualifiedName(*parent, ClassNames::MAYBE_INTERFACE), ClassName(interface, ClassNames::BASE), interface.GetDescriptor()); } else { out << fmt::format("DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE({}, \"{}\")\n", ClassName(interface, ClassNames::BASE), interface.GetDescriptor()); } GenerateConstantDefinitions(out, interface, typenames, /*template_decl=*/"", ClassName(interface, ClassNames::INTERFACE)); LeaveNamespace(out, interface); } void GenerateClientClassDecl(CodeWriter& out, const AidlInterface& interface, const AidlTypenames& typenames, const Options& options) { const string bp_name = ClassName(interface, ClassNames::CLIENT); const string iface = ClassName(interface, ClassNames::INTERFACE); out << "class"; GenerateDeprecated(out, interface); out << " " << bp_name << " : public ::android::BpInterface<" << iface << "> {\n"; out << "public:\n"; out.Indent(); out << "explicit " << bp_name << "(const ::android::sp<::android::IBinder>& " << kImplVarName << ");\n"; out << "virtual ~" << bp_name << "() = default;\n"; for (const auto& method : interface.GetMethods()) { if (method->IsUserDefined()) { GenerateMethodDecl(out, typenames, *method, /*clazz=*/""); out << " override"; GenerateDeprecated(out, *method); out << ";\n"; } else if (method->GetName() == kGetInterfaceVersion && options.Version() > 0) { out << "int32_t " << method->GetName() << "() override;\n"; } else if (method->GetName() == kGetInterfaceHash && !options.Hash().empty()) { out << "std::string " << method->GetName() << "() override;\n"; } } if (options.GenLog()) { out << kTransactionLogStruct; out << "static std::function logFunc;\n"; } out.Dedent(); if (options.Version() > 0 || !options.Hash().empty()) { out << "private:\n"; out.Indent(); if (options.Version() > 0) { out << "int32_t cached_version_ = -1;\n"; } if (!options.Hash().empty()) { out << "std::string cached_hash_ = \"-1\";\n"; out << "std::mutex cached_hash_mutex_;\n"; } out.Dedent(); } out << "}; // class " << bp_name << "\n"; } void GenerateClientHeader(CodeWriter& out, const AidlInterface& interface, const AidlTypenames& typenames, const Options& options) { out << "#pragma once\n\n"; out << "#include <" << kIBinderHeader << ">\n"; out << "#include <" << kIInterfaceHeader << ">\n"; out << "#include \n"; out << "#include <" << HeaderFile(interface, ClassNames::RAW, false) << ">\n"; if (options.GenLog()) { out << "#include \n"; // for std::function out << "#include \n"; } out << "\n"; EnterNamespace(out, interface); GenerateClientClassDecl(out, interface, typenames, options); LeaveNamespace(out, interface); } // Some interfaces are declared in .aidl files, but defined elsewhere. // These interfaces can not have Delegators and need to be avoided. // TODO(b/242920522) These should all be defined in .aidl files. bool isKnownUndefinedInterface(const std::string& canonicalName) { static const auto* kKnownUndefinedInterfaces = new std::set{ "android.hardware.ICamera", "android.hardware.ICameraClient", "android.IOMXNode", "android.IMediaExtractor", "android.IDataSource", }; return kKnownUndefinedInterfaces->find(canonicalName) != kKnownUndefinedInterfaces->end(); }; bool isDelegateable(const AidlTypeSpecifier& type) { return type.GetDefinedType() && type.GetDefinedType()->AsInterface() && !isKnownUndefinedInterface(type.GetDefinedType()->GetCanonicalName()) && !type.IsArray(); } void wrapDelegate(CodeWriter& out, const std::string& argName, const AidlTypeSpecifier& type, bool in) { const std::string argRef = in ? argName : "*" + argName; const std::string targetArgName = in ? "_" + argName : argName; const std::string targetArgRef = in ? targetArgName : "*" + targetArgName; // input binders need local variables for each arg to pass to the delegate // because the parameters are const if (in) { out << "::android::sp<::" << Join(type.GetSplitName(), "::") << "Delegator> " << targetArgName << ";\n"; } out << "if (" << argRef << ") {\n"; out.Indent(); out << targetArgRef << " = ::android::sp<::" << Join(type.GetSplitName(), "::") << "Delegator>::cast(delegate(" << argRef << "));\n"; out.Dedent(); out << "}\n"; } void GenerateServerClassDecl(CodeWriter& out, const AidlInterface& interface, const AidlTypenames& typenames, const Options& options) { const string bn_name = ClassName(interface, ClassNames::SERVER); const string iface = ClassName(interface, ClassNames::INTERFACE); out << "class"; GenerateDeprecated(out, interface); out << " " << bn_name << " : public " << "::android::BnInterface<" << iface << "> {\n"; out << "public:\n"; out.Indent(); for (const auto& method : interface.GetMethods()) { out << "static constexpr uint32_t TRANSACTION_" << method->GetName() << " = " << "::android::IBinder::FIRST_CALL_TRANSACTION + " << std::to_string(method->GetId()) << ";\n"; } out << "explicit " << bn_name << "();\n"; out << fmt::format("{} onTransact(uint32_t {}, const {}& {}, {}* {}, uint32_t {}) override;\n", kAndroidStatusLiteral, kCodeVarName, kAndroidParcelLiteral, kDataVarName, kAndroidParcelLiteral, kReplyVarName, kFlagsVarName); if (options.Version() > 0) { out << "int32_t " << kGetInterfaceVersion << "();\n"; } if (!options.Hash().empty()) { out << "std::string " << kGetInterfaceHash << "();\n"; } if (options.GenLog()) { out << kTransactionLogStruct; out << "static std::function logFunc;\n"; } out.Dedent(); out << "}; // class " << bn_name << "\n\n"; std::string d_name = ClassName(interface, ClassNames::DELEGATOR_IMPL); out << "class"; GenerateDeprecated(out, interface); out << " " << d_name << " : public " << bn_name << " {\n"; out << "public:\n"; out.Indent(); out << "explicit " << d_name << "(" << StringPrintf("const ::android::sp<%s> &impl", iface.c_str()) << ") " << StringPrintf(": %s(impl)", kDelegateImplVarName) << " {}\n\n"; out << "::android::sp<" << iface << "> getImpl() { return " << kDelegateImplVarName << "; }\n"; for (const auto& method : interface.GetMethods()) { if (method->IsUserDefined()) { GenerateMethodDecl(out, typenames, *method, /*clazz=*/""); out << " override"; GenerateDeprecated(out, *method); std::vector args; // arg name, type std::vector> outBinders; std::vector> inBinders; for (const auto& arg : method->GetArguments()) { if (isDelegateable(arg->GetType())) { if (arg->IsOut()) { outBinders.push_back({arg->GetName(), arg->GetType()}); } else if (arg->IsIn()) { inBinders.push_back({arg->GetName(), arg->GetType()}); } else { AIDL_FATAL(*arg) << "inout interface?"; } AIDL_FATAL_IF(!arg->IsIn() && !arg->IsOut(), *arg) << "Not in or out?"; args.push_back("_" + arg->GetName()); } else { if (IsNonCopyableType(arg->GetType(), typenames)) { args.push_back(StringPrintf("std::move(%s)", arg->GetName().c_str())); } else { args.push_back(arg->GetName()); } } } if (method->GetType().GetName() != "void") { if (isDelegateable(method->GetType())) { outBinders.push_back({kReturnVarName, method->GetType()}); } args.push_back(kReturnVarName); } out << " {\n"; out.Indent(); for (const auto binder : inBinders) { wrapDelegate(out, binder.first, binder.second, true); } if (outBinders.empty()) { out << "return " << kDelegateImplVarName << "->" << method->GetName() << "(" << base::Join(args, ", ") << ");\n"; } else { out << "auto _status = " << kDelegateImplVarName << "->" << method->GetName() << "(" << base::Join(args, ", ") << ");\n"; for (const auto& binder : outBinders) { wrapDelegate(out, binder.first, binder.second, false); } out << "return _status;\n"; } out.Dedent(); out << "}\n"; } else if (method->GetName() == kGetInterfaceVersion && options.Version()) { out << "int32_t " << kGetInterfaceVersion << "()" << " override {\n"; out.Indent(); out << "int32_t _delegator_ver = " << bn_name << "::" << kGetInterfaceVersion << "();\n"; out << "int32_t _impl_ver = " << kDelegateImplVarName << "->" << kGetInterfaceVersion << "();\n"; out << "return _delegator_ver < _impl_ver ? _delegator_ver : _impl_ver;\n"; out.Dedent(); out << "}\n"; } else if (method->GetName() == kGetInterfaceHash && !options.Hash().empty()) { out << "std::string " << kGetInterfaceHash << "()" << " override {\n"; out << " return " << kDelegateImplVarName << "->" << kGetInterfaceHash << "();\n"; out << "}\n"; } } out.Dedent(); out << "private:\n"; out.Indent(); out << "::android::sp<" << iface << "> " << kDelegateImplVarName << ";\n"; out.Dedent(); out << "}; // class " << d_name << "\n"; } // Collect all includes for the type's server header. Nested types are visited as well via // VisitTopDown. void GenerateServerHeaderIncludes(CodeWriter& out, const AidlDefinedType& defined_type, const AidlTypenames& typenames, const Options& options) { struct Visitor : AidlVisitor { const AidlTypenames& typenames; const Options& options; std::set includes; Visitor(const AidlTypenames& typenames, const Options& options) : typenames(typenames), options(options) {} // Collect includes for each type reference void Visit(const AidlTypeSpecifier& type) override { // Add Bn* header files for types used in this header. The *Delegator // definitions require them. const auto defined_type = type.GetDefinedType(); if (defined_type && defined_type->AsInterface()) { if (!isKnownUndefinedInterface(defined_type->GetCanonicalName())) { includes.insert(HeaderFile(*defined_type, ClassNames::SERVER, /*use_os_sep=*/false)); } } } // Collect implementation-specific includes for each type definition void Visit(const AidlInterface& iface) override { includes.insert(HeaderFile(iface, ClassNames::SERVER, false)); } } v(typenames, options); VisitTopDown(v, defined_type); v.includes.insert(kBinderDelegateHeader); for (const auto& path : v.includes) { out << "#include <" << path << ">\n"; } out << "\n"; } void GenerateServerHeader(CodeWriter& out, const AidlInterface& interface, const AidlTypenames& typenames, const Options& options) { out << "#pragma once\n\n"; out << "#include \n"; out << "#include <" << HeaderFile(interface, ClassNames::RAW, false) << ">\n"; if (options.GenLog()) { out << "#include \n"; // for std::function out << "#include \n"; } GenerateServerHeaderIncludes(out, interface, typenames, options); out << "\n"; EnterNamespace(out, interface); GenerateServerClassDecl(out, interface, typenames, options); LeaveNamespace(out, interface); } void GenerateClassDecl(CodeWriter& out, const AidlDefinedType& defined_type, const AidlTypenames& typenames, const Options& options); void GenerateNestedTypeDecls(CodeWriter& out, const AidlDefinedType& type, const AidlTypenames& typenames, const Options& options) { auto visit = [&](const auto& nested) { GenerateClassDecl(out, nested, typenames, options); }; AIDL_FATAL_IF(!TopologicalVisit(type.GetNestedTypes(), visit), type) << "Cycle detected."; } void GenerateInterfaceClassDecl(CodeWriter& out, const AidlInterface& interface, const AidlTypenames& typenames, const Options& options) { const string i_name = ClassName(interface, ClassNames::INTERFACE); out << "class " << ClassName(interface, ClassNames::DELEGATOR_IMPL) << ";\n\n"; out << "class"; GenerateDeprecated(out, interface); out << " " << i_name << " : public ::android::IInterface {\n"; out << "public:\n"; out.Indent(); out << "typedef " << ClassName(interface, ClassNames::DELEGATOR_IMPL) << " DefaultDelegator;\n"; out << "DECLARE_META_INTERFACE(" << ClassName(interface, ClassNames::BASE) << ")\n"; if (options.Version() > 0) { if (options.IsLatestUnfrozenVersion()) { out << "static inline const int32_t VERSION = true ? " << std::to_string(options.PreviousVersion()) << " : " << std::to_string(options.Version()) << ";\n"; } else { out << "static inline const int32_t VERSION = " << std::to_string(options.Version()) << ";\n"; } } if (!options.Hash().empty()) { if (options.IsLatestUnfrozenVersion()) { out << "static inline const std::string HASH = true ? \"" << options.PreviousHash() << "\" : \"" << options.Hash() << "\";\n"; } else { out << "static inline const std::string HASH = \"" << options.Hash() << "\";\n"; } } GenerateNestedTypeDecls(out, interface, typenames, options); GenerateConstantDeclarations(out, interface, typenames); for (const auto& method : interface.GetMethods()) { if (method->IsUserDefined()) { out << "virtual "; GenerateMethodDecl(out, typenames, *method, /*clazz=*/""); GenerateDeprecated(out, *method); out << " = 0;\n"; } else if (method->GetName() == kGetInterfaceVersion && options.Version() > 0) { out << "virtual int32_t " << method->GetName() << "() = 0;\n"; } else if (method->GetName() == kGetInterfaceHash && !options.Hash().empty()) { out << "virtual std::string " << method->GetName() << "() = 0;\n"; } } out.Dedent(); out << "}; // class " << i_name << "\n"; out << "\n"; // Implement the default impl class. const string default_impl = ClassName(interface, ClassNames::DEFAULT_IMPL); out << "class"; GenerateDeprecated(out, interface); out << " " << default_impl << " : public " << i_name << " {\n"; out << "public:\n"; out.Indent(); // onAsBinder returns nullptr as this interface is not associated with a // real binder. out << "::android::IBinder* onAsBinder() override {\n" << " return nullptr;\n" << "}\n"; // Each interface method by default returns UNKNOWN_TRANSACTION with is // the same status that is returned by transact() when the method is // not implemented in the server side. In other words, these default // methods do nothing; they only exist to aid making a real default // impl class without having to override all methods in an interface. for (const auto& method : interface.GetMethods()) { if (method->IsUserDefined()) { out << "::android::binder::Status " << method->GetName() << "(" << GenerateArgList(typenames, *method, /*for_declaration=*/true, /*type_name_only=*/true) << ") override"; GenerateDeprecated(out, *method); out << " {\n" << " return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION);\n" << "}\n"; } else if (method->GetName() == kGetInterfaceVersion && options.Version() > 0) { out << "int32_t " << kGetInterfaceVersion << "() override {\n" << " return 0;\n" << "}\n"; } else if (method->GetName() == kGetInterfaceHash && !options.Hash().empty()) { out << "std::string " << kGetInterfaceHash << "() override {\n" << " return \"\";\n" << "}\n"; } } out.Dedent(); out << "}; // class " << default_impl << "\n"; // When an interface is nested, every class should be defined together here // because we don't have separate headers for them. // (e.g. IFoo, IFooDefault, BpFoo, BnFoo, IFooDelegator) if (interface.GetParentType()) { GenerateClientClassDecl(out, interface, typenames, options); GenerateServerClassDecl(out, interface, typenames, options); } } void GenerateReadFromParcel(CodeWriter& out, const AidlStructuredParcelable& parcel, const AidlTypenames& typenames) { out << "::android::status_t _aidl_ret_status = ::android::OK;\n"; out << "size_t _aidl_start_pos = _aidl_parcel->dataPosition();\n"; out << "int32_t _aidl_parcelable_raw_size = 0;\n"; out << "_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size);\n"; out << "if (((_aidl_ret_status) != (::android::OK))) {\n"; out << " return _aidl_ret_status;\n"; out << "}\n"; out << "if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE;\n"; out << "size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size);\n"; out << "if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE;\n"; for (const auto& variable : parcel.GetFields()) { string method = ParcelReadMethodOf(variable->GetType(), typenames); string arg = ParcelReadCastOf(variable->GetType(), typenames, "&" + variable->GetName()); out << "if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) {\n"; out << " _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);\n"; out << " return _aidl_ret_status;\n"; out << "}\n"; if (variable->IsNew() && ShouldForceDowngradeFor(CommunicationSide::READ)) { out << "if (false) {\n"; out.Indent(); } out << "_aidl_ret_status = _aidl_parcel->" << method << "(" << arg << ");\n"; out << "if (((_aidl_ret_status) != (::android::OK))) {\n"; out << " return _aidl_ret_status;\n"; out << "}\n"; if (variable->IsNew() && ShouldForceDowngradeFor(CommunicationSide::READ)) { out.Dedent(); out << "}\n"; } } out << "_aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size);\n"; out << "return _aidl_ret_status;\n"; } void GenerateWriteToParcel(CodeWriter& out, const AidlStructuredParcelable& parcel, const AidlTypenames& typenames) { out << "::android::status_t _aidl_ret_status = ::android::OK;\n"; out << "size_t _aidl_start_pos = " << kParcelVarName << "->dataPosition();\n"; out << kParcelVarName << "->writeInt32(0);\n"; for (const auto& variable : parcel.GetFields()) { string method = ParcelWriteMethodOf(variable->GetType(), typenames); string arg = ParcelWriteCastOf(variable->GetType(), typenames, variable->GetName()); if (variable->IsNew() && ShouldForceDowngradeFor(CommunicationSide::WRITE)) { out << "if (false) {\n"; out.Indent(); } out << "_aidl_ret_status = " << kParcelVarName << "->" << method << "(" << arg << ");\n"; out << "if (((_aidl_ret_status) != (::android::OK))) {\n"; out << " return _aidl_ret_status;\n"; out << "}\n"; if (variable->IsNew() && ShouldForceDowngradeFor(CommunicationSide::WRITE)) { out.Dedent(); out << "}\n"; } } out << "size_t _aidl_end_pos = " << kParcelVarName << "->dataPosition();\n"; out << kParcelVarName << "->setDataPosition(_aidl_start_pos);\n"; out << kParcelVarName << "->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos));\n"; out << kParcelVarName << "->setDataPosition(_aidl_end_pos);\n"; out << "return _aidl_ret_status;\n"; } ParcelWriterContext GetParcelWriterContext(const AidlTypenames& typenames) { return ParcelWriterContext{ .status_type = kAndroidStatusLiteral, .status_ok = kAndroidStatusOk, .status_bad = kAndroidStatusBadValue, .read_func = [&](CodeWriter& out, const string& var, const AidlTypeSpecifier& type) { out << fmt::format("{}->{}({})", kParcelVarName, ParcelReadMethodOf(type, typenames), ParcelReadCastOf(type, typenames, "&" + var)); }, .write_func = [&](CodeWriter& out, const string& value, const AidlTypeSpecifier& type) { out << fmt::format("{}->{}({})", kParcelVarName, ParcelWriteMethodOf(type, typenames), ParcelWriteCastOf(type, typenames, value)); }, }; } void GenerateReadFromParcel(CodeWriter& out, const AidlUnionDecl& decl, const AidlTypenames& typenames) { UnionWriter uw{decl, typenames, &CppNameOf, &ConstantValueDecorator}; uw.ReadFromParcel(out, GetParcelWriterContext(typenames)); } void GenerateWriteToParcel(CodeWriter& out, const AidlUnionDecl& decl, const AidlTypenames& typenames) { UnionWriter uw{decl, typenames, &CppNameOf, &ConstantValueDecorator}; uw.WriteToParcel(out, GetParcelWriterContext(typenames)); } void GenerateParcelFields(CodeWriter& out, const AidlStructuredParcelable& decl, const AidlTypenames& typenames) { for (const auto& variable : decl.GetFields()) { const auto& type = variable->GetType(); std::string cpp_type = CppNameOf(type, typenames); out << cpp_type; GenerateDeprecated(out, *variable); out << " " << variable->GetName(); if (variable->GetDefaultValue()) { out << " = " << variable->ValueString(ConstantValueDecorator); } else { // Some types needs to be explicitly initialized even when no default value is set. // - ParcelableHolder should be initialized with stability // - enum should be zero initialized, otherwise the value will be indeterminate // - fixed-size arrays should be initialized, otherwise the value will be indeterminate if (type.GetName() == "ParcelableHolder") { if (decl.IsVintfStability()) { out << " { ::android::Parcelable::Stability::STABILITY_VINTF }"; } else { out << " { ::android::Parcelable::Stability::STABILITY_LOCAL }"; } } else if (typenames.GetEnumDeclaration(type) && !type.IsArray()) { out << " = " << cpp_type << "(0)"; } else if (type.IsFixedSizeArray() && !type.IsNullable()) { out << " = {{}}"; } } out << ";\n"; } } void GenerateParcelFields(CodeWriter& out, const AidlUnionDecl& decl, const AidlTypenames& typenames) { UnionWriter uw{decl, typenames, &CppNameOf, &ConstantValueDecorator}; uw.PublicFields(out); } template void GenerateParcelClassDecl(CodeWriter& out, const ParcelableType& parcel, const AidlTypenames& typenames, const Options& options) { const string clazz = parcel.GetName(); ClangDiagnosticIgnoreDeprecated guard(out, HasDeprecatedField(parcel)); out << TemplateDecl(parcel); out << "class"; GenerateDeprecated(out, parcel); out << " " << clazz << " : public ::android::Parcelable {\n"; out << "public:\n"; out.Indent(); GenerateNestedTypeDecls(out, parcel, typenames, options); GenerateParcelFields(out, parcel, typenames); GenerateParcelableComparisonOperators(out, parcel); GenerateConstantDeclarations(out, parcel, typenames); if (parcel.IsVintfStability()) { out << "::android::Parcelable::Stability getStability() const override { return " "::android::Parcelable::Stability::STABILITY_VINTF; }\n"; } out << kAndroidStatusLiteral << " readFromParcel(const ::android::Parcel* _aidl_parcel) final;\n"; out << kAndroidStatusLiteral << " writeToParcel(::android::Parcel* _aidl_parcel) const final;\n"; const string canonical_name = parcel.GetCanonicalName(); out << "static const ::android::String16& getParcelableDescriptor() {\n" << " static const ::android::StaticString16 DESCRIPTOR (u\"" << canonical_name << "\");\n" << " return DESCRIPTOR;\n" << "}\n"; GenerateToString(out, parcel); out.Dedent(); if (auto decl = AidlCast(parcel); decl) { out << "private:\n"; out.Indent(); UnionWriter uw{*decl, typenames, &CppNameOf, &ConstantValueDecorator}; uw.PrivateFields(out); out.Dedent(); } out << "}; // class " << clazz << "\n"; } template void GenerateParcelSource(CodeWriter& out, const T& parcel, const AidlTypenames& typenames, const Options&) { string q_name = GetQualifiedName(parcel); if (parcel.IsGeneric()) { q_name += "<" + Join(parcel.GetTypeParameters(), ",") + ">"; } out << "#include <" << CppHeaderForType(parcel) << ">\n\n"; EnterNamespace(out, parcel); GenerateConstantDefinitions(out, parcel, typenames, TemplateDecl(parcel), q_name); { ClangDiagnosticIgnoreDeprecated guard(out, HasDeprecatedField(parcel)); out << TemplateDecl(parcel); out << "::android::status_t " << q_name << "::readFromParcel(const ::android::Parcel* " << kParcelVarName << ") {\n"; out.Indent(); GenerateReadFromParcel(out, parcel, typenames); out.Dedent(); out << "}\n"; out << TemplateDecl(parcel); out << "::android::status_t " << q_name << "::writeToParcel(::android::Parcel* " << kParcelVarName << ") const {\n"; out.Indent(); GenerateWriteToParcel(out, parcel, typenames); out.Dedent(); out << "}\n"; } LeaveNamespace(out, parcel); } void GenerateEnumClassDecl(CodeWriter& out, const AidlEnumDeclaration& enum_decl, const AidlTypenames& typenames) { cpp::GenerateEnumClassDecl(out, enum_decl, CppNameOf(enum_decl.GetBackingType(), typenames), ConstantValueDecorator); } void GenerateClassDecl(CodeWriter& out, const AidlDefinedType& defined_type, const AidlTypenames& typenames, const Options& options) { if (auto iface = AidlCast(defined_type); iface) { GenerateInterfaceClassDecl(out, *iface, typenames, options); } else if (auto parcelable = AidlCast(defined_type); parcelable) { GenerateParcelClassDecl(out, *parcelable, typenames, options); } else if (auto union_decl = AidlCast(defined_type); union_decl) { GenerateParcelClassDecl(out, *union_decl, typenames, options); } else if (auto enum_decl = AidlCast(defined_type); enum_decl) { GenerateEnumClassDecl(out, *enum_decl, typenames); } else { AIDL_FATAL(defined_type) << "Unrecognized type sent for CPP generation."; } } } // namespace internals using namespace internals; // Collect all includes for the type's header. Nested types are visited as well via VisitTopDown. void GenerateHeaderIncludes(CodeWriter& out, const AidlDefinedType& defined_type, const AidlTypenames& typenames, const Options& options) { struct Visitor : AidlVisitor { const AidlTypenames& typenames; const Options& options; std::set includes; Visitor(const AidlTypenames& typenames, const Options& options) : typenames(typenames), options(options) {} // Collect includes for each type reference including built-in type void Visit(const AidlTypeSpecifier& type) override { cpp::AddHeaders(type, typenames, &includes); } // Collect implementation-specific includes for each type definition void Visit(const AidlInterface& iface) override { includes.insert(kIBinderHeader); // IBinder includes.insert(kIInterfaceHeader); // IInterface includes.insert(kStatusHeader); // Status includes.insert(kStrongPointerHeader); // sp<> if (options.GenTraces()) { includes.insert(kTraceHeader); } // For a nested interface, client/server classes are declared the same header as well. if (iface.GetParentType()) { includes.insert(kBinderDelegateHeader); // Delegate.h // client/server class provides logFunc when gen_log is on if (options.GenLog()) { includes.insert("functional"); // std::function for logFunc includes.insert("android/binder_to_string.h"); // Generic ToString helper } } } void Visit(const AidlStructuredParcelable&) override { AddParcelableCommonHeaders(); includes.insert("tuple"); // std::tie in comparison operators } void Visit(const AidlUnionDecl& union_decl) override { AddParcelableCommonHeaders(); auto union_headers = cpp::UnionWriter::GetHeaders(union_decl); includes.insert(std::begin(union_headers), std::end(union_headers)); } void Visit(const AidlEnumDeclaration&) override { includes.insert("array"); // used in enum_values includes.insert("binder/Enums.h"); // provides enum_range includes.insert("string"); // toString() returns std::string } void AddParcelableCommonHeaders() { includes.insert(kParcelHeader); // Parcel in readFromParcel/writeToParcel includes.insert(kStatusHeader); // Status includes.insert(kString16Header); // String16 in getParcelableDescriptor includes.insert("android/binder_to_string.h"); // toString() } } v(typenames, options); VisitTopDown(v, defined_type); for (const auto& path : v.includes) { out << "#include <" << path << ">\n"; } out << "\n"; if (v.includes.count("cassert")) { // TODO(b/31559095) bionic on host should define __assert2 out << "#ifndef __BIONIC__\n#define __assert2(a,b,c,d) ((void)0)\n#endif\n\n"; } } // Generic parcelables and enum utilities should be defined in header. void GenerateHeaderDefinitions(CodeWriter& out, const AidlDefinedType& defined_type, const AidlTypenames& typenames, const Options& options) { struct Visitor : AidlVisitor { CodeWriter& out; const AidlTypenames& typenames; const Options& options; Visitor(CodeWriter& out, const AidlTypenames& typenames, const Options& options) : out(out), typenames(typenames), options(options) {} void Visit(const AidlEnumDeclaration& enum_decl) override { const auto backing_type = CppNameOf(enum_decl.GetBackingType(), typenames); EnterNamespace(out, enum_decl); out << GenerateEnumToString(enum_decl, backing_type); LeaveNamespace(out, enum_decl); out << "namespace android {\n"; out << "namespace internal {\n"; out << GenerateEnumValues(enum_decl, {""}); out << "} // namespace internal\n"; out << "} // namespace android\n"; } void Visit(const AidlStructuredParcelable& parcelable) override { if (parcelable.IsGeneric()) { GenerateParcelSource(out, parcelable, typenames, options); } } void Visit(const AidlUnionDecl& union_decl) override { if (union_decl.IsGeneric()) { GenerateParcelSource(out, union_decl, typenames, options); } } } v(out, typenames, options); VisitTopDown(v, defined_type); } void GenerateHeader(CodeWriter& out, const AidlDefinedType& defined_type, const AidlTypenames& typenames, const Options& options) { if (auto parcelable = AidlCast(defined_type); parcelable) { out << "#error TODO(b/111362593) parcelables do not have headers"; return; } out << "#pragma once\n\n"; GenerateHeaderIncludes(out, defined_type, typenames, options); GenerateForwardDecls(out, defined_type, false); EnterNamespace(out, defined_type); // Each class decl contains its own nested types' class decls GenerateClassDecl(out, defined_type, typenames, options); LeaveNamespace(out, defined_type); GenerateHeaderDefinitions(out, defined_type, typenames, options); } void GenerateClientHeader(CodeWriter& out, const AidlDefinedType& defined_type, const AidlTypenames& typenames, const Options& options) { if (auto iface = AidlCast(defined_type); iface) { GenerateClientHeader(out, *iface, typenames, options); } else if (auto parcelable = AidlCast(defined_type); parcelable) { out << "#error TODO(b/111362593) parcelables do not have bp classes"; } else if (auto union_decl = AidlCast(defined_type); union_decl) { out << "#error TODO(b/111362593) parcelables do not have bp classes"; } else if (auto enum_decl = AidlCast(defined_type); enum_decl) { out << "#error TODO(b/111362593) enums do not have bp classes"; } else if (auto parcelable = AidlCast(defined_type); parcelable) { out << "#error TODO(b/111362593) parcelables do not have bp classes"; } else { AIDL_FATAL(defined_type) << "Unrecognized type sent for CPP generation."; } } void GenerateServerHeader(CodeWriter& out, const AidlDefinedType& defined_type, const AidlTypenames& typenames, const Options& options) { if (auto iface = AidlCast(defined_type); iface) { GenerateServerHeader(out, *iface, typenames, options); } else if (auto parcelable = AidlCast(defined_type); parcelable) { out << "#error TODO(b/111362593) parcelables do not have bn classes"; } else if (auto union_decl = AidlCast(defined_type); union_decl) { out << "#error TODO(b/111362593) parcelables do not have bn classes"; } else if (auto enum_decl = AidlCast(defined_type); enum_decl) { out << "#error TODO(b/111362593) enums do not have bn classes"; } else if (auto parcelable = AidlCast(defined_type); parcelable) { out << "#error TODO(b/111362593) parcelables do not have bn classes"; } else { AIDL_FATAL(defined_type) << "Unrecognized type sent for CPP generation."; } } void GenerateSource(CodeWriter& out, const AidlDefinedType& defined_type, const AidlTypenames& typenames, const Options& options) { struct Visitor : AidlVisitor { CodeWriter& out; const AidlTypenames& typenames; const Options& options; Visitor(CodeWriter& out, const AidlTypenames& typenames, const Options& options) : out(out), typenames(typenames), options(options) {} void Visit(const AidlInterface& interface) override { GenerateInterfaceSource(out, interface, typenames, options); GenerateClientSource(out, interface, typenames, options); GenerateServerSource(out, interface, typenames, options); } void Visit(const AidlStructuredParcelable& parcelable) override { if (!parcelable.IsGeneric()) { GenerateParcelSource(out, parcelable, typenames, options); } else { out << "\n"; } } void Visit(const AidlUnionDecl& union_decl) override { if (!union_decl.IsGeneric()) { GenerateParcelSource(out, union_decl, typenames, options); } else { out << "\n"; } } void Visit(const AidlEnumDeclaration& enum_decl) override { if (!enum_decl.GetParentType()) { out << "// This file is intentionally left blank as placeholder for enum declaration.\n"; } } void Visit(const AidlParcelable& parcelable) override { AIDL_FATAL_IF(parcelable.GetParentType(), parcelable) << "Unstructured parcelable can't be nested."; out << "// This file is intentionally left blank as placeholder for parcel declaration.\n"; } } v(out, typenames, options); VisitTopDown(v, defined_type); } bool GenerateCpp(const string& output_file, const Options& options, const AidlTypenames& typenames, const AidlDefinedType& defined_type, const IoDelegate& io_delegate) { if (!ValidateOutputFilePath(output_file, options, defined_type)) { return false; } using GenFn = void (*)(CodeWriter& out, const AidlDefinedType& defined_type, const AidlTypenames& typenames, const Options& options); // Wrap Generate* function to handle CodeWriter for a file. auto gen = [&](auto file, GenFn fn) { unique_ptr writer(io_delegate.GetCodeWriter(file)); GenerateAutoGenHeader(*writer, options); fn(*writer, defined_type, typenames, options); AIDL_FATAL_IF(!writer->Close(), defined_type) << "I/O Error!"; return true; }; return gen(options.OutputHeaderDir() + HeaderFile(defined_type, ClassNames::RAW), &GenerateHeader) && gen(options.OutputHeaderDir() + HeaderFile(defined_type, ClassNames::CLIENT), &GenerateClientHeader) && gen(options.OutputHeaderDir() + HeaderFile(defined_type, ClassNames::SERVER), &GenerateServerHeader) && gen(output_file, &GenerateSource); } } // namespace cpp } // namespace aidl } // namespace android ./PaxHeaders.X/generate_cpp.h0100644 0000000 0000000 00000000034 15172120304 015101 xustar000000000 0000000 28 mtime=1776853188.3360000 generate_cpp.h0100644 0000000 0000000 00000002072 15172120304 012406 0ustar000000000 0000000 /* * Copyright (C) 2015, 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. */ #pragma once #include #include #include "aidl_language.h" #include "aidl_to_cpp.h" #include "aidl_to_cpp_common.h" #include "options.h" namespace android { namespace aidl { namespace cpp { bool GenerateCpp(const string& output_file, const Options& options, const AidlTypenames& typenames, const AidlDefinedType& parsed_doc, const IoDelegate& io_delegate); } // namespace cpp } // namespace aidl } // namespace android ./PaxHeaders.X/generate_cpp_analyzer.cpp0100644 0000000 0000000 00000000034 15172120304 017341 xustar000000000 0000000 28 mtime=1776853188.3360000 generate_cpp_analyzer.cpp0100644 0000000 0000000 00000020515 15172120304 014650 0ustar000000000 0000000 /* * Copyright (C) 2022, 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_cpp_analyzer.h" #include #include "aidl.h" #include "aidl_language.h" #include "aidl_to_common.h" #include "aidl_to_cpp.h" #include "code_writer.h" #include "logging.h" using std::string; using std::unique_ptr; namespace android { namespace aidl { namespace cpp { namespace { const char kAndroidStatusVarName[] = "_aidl_ret_status"; const char kReturnVarName[] = "_aidl_return"; const char kDataVarName[] = "_aidl_data"; const char kReplyVarName[] = "_aidl_reply"; void GenerateAnalyzerTransaction(CodeWriter& out, const AidlInterface& interface, const AidlMethod& method, const AidlTypenames& typenames, const Options& options) { // Reading past the interface descriptor and reply binder status out << "_aidl_ret_status = ::android::OK;\n"; out.Write("if (!(%s.enforceInterface(android::String16(\"%s\")))) {\n", kDataVarName, interface.GetDescriptor().c_str()); out.Write(" %s = ::android::BAD_TYPE;\n", kAndroidStatusVarName); out << " std::cout << \" Failure: Parcel interface does not match.\" << std::endl;\n" << " break;\n" << "}\n"; // Declare parameters for (const unique_ptr& a : method.GetArguments()) { out.Write("%s %s;\n", CppNameOf(a->GetType(), typenames).c_str(), BuildVarName(*a).c_str()); } out << "::android::binder::Status binderStatus;\n"; // Declare and read the return value. // Read past the binder status. out.Write("binderStatus.readFromParcel(%s);\n", kReplyVarName); if (method.GetType().GetName() != "void") { out.Write("%s %s;\n", CppNameOf(method.GetType(), typenames).c_str(), kReturnVarName); out.Write("bool returnError = false;\n"); } // Read Reply if (method.GetType().GetName() != "void") { out.Write("%s = %s.%s(%s);\n", kAndroidStatusVarName, kReplyVarName, ParcelReadMethodOf(method.GetType(), typenames).c_str(), ParcelReadCastOf(method.GetType(), typenames, string("&") + kReturnVarName).c_str()); out.Write("if (((%s) != (android::NO_ERROR))) {\n", kAndroidStatusVarName); out.Indent(); out.Write( "std::cerr << \"Failure: error in reading return value from Parcel.\" << std::endl;\n"); out.Write("returnError = true;\n"); out.Dedent(); out.Write("}\n"); } // Reading arguments out << "do { // Single-pass loop to break if argument reading fails\n"; out.Indent(); for (const auto& a : method.GetArguments()) { out.Write("%s = %s.%s(%s);\n", kAndroidStatusVarName, kDataVarName, ParcelReadMethodOf(a->GetType(), typenames).c_str(), ParcelReadCastOf(a->GetType(), typenames, "&" + BuildVarName(*a)).c_str()); out.Write("if (((%s) != (android::NO_ERROR))) {\n", kAndroidStatusVarName); out.Indent(); out.Write("std::cerr << \"Failure: error in reading argument %s from Parcel.\" << std::endl;\n", a->GetName().c_str()); out.Dedent(); out.Write(" break;\n}\n"); } out.Dedent(); out << "} while(false);\n"; if (!method.GetArguments().empty() && options.GetMinSdkVersion() >= SDK_VERSION_Tiramisu) { out.Write( "if (!%s.enforceNoDataAvail().isOk()) {\n %s = android::BAD_VALUE;\n std::cout << \" " "Failure: Parcel has too much data.\" << std::endl;\n break;\n}\n", kDataVarName, kAndroidStatusVarName); } // Arguments out.Write("std::cout << \" arguments: \" << std::endl;\n"); for (const auto& a : method.GetArguments()) { out.Write( "std::cout << \" %s: \" << ::android::internal::ToString(%s) " "<< std::endl;\n", a->GetName().c_str(), BuildVarName(*a).c_str()); } // Return Value if (method.GetType().GetName() != "void") { out.Write("if (returnError) {\n"); out.Indent(); out.Write("std::cout << \" return: \" << std::endl;\n"); out.Dedent(); out.Write("} else {"); out.Indent(); out.Write("std::cout << \" return: \" << ::android::internal::ToString(%s) << std::endl;\n", kReturnVarName); out.Dedent(); out.Write("}\n"); } else { out.Write("std::cout << \" return: void\" << std::endl;\n"); } } void GenerateAnalyzerSource(CodeWriter& out, const AidlDefinedType& defined_type, const AidlTypenames& typenames, const Options& options) { auto interface = AidlCast(defined_type); string q_name = GetQualifiedName(*interface, ClassNames::INTERFACE); string canonicalName = defined_type.GetCanonicalName(); string interfaceName = defined_type.GetName(); // Includes vector include_list{ "iostream", "binder/Parcel.h", "android/binder_to_string.h", HeaderFile(*interface, ClassNames::RAW, false), // HeaderFile(*interface, ClassNames::INTERFACE, false), }; for (const auto& include : include_list) { out << "#include <" << include << ">\n"; } out << "namespace {\n"; // Function Start out.Write( "android::status_t analyze%s(uint32_t _aidl_code, const android::Parcel& %s, const " "android::Parcel& %s) {\n", q_name.c_str(), kDataVarName, kReplyVarName); out.Indent(); out.Write("android::status_t %s;\nswitch(_aidl_code) {\n", kAndroidStatusVarName); out.Indent(); // Main Switch Statement for (const auto& method : interface->GetMethods()) { out.Write("case ::android::IBinder::FIRST_CALL_TRANSACTION + %d:\n{\n", (method->GetId())); out.Indent(); out.Write("std::cout << \"%s.%s()\" << std::endl;\n", interfaceName.c_str(), method->GetName().c_str()); GenerateAnalyzerTransaction(out, *interface, *method, typenames, options); out.Dedent(); out << "}\n"; out << "break;\n"; } out << "default:\n{\n std::cout << \" Transaction code \" << _aidl_code << \" not known.\" << " "std::endl;\n"; out.Write("%s = android::UNKNOWN_TRANSACTION;\n}\n", kAndroidStatusVarName); out.Dedent(); out.Write("}\nreturn %s;\n", kAndroidStatusVarName); out << "// To prevent unused variable warnings\n"; out.Write("(void)%s; (void)%s; (void)%s;\n", kAndroidStatusVarName, kDataVarName, kReplyVarName); out.Dedent(); out << "}\n\n} // namespace\n"; out << "\n#include \nusing android::aidl::Analyzer;\n"; out.Write( "__attribute__((constructor)) static void addAnalyzer() {\n" " Analyzer::installAnalyzer(std::make_unique(\"%s\", \"%s\", &analyze%s));\n}\n", canonicalName.c_str(), interfaceName.c_str(), q_name.c_str()); } void GenerateAnalyzerPlaceholder(CodeWriter& out, const AidlDefinedType& /*defined_type*/, const AidlTypenames& /*typenames*/, const Options& /*options*/) { out << "// This file is intentionally left blank as placeholder for building an analyzer.\n"; } } // namespace bool GenerateCppAnalyzer(const string& output_file, const Options& options, const AidlTypenames& typenames, const AidlDefinedType& defined_type, const IoDelegate& io_delegate) { if (!ValidateOutputFilePath(output_file, options, defined_type)) { return false; } using GenFn = void (*)(CodeWriter & out, const AidlDefinedType& defined_type, const AidlTypenames& typenames, const Options& options); auto gen = [&](auto file, GenFn fn) { unique_ptr writer(io_delegate.GetCodeWriter(file)); GenerateAutoGenHeader(*writer, options); fn(*writer, defined_type, typenames, options); AIDL_FATAL_IF(!writer->Close(), defined_type) << "I/O Error!"; return true; }; if (AidlCast(defined_type)) { return gen(output_file, &GenerateAnalyzerSource); } else { return gen(output_file, &GenerateAnalyzerPlaceholder); } } } // namespace cpp } // namespace aidl } // namespace android ./PaxHeaders.X/generate_cpp_analyzer.h0100644 0000000 0000000 00000000034 15172120304 017006 xustar000000000 0000000 28 mtime=1776853188.3370000 generate_cpp_analyzer.h0100644 0000000 0000000 00000002143 15172120304 014312 0ustar000000000 0000000 /* * Copyright (C) 2022, 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. */ #pragma once #include #include #include "aidl_language.h" #include "aidl_to_cpp.h" #include "aidl_to_cpp_common.h" #include "options.h" namespace android { namespace aidl { namespace cpp { bool GenerateCppAnalyzer(const string& output_file, const Options& options, const AidlTypenames& typenames, const AidlDefinedType& parsed_doc, const IoDelegate& io_delegate); } // namespace cpp } // namespace aidl } // namespace android ./PaxHeaders.X/generate_cpp_unittest.cpp0100644 0000000 0000000 00000000034 15172120304 017373 xustar000000000 0000000 28 mtime=1776853188.3370000 generate_cpp_unittest.cpp0100644 0000000 0000000 00000007731 15172120304 014707 0ustar000000000 0000000 /* * Copyright (C) 2015, 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 #include #include #include "aidl.h" #include "aidl_language.h" #include "code_writer.h" #include "generate_cpp.h" #include "os.h" #include "tests/fake_io_delegate.h" #include "tests/test_util.h" using ::android::aidl::test::FakeIoDelegate; using ::android::base::StringPrintf; using std::string; using std::unique_ptr; namespace android { namespace aidl { namespace cpp { class ASTTest : public ::testing::Test { protected: ASTTest(const string& cmdline, const string& file_contents) : options_(Options::From(cmdline)), file_contents_(file_contents) { } AidlInterface* ParseSingleInterface() { io_delegate_.SetFileContents(options_.InputFiles().at(0), file_contents_); vector imported_files; ImportResolver import_resolver{io_delegate_, options_.InputFiles().at(0), {"."}}; AidlError err = ::android::aidl::internals::load_and_validate_aidl( options_.InputFiles().front(), options_, io_delegate_, &typenames_, &imported_files); if (err != AidlError::OK) { return nullptr; } const auto& defined_types = typenames_.MainDocument().DefinedTypes(); EXPECT_EQ(1ul, defined_types.size()); EXPECT_NE(nullptr, defined_types.front().get()->AsInterface()); return defined_types.front().get()->AsInterface(); } const Options options_; const string file_contents_; FakeIoDelegate io_delegate_; AidlTypenames typenames_; }; namespace test_io_handling { const char kInputPath[] = "a/IFoo.aidl"; const char kOutputPath[] = "output.cpp"; const char kHeaderDir[] = "headers"; const char kInterfaceHeaderRelPath[] = "a/IFoo.h"; const string kCmdline = string("aidl-cpp -I . ") + kInputPath + " " + kHeaderDir + " " + kOutputPath; } // namespace test_io_handling class IoErrorHandlingTest : public ASTTest { public: IoErrorHandlingTest() : ASTTest(test_io_handling::kCmdline, "package a; interface IFoo {}") {} }; TEST_F(IoErrorHandlingTest, GenerateCorrectlyAbsentErrors) { // Confirm that this is working correctly without I/O problems. AidlInterface* interface = ParseSingleInterface(); ASSERT_NE(interface, nullptr); ASSERT_TRUE(GenerateCpp(options_.OutputFile(), options_, typenames_, *interface, io_delegate_)); } TEST_F(IoErrorHandlingTest, HandlesBadHeaderWrite) { using namespace test_io_handling; AidlInterface* interface = ParseSingleInterface(); ASSERT_NE(interface, nullptr); // Simulate issues closing the interface header. const string header_path = StringPrintf("%s%c%s", kHeaderDir, OS_PATH_SEPARATOR, kInterfaceHeaderRelPath); io_delegate_.AddBrokenFilePath(header_path); ASSERT_DEATH(GenerateCpp(options_.OutputFile(), options_, typenames_, *interface, io_delegate_), "I/O Error!"); // We should never attempt to write the C++ file if we fail writing headers. ASSERT_FALSE(io_delegate_.GetWrittenContents(kOutputPath, nullptr)); } TEST_F(IoErrorHandlingTest, HandlesBadCppWrite) { using test_io_handling::kOutputPath; AidlInterface* interface = ParseSingleInterface(); ASSERT_NE(interface, nullptr); // Simulate issues closing the cpp file. io_delegate_.AddBrokenFilePath(kOutputPath); ASSERT_DEATH(GenerateCpp(options_.OutputFile(), options_, typenames_, *interface, io_delegate_), "I/O Error!"); } } // namespace cpp } // namespace aidl } // namespace android ./PaxHeaders.X/generate_java.cpp0100644 0000000 0000000 00000000034 15172120304 015573 xustar000000000 0000000 28 mtime=1776853188.3370000 generate_java.cpp0100644 0000000 0000000 00000115174 15172120304 013110 0ustar000000000 0000000 /* * 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 "generate_java.h" #include #include #include #include #include #include #include #include #include #include #include "aidl_to_common.h" #include "aidl_to_java.h" #include "code_writer.h" #include "logging.h" using ::android::base::EndsWith; using ::android::base::Join; using ::android::base::StartsWith; using std::string; using std::unique_ptr; using std::vector; namespace { using android::aidl::java::CodeGeneratorContext; using android::aidl::java::ConstantValueDecorator; inline string GetterName(const AidlVariableDeclaration& variable) { return "get" + variable.GetCapitalizedName(); } inline string SetterName(const AidlVariableDeclaration& variable) { return "set" + variable.GetCapitalizedName(); } // clang-format off const map kContentsDescribers { {"FileDescriptor", R"(if (_v instanceof java.io.FileDescriptor) { return android.os.Parcelable.CONTENTS_FILE_DESCRIPTOR; })"}, {"Parcelable", R"(if (_v instanceof android.os.Parcelable) { return ((android.os.Parcelable) _v).describeContents(); })"}, {"Map", R"(if (_v instanceof java.util.Map) { return describeContents(((java.util.Map) _v).values()); })"}, {"List", R"(if (_v instanceof java.util.Collection) { int _mask = 0; for (Object o : (java.util.Collection) _v) { _mask |= describeContents(o); } return _mask; })"}, {"Array", R"(if (_v instanceof Object[]) { int _mask = 0; for (Object o : (Object[]) _v) { _mask |= describeContents(o); } return _mask; })"}, }; // clang-format on void GenerateDescribeContentsHelper(CodeWriter& out, const set& describers) { out << "private int describeContents(Object _v) {\n"; out.Indent(); out << "if (_v == null) return 0;\n"; for (const auto& d : describers) { out << kContentsDescribers.at(d) << "\n"; } out << "return 0;\n"; out.Dedent(); out << "}\n"; } // Some types contribute to Parcelable.describeContents(). // e.g. FileDescriptor, Parcelables, List ... bool CanDescribeContents(const AidlTypeSpecifier& type, const AidlTypenames& types, set* describers) { if (type.IsArray()) { bool canDescribe = false; type.ViewAsArrayBase([&](const AidlTypeSpecifier& base) { canDescribe = CanDescribeContents(base, types, describers); }); if (canDescribe) { describers->insert("Array"); return true; } return false; } if (type.GetName() == "List") { if (CanDescribeContents(*type.GetTypeParameters()[0], types, describers)) { describers->insert("List"); return true; } return false; } if (type.GetName() == "Map") { if (CanDescribeContents(*type.GetTypeParameters()[1], types, describers)) { describers->insert("Map"); // Map describer uses List describer describers->insert("List"); return true; } return false; } if (type.GetName() == "FileDescriptor") { describers->insert("FileDescriptor"); return true; } if (type.GetName() == "ParcelFileDescriptor" || type.GetName() == "ParcelableHolder" || types.GetParcelable(type) != nullptr) { describers->insert("Parcelable"); return true; } return false; } void GenerateParcelableDescribeContents(CodeWriter& out, const AidlStructuredParcelable& decl, const AidlTypenames& types) { set describers; out << "@Override\n"; out << "public int describeContents() {\n"; out.Indent(); out << "int _mask = 0;\n"; for (const auto& f : decl.GetFields()) { if (CanDescribeContents(f->GetType(), types, &describers)) { out << "_mask |= describeContents(" << f->GetName() << ");\n"; } } out << "return _mask;\n"; out.Dedent(); out << "}\n"; if (!describers.empty()) { GenerateDescribeContentsHelper(out, describers); } } void GenerateParcelableDescribeContents(CodeWriter& out, const AidlUnionDecl& decl, const AidlTypenames& types) { set describers; out << "@Override\n"; out << "public int describeContents() {\n"; out.Indent(); out << "int _mask = 0;\n"; out << "switch (getTag()) {\n"; for (const auto& f : decl.GetFields()) { if (CanDescribeContents(f->GetType(), types, &describers)) { out << "case " << f->GetName() << ":\n"; out.Indent(); out << "_mask |= describeContents(" << GetterName(*f) << "());\n"; out << "break;\n"; out.Dedent(); } } out << "}\n"; out << "return _mask;\n"; out.Dedent(); out << "}\n"; if (!describers.empty()) { GenerateDescribeContentsHelper(out, describers); } } void GenerateToString(CodeWriter& out, const AidlStructuredParcelable& parcel, const AidlTypenames& typenames, const Options& options) { out << "@Override\n"; out << "public String toString() {\n"; out.Indent(); out << "java.util.StringJoiner _aidl_sj = new java.util.StringJoiner("; out << "\", \", \"{\", \"}\");\n"; for (const auto& field : parcel.GetFields()) { CodeGeneratorContext ctx{ .writer = out, .typenames = typenames, .type = field->GetType(), .var = field->GetName(), .min_sdk_version = options.GetMinSdkVersion(), }; out << "_aidl_sj.add(\"" << field->GetName() << ": \" + ("; ToStringFor(ctx); out << "));\n"; } out << "return \"" << parcel.GetName() << "\" + _aidl_sj.toString() ;\n"; out.Dedent(); out << "}\n"; } void GenerateToString(CodeWriter& out, const AidlUnionDecl& parcel, const AidlTypenames& typenames, const Options& options) { out << "@Override\n"; out << "public String toString() {\n"; out.Indent(); out << "switch (_tag) {\n"; for (const auto& field : parcel.GetFields()) { CodeGeneratorContext ctx{ .writer = out, .typenames = typenames, .type = field->GetType(), .var = GetterName(*field) + "()", .min_sdk_version = options.GetMinSdkVersion(), }; out << "case " << field->GetName() << ": return \"" << parcel.GetName() << "." << field->GetName() << "(\" + ("; ToStringFor(ctx); out << ") + \")\";\n"; } out << "}\n"; out << "throw new IllegalStateException(\"unknown field: \" + _tag);\n"; out.Dedent(); out << "}\n"; } void GenerateEqualsAndHashCode(CodeWriter& out, const AidlStructuredParcelable& parcel, const AidlTypenames&) { out << "@Override\n"; out << "public boolean equals(Object other) {\n"; out.Indent(); out << "if (this == other) return true;\n"; out << "if (other == null) return false;\n"; out << "if (!(other instanceof " << parcel.GetName() << ")) return false;\n"; out << parcel.GetName() << " that = (" << parcel.GetName() << ")other;\n"; for (const auto& field : parcel.GetFields()) { out << "if (!java.util.Objects.deepEquals(" << field->GetName() << ", that." << field->GetName() << ")) return false;\n"; } out << "return true;\n"; out.Dedent(); out << "}\n"; out << "\n"; out << "@Override\n"; out << "public int hashCode() {\n"; out.Indent(); out << "return java.util.Arrays.deepHashCode(java.util.Arrays.asList("; std::vector names; for (const auto& field : parcel.GetFields()) { names.push_back(field->GetName()); } out << android::base::Join(names, ", ") << ").toArray());\n"; out.Dedent(); out << "}\n"; } void GenerateEqualsAndHashCode(CodeWriter& out, const AidlUnionDecl& decl, const AidlTypenames&) { out << "@Override\n"; out << "public boolean equals(Object other) {\n"; out.Indent(); out << "if (this == other) return true;\n"; out << "if (other == null) return false;\n"; out << "if (!(other instanceof " << decl.GetName() << ")) return false;\n"; out << decl.GetName() << " that = (" << decl.GetName() << ")other;\n"; out << "if (_tag != that._tag) return false;\n"; out << "if (!java.util.Objects.deepEquals(_value, that._value)) return false;\n"; out << "return true;\n"; out.Dedent(); out << "}\n"; out << "\n"; out << "@Override\n"; out << "public int hashCode() {\n"; out.Indent(); out << "return java.util.Arrays.deepHashCode(java.util.Arrays.asList(_tag, _value).toArray());\n"; out.Dedent(); out << "}\n"; out << "\n"; } } // namespace namespace android { namespace aidl { namespace java { std::string GenerateComments(const AidlCommentable& node) { return FormatCommentsForJava(node.GetComments()); } std::string GenerateAnnotations(const AidlNode& node) { std::string result; for (const auto& a : JavaAnnotationsFor(node)) { result += a + "\n"; } return result; } std::unique_ptr GenerateParcelableClass( const AidlStructuredParcelable* parcel, const AidlTypenames& typenames, const Options& options) { auto parcel_class = std::make_unique(); parcel_class->comment = GenerateComments(*parcel); parcel_class->modifiers = PUBLIC; parcel_class->what = Class::CLASS; parcel_class->type = parcel->GetCanonicalName(); parcel_class->interfaces.push_back("android.os.Parcelable"); parcel_class->annotations = JavaAnnotationsFor(*parcel); if (parcel->GetParentType()) { parcel_class->modifiers |= STATIC; } if (parcel->IsGeneric()) { parcel_class->type += "<" + base::Join(parcel->GetTypeParameters(), ",") + ">"; } for (const auto& variable : parcel->GetFields()) { std::ostringstream out; out << GenerateComments(*variable); out << GenerateAnnotations(*variable); out << "public "; if (variable->GetType().GetName() == "ParcelableHolder" || parcel->IsJavaOnlyImmutable()) { out << "final "; } out << JavaSignatureOf(variable->GetType()) << " " << variable->GetName(); if (!parcel->IsJavaOnlyImmutable() && variable->GetDefaultValue()) { out << " = " << variable->ValueString(ConstantValueDecorator); } else if (variable->GetType().GetName() == "ParcelableHolder") { out << std::boolalpha; out << " = new " << JavaSignatureOf(variable->GetType()) << "("; if (parcel->IsVintfStability()) { out << "android.os.Parcelable.PARCELABLE_STABILITY_VINTF"; } else { out << "android.os.Parcelable.PARCELABLE_STABILITY_LOCAL"; } out << ")"; out << std::noboolalpha; } out << ";\n"; parcel_class->elements.push_back(std::make_shared(out.str())); } std::ostringstream out; if (parcel->IsJavaOnlyImmutable()) { auto builder_class = std::make_shared(); builder_class->modifiers = PUBLIC | FINAL | STATIC; builder_class->what = Class::CLASS; builder_class->type = "Builder"; out.str(""); for (const auto& variable : parcel->GetFields()) { out << "private " << JavaSignatureOf(variable->GetType()) << " " << variable->GetName(); if (variable->GetDefaultValue()) { out << " = " << variable->ValueString(ConstantValueDecorator); } out << ";\n"; out << "public Builder " << SetterName(*variable) << "(" << JavaSignatureOf(variable->GetType()) << " " << variable->GetName() << ") {\n" << " " << "this." << variable->GetName() << " = " << variable->GetName() << ";\n" << " return this;\n" << "}\n"; } out << "public " << parcel->GetCanonicalName() << " build() {\n" << " return new " << parcel->GetCanonicalName() << "("; std::vector variables; std::transform(parcel->GetFields().begin(), parcel->GetFields().end(), std::back_inserter(variables), [](const auto& f) { return f->GetName(); }); out << base::Join(variables, ", ") << ");\n" << "}\n"; builder_class->elements.push_back(std::make_shared(out.str())); parcel_class->elements.push_back(builder_class); } if (parcel->IsVintfStability()) { parcel_class->elements.push_back(std::make_shared( "@Override\n public final int getStability() { return " "android.os.Parcelable.PARCELABLE_STABILITY_VINTF; }\n")); } out.str(""); out << "public static final android.os.Parcelable.Creator<" << parcel->GetName() << "> CREATOR = " << "new android.os.Parcelable.Creator<" << parcel->GetName() << ">() {\n"; out << " @Override\n"; out << " public " << parcel->GetName() << " createFromParcel(android.os.Parcel _aidl_source) {\n"; if (parcel->IsJavaOnlyImmutable()) { out << " return internalCreateFromParcel(_aidl_source);\n"; } else { out << " " << parcel->GetName() << " _aidl_out = new " << parcel->GetName() << "();\n"; out << " _aidl_out.readFromParcel(_aidl_source);\n"; out << " return _aidl_out;\n"; } out << " }\n"; out << " @Override\n"; out << " public " << parcel->GetName() << "[] newArray(int _aidl_size) {\n"; out << " return new " << parcel->GetName() << "[_aidl_size];\n"; out << " }\n"; out << "};\n"; parcel_class->elements.push_back(std::make_shared(out.str())); auto flag_variable = std::make_shared("int", "_aidl_flag"); auto parcel_variable = std::make_shared("android.os.Parcel", "_aidl_parcel"); auto write_method = std::make_shared(); write_method->modifiers = PUBLIC | OVERRIDE | FINAL; write_method->returnType = "void"; write_method->name = "writeToParcel"; write_method->parameters.push_back(parcel_variable); write_method->parameters.push_back(flag_variable); write_method->statements = std::make_shared(); out.str(""); out << "int _aidl_start_pos = _aidl_parcel.dataPosition();\n" << "_aidl_parcel.writeInt(0);\n"; write_method->statements->Add(std::make_shared(out.str())); for (const auto& field : parcel->GetFields()) { string code; CodeWriterPtr writer = CodeWriter::ForString(&code); CodeGeneratorContext context{ .writer = *(writer.get()), .typenames = typenames, .type = field->GetType(), .parcel = parcel_variable->name, .var = field->GetName(), .min_sdk_version = options.GetMinSdkVersion(), .write_to_parcel_flag = "_aidl_flag", }; if (field->IsNew() && ShouldForceDowngradeFor(CommunicationSide::WRITE)) { context.writer.Write("if (false) {;\n"); context.writer.Indent(); } WriteToParcelFor(context); if (field->IsNew() && ShouldForceDowngradeFor(CommunicationSide::WRITE)) { context.writer.Dedent(); context.writer.Write("};\n"); } writer->Close(); write_method->statements->Add(std::make_shared(code)); } out.str(""); out << "int _aidl_end_pos = _aidl_parcel.dataPosition();\n" << "_aidl_parcel.setDataPosition(_aidl_start_pos);\n" << "_aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos);\n" << "_aidl_parcel.setDataPosition(_aidl_end_pos);\n"; write_method->statements->Add(std::make_shared(out.str())); parcel_class->elements.push_back(write_method); if (parcel->IsJavaOnlyImmutable()) { auto constructor = std::make_shared(); constructor->modifiers = PUBLIC; constructor->name = parcel->GetName(); constructor->statements = std::make_shared(); for (const auto& field : parcel->GetFields()) { constructor->parameters.push_back( std::make_shared(JavaSignatureOf(field->GetType()), field->GetName())); out.str(""); out << "this." << field->GetName() << " = "; if (field->GetType().GetName() == "List") { out << field->GetName() << " == null ? null : java.util.Collections.unmodifiableList(" << field->GetName() << ");\n"; } else if (field->GetType().GetName() == "Map") { out << field->GetName() << " == null ? null : java.util.Collections.unmodifiableMap(" << field->GetName() << ");\n"; } else { out << field->GetName() << ";\n"; } constructor->statements->Add(std::make_shared(out.str())); } parcel_class->elements.push_back(constructor); } // For an immutable parcelable, generate internalCreateFromParcel method. // Otherwise, generate readFromParcel method. auto read_or_create_method = std::make_shared(); if (parcel->IsJavaOnlyImmutable()) { auto constructor = std::make_shared(); read_or_create_method->modifiers = PRIVATE | STATIC; read_or_create_method->returnType = parcel->GetName(); read_or_create_method->name = "internalCreateFromParcel"; read_or_create_method->parameters.push_back(parcel_variable); read_or_create_method->statements = std::make_shared(); } else { read_or_create_method->modifiers = PUBLIC | FINAL; read_or_create_method->returnType = "void"; read_or_create_method->name = "readFromParcel"; read_or_create_method->parameters.push_back(parcel_variable); read_or_create_method->statements = std::make_shared(); } out.str(""); const string builder_variable = "_aidl_parcelable_builder"; if (parcel->IsJavaOnlyImmutable()) { out << "Builder " << builder_variable << " = new Builder();\n"; } out << "int _aidl_start_pos = _aidl_parcel.dataPosition();\n" << "int _aidl_parcelable_size = _aidl_parcel.readInt();\n" << "try {\n" << " if (_aidl_parcelable_size < 4) throw new " "android.os.BadParcelableException(\"Parcelable too small\");"; if (parcel->IsJavaOnlyImmutable()) { out << " " << builder_variable << ".build()"; } out << ";\n"; read_or_create_method->statements->Add(std::make_shared(out.str())); out.str(""); out << " if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return"; if (parcel->IsJavaOnlyImmutable()) { out << " " << builder_variable << ".build()"; } out << ";\n"; std::shared_ptr sizeCheck = std::make_shared(out.str()); // keep this across different fields in order to create the classloader // at most once. bool is_classloader_created = false; for (const auto& field : parcel->GetFields()) { read_or_create_method->statements->Add(sizeCheck); const auto field_variable_name = (parcel->IsJavaOnlyImmutable() ? "_aidl_temp_" : "") + field->GetName(); string code; CodeWriterPtr writer = CodeWriter::ForString(&code); CodeGeneratorContext context{ .writer = *(writer.get()), .typenames = typenames, .type = field->GetType(), .parcel = parcel_variable->name, .var = field_variable_name, .min_sdk_version = options.GetMinSdkVersion(), .is_classloader_created = &is_classloader_created, }; context.writer.Indent(); if (field->IsNew() && ShouldForceDowngradeFor(CommunicationSide::READ)) { context.writer.Write("if (false) {;\n"); context.writer.Indent(); } if (parcel->IsJavaOnlyImmutable()) { context.writer.Write("%s %s;\n", JavaSignatureOf(field->GetType()).c_str(), field_variable_name.c_str()); } CreateFromParcelFor(context); if (parcel->IsJavaOnlyImmutable()) { context.writer.Write("%s.%s(%s);\n", builder_variable.c_str(), SetterName(*field).c_str(), field_variable_name.c_str()); } if (field->IsNew() && ShouldForceDowngradeFor(CommunicationSide::READ)) { context.writer.Dedent(); context.writer.Write("};\n"); } writer->Close(); read_or_create_method->statements->Add(std::make_shared(code)); } out.str(""); out << "} finally {\n" << " if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) {\n" << " throw new android.os.BadParcelableException(\"Overflow in the size of " "parcelable\");\n" << " }\n" << " _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size);\n"; if (parcel->IsJavaOnlyImmutable()) { out << " return " << builder_variable << ".build();\n"; } out << "}\n"; read_or_create_method->statements->Add(std::make_shared(out.str())); parcel_class->elements.push_back(read_or_create_method); string constants; GenerateConstantDeclarations(*CodeWriter::ForString(&constants), *parcel); parcel_class->elements.push_back(std::make_shared(constants)); if (parcel->JavaDerive("toString")) { string to_string; GenerateToString(*CodeWriter::ForString(&to_string), *parcel, typenames, options); parcel_class->elements.push_back(std::make_shared(to_string)); } if (parcel->JavaDerive("equals")) { string to_string; GenerateEqualsAndHashCode(*CodeWriter::ForString(&to_string), *parcel, typenames); parcel_class->elements.push_back(std::make_shared(to_string)); } string describe_contents; GenerateParcelableDescribeContents(*CodeWriter::ForString(&describe_contents), *parcel, typenames); parcel_class->elements.push_back(std::make_shared(describe_contents)); // all the nested types string code; auto writer = CodeWriter::ForString(&code); for (const auto& nested : parcel->GetNestedTypes()) { GenerateClass(*writer, *nested, typenames, options); } GenerateParcelHelpers(*writer, *parcel, typenames, options); writer->Close(); parcel_class->elements.push_back(std::make_shared(code)); return parcel_class; } void GenerateEnumClass(CodeWriter& out, const AidlEnumDeclaration& enum_decl) { const AidlTypeSpecifier& backing_type = enum_decl.GetBackingType(); std::string raw_type = JavaSignatureOf(backing_type); std::string boxing_type = JavaBoxingTypeOf(backing_type); out << GenerateComments(enum_decl); out << GenerateAnnotations(enum_decl); out << "public "; if (enum_decl.GetParentType()) { out << "static "; } out << "@interface " << enum_decl.GetName() << " {\n"; out.Indent(); for (const auto& enumerator : enum_decl.GetEnumerators()) { out << GenerateComments(*enumerator); out << GenerateAnnotations(*enumerator); out << fmt::format("public static final {} {} = {};\n", raw_type, enumerator->GetName(), enumerator->ValueString(backing_type, ConstantValueDecorator)); } if (enum_decl.JavaDerive("toString")) { out << "interface $ {\n"; out.Indent(); out << "static String toString(" << raw_type << " _aidl_v) {\n"; out.Indent(); for (const auto& enumerator : enum_decl.GetEnumerators()) { out << "if (_aidl_v == " << enumerator->GetName() << ") return \"" << enumerator->GetName() << "\";\n"; } out << "return " << boxing_type << ".toString(_aidl_v);\n"; out.Dedent(); out << "}\n"; out << fmt::format(R"(static String arrayToString(Object _aidl_v) {{ if (_aidl_v == null) return "null"; Class _aidl_cls = _aidl_v.getClass(); if (!_aidl_cls.isArray()) throw new IllegalArgumentException("not an array: " + _aidl_v); Class comp = _aidl_cls.getComponentType(); java.util.StringJoiner _aidl_sj = new java.util.StringJoiner(", ", "[", "]"); if (comp.isArray()) {{ for (int _aidl_i = 0; _aidl_i < java.lang.reflect.Array.getLength(_aidl_v); _aidl_i++) {{ _aidl_sj.add(arrayToString(java.lang.reflect.Array.get(_aidl_v, _aidl_i))); }} }} else {{ if (_aidl_cls != {raw_type}[].class) throw new IllegalArgumentException("wrong type: " + _aidl_cls); for ({raw_type} e : ({raw_type}[]) _aidl_v) {{ _aidl_sj.add(toString(e)); }} }} return _aidl_sj.toString(); }} )", fmt::arg("raw_type", raw_type)); out.Dedent(); out << "}\n"; } out.Dedent(); out << "}\n"; } void GenerateUnionClass(CodeWriter& out, const AidlUnionDecl* decl, const AidlTypenames& typenames, const Options& options) { const string tag_type = "int"; auto tag_type_specifier = typenames.MakeResolvedType(AIDL_LOCATION_HERE, tag_type, /* isArray */ false); const string clazz = decl->GetName(); out << GenerateComments(*decl); out << GenerateAnnotations(*decl); out << "public "; if (decl->GetParentType()) { out << "static "; } out << "final class " + clazz + " implements android.os.Parcelable {\n"; out.Indent(); size_t tag_index = 0; out << "// tags for union fields\n"; for (const auto& variable : decl->GetFields()) { auto signature = variable->Signature() + ";"; out << "public final static " + tag_type + " " + variable->GetName() + " = " + std::to_string(tag_index++) + "; // " + signature + "\n"; } out << "\n"; const auto final_opt = decl->IsJavaOnlyImmutable() ? "final " : ""; out << "private " << final_opt << tag_type + " _tag;\n"; out << "private " << final_opt << "Object _value;\n"; out << "\n"; AIDL_FATAL_IF(decl->GetFields().empty(), *decl) << "Union '" << clazz << "' is empty."; const auto& first_field = decl->GetFields()[0]; const auto& first_type = JavaSignatureOf(first_field->GetType()); const auto& first_value = first_field->ValueString(ConstantValueDecorator); // default ctor() inits with first member's default value out << "public " + clazz + "() {\n"; out.Indent(); out << first_type + " _value = " << (first_value.empty() ? DefaultJavaValueOf(first_field->GetType()) : first_value) << ";\n"; out << "this._tag = " << first_field->GetName() << ";\n"; out << "this._value = _value;\n"; out.Dedent(); out << "}\n\n"; if (!decl->IsJavaOnlyImmutable()) { // private ctor(Parcel) out << "private " + clazz + "(android.os.Parcel _aidl_parcel) {\n"; out << " readFromParcel(_aidl_parcel);\n"; out << "}\n\n"; } // private ctor(tag, value) out << "private " + clazz + "(" + tag_type + " _tag, Object _value) {\n"; out.Indent(); out << "this._tag = _tag;\n"; out << "this._value = _value;\n"; out.Dedent(); out << "}\n\n"; // getTag() out << "public " + tag_type + " " + "getTag() {\n"; out.Indent(); out << "return _tag;\n"; out.Dedent(); out << "}\n\n"; // value ctor, getter, setter(for mutable) for each field for (const auto& variable : decl->GetFields()) { out << "// " + variable->Signature() + ";\n\n"; auto var_name = variable->GetName(); auto var_type = JavaSignatureOf(variable->GetType()); // value ctor out << GenerateComments(*variable); out << GenerateAnnotations(*variable); out << "public static " + clazz + " " + var_name + "(" + var_type + " _value) {\n"; out.Indent(); out << "return new " + clazz + "(" + var_name + ", _value);\n"; out.Dedent(); out << "}\n\n"; // getter if (variable->GetType().IsGeneric()) { out << "@SuppressWarnings(\"unchecked\")\n"; } out << "public " + var_type + " " + GetterName(*variable) + "() {\n"; out.Indent(); out << "_assertTag(" + var_name + ");\n"; out << "return (" + var_type + ") _value;\n"; out.Dedent(); out << "}\n\n"; // setter if (!decl->IsJavaOnlyImmutable()) { out << "public void " + SetterName(*variable) + "(" + var_type + " _value) {\n"; out.Indent(); out << "_set(" + var_name + ", _value);\n"; out.Dedent(); out << "}\n\n"; } } if (decl->IsVintfStability()) { out << "@Override\n"; out << "public final int getStability() {\n"; out << " return android.os.Parcelable.PARCELABLE_STABILITY_VINTF;\n"; out << "}\n\n"; } out << "public static final android.os.Parcelable.Creator<" << clazz << "> CREATOR = " << "new android.os.Parcelable.Creator<" << clazz << ">() {\n"; out << " @Override\n"; out << " public " << clazz << " createFromParcel(android.os.Parcel _aidl_source) {\n"; if (decl->IsJavaOnlyImmutable()) { out << " return internalCreateFromParcel(_aidl_source);\n"; } else { out << " return new " + clazz + "(_aidl_source);\n"; } out << " }\n"; out << " @Override\n"; out << " public " << clazz << "[] newArray(int _aidl_size) {\n"; out << " return new " << clazz << "[_aidl_size];\n"; out << " }\n"; out << "};\n\n"; auto write_to_parcel = [&](const AidlTypeSpecifier& type, std::string name, std::string parcel) { string code; CodeWriterPtr writer = CodeWriter::ForString(&code); CodeGeneratorContext context{ .writer = *(writer.get()), .typenames = typenames, .type = type, .parcel = parcel, .var = name, .min_sdk_version = options.GetMinSdkVersion(), .write_to_parcel_flag = "_aidl_flag", }; WriteToParcelFor(context); writer->Close(); return code; }; out << "@Override\n"; out << "public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) {\n"; out.Indent(); out << write_to_parcel(*tag_type_specifier, "_tag", "_aidl_parcel"); out << "switch (_tag) {\n"; for (const auto& variable : decl->GetFields()) { out << "case " + variable->GetName() + ":\n"; out.Indent(); if (variable->IsNew() && ShouldForceDowngradeFor(CommunicationSide::WRITE)) { out << "if (true) throw new IllegalArgumentException(\"union: unknown tag: \" + _tag);\n"; } out << write_to_parcel(variable->GetType(), GetterName(*variable) + "()", "_aidl_parcel"); out << "break;\n"; out.Dedent(); } out << "}\n"; out.Dedent(); out << "}\n\n"; // keep this across different fields in order to create the classloader // at most once. bool is_classloader_created = false; auto read_from_parcel = [&](const AidlTypeSpecifier& type, std::string name, std::string parcel) { string code; CodeWriterPtr writer = CodeWriter::ForString(&code); CodeGeneratorContext context{ .writer = *(writer.get()), .typenames = typenames, .type = type, .parcel = parcel, .var = name, .min_sdk_version = options.GetMinSdkVersion(), .is_classloader_created = &is_classloader_created, }; CreateFromParcelFor(context); writer->Close(); return code; }; if (decl->IsJavaOnlyImmutable()) { // When it's immutable we don't need readFromParcel, but we can use it from createFromParcel out << "private static " + clazz + " internalCreateFromParcel(android.os.Parcel _aidl_parcel) {\n"; } else { // Not override, but as a user-defined parcelable, this method should be public out << "public void readFromParcel(android.os.Parcel _aidl_parcel) {\n"; } out.Indent(); out << tag_type + " _aidl_tag;\n"; out << read_from_parcel(*tag_type_specifier, "_aidl_tag", "_aidl_parcel"); out << "switch (_aidl_tag) {\n"; for (const auto& variable : decl->GetFields()) { auto var_name = variable->GetName(); auto var_type = JavaSignatureOf(variable->GetType()); out << "case " + var_name + ": {\n"; out.Indent(); if (variable->IsNew() && ShouldForceDowngradeFor(CommunicationSide::READ)) { out << "if (true) throw new IllegalArgumentException(\"union: unknown tag: \" + _tag);\n"; } out << var_type + " _aidl_value;\n"; out << read_from_parcel(variable->GetType(), "_aidl_value", "_aidl_parcel"); if (decl->IsJavaOnlyImmutable()) { out << "return new " << clazz << "(_aidl_tag, _aidl_value); }\n"; } else { out << "_set(_aidl_tag, _aidl_value);\n"; out << "return; }\n"; } out.Dedent(); } out << "}\n"; out << "throw new IllegalArgumentException(\"union: unknown tag: \" + _aidl_tag);\n"; out.Dedent(); out << "}\n\n"; GenerateConstantDeclarations(out, *decl); GenerateParcelableDescribeContents(out, *decl, typenames); out << "\n"; if (decl->JavaDerive("toString")) { GenerateToString(out, *decl, typenames, options); } if (decl->JavaDerive("equals")) { GenerateEqualsAndHashCode(out, *decl, typenames); } // helper: _assertTag out << "private void _assertTag(" + tag_type + " tag) {\n"; out << " if (getTag() != tag) {\n"; out << " throw new IllegalStateException(\"bad access: \" + _tagString(tag) + \", \" + " "_tagString(getTag()) + \" is available.\");\n"; out << " }\n"; out << "}\n\n"; // helper: _tagString out << "private String _tagString(" + tag_type + " _tag) {\n"; out << " switch (_tag) {\n"; for (const auto& variable : decl->GetFields()) { auto var_name = variable->GetName(); out << " case " + var_name + ": return \"" + var_name + "\";\n"; } out << " }\n"; out << " throw new IllegalStateException(\"unknown field: \" + _tag);\n"; out << "}\n"; if (!decl->IsJavaOnlyImmutable()) { out << "\n"; out << "private void _set(int _tag, Object _value) {\n"; out.Indent(); out << "this._tag = _tag;\n"; out << "this._value = _value;\n"; out.Dedent(); out << "}\n"; } // all the nested types for (const auto& nested : decl->GetNestedTypes()) { GenerateClass(out, *nested, typenames, options); } GenerateParcelHelpers(out, *decl, typenames, options); out.Dedent(); out << "}\n"; } std::string dump_location(const AidlNode& method) { return method.PrintLocation(); } std::string GenerateJavaUnsupportedAppUsageParameters(const AidlAnnotation& a) { const std::map params = a.AnnotationParams(ConstantValueDecorator); std::vector parameters_decl; for (const auto& name_and_param : params) { const std::string& param_name = name_and_param.first; const std::string& param_value = name_and_param.second; parameters_decl.push_back(param_name + " = " + param_value); } parameters_decl.push_back("overrideSourcePosition=\"" + dump_location(a) + "\""); return "(" + Join(parameters_decl, ", ") + ")"; } std::vector GenerateJavaAnnotations(const AidlAnnotatable& a) { std::vector result; const AidlAnnotation* unsupported_app_usage = a.UnsupportedAppUsage(); if (unsupported_app_usage != nullptr) { result.emplace_back("@android.compat.annotation.UnsupportedAppUsage" + GenerateJavaUnsupportedAppUsageParameters(*unsupported_app_usage)); } for (const auto& annotation : a.GetAnnotations()) { if (annotation->GetType() == AidlAnnotation::Type::JAVA_PASSTHROUGH) { result.emplace_back(annotation->ParamValue("annotation").value()); } if (annotation->GetType() == AidlAnnotation::Type::JAVA_SUPPRESS_LINT) { std::vector values; for (const auto& [name, value] : annotation->AnnotationParams(ConstantValueDecorator)) { values.emplace_back(name + " = " + value); } result.emplace_back("@android.annotation.SuppressLint(" + Join(values, ", ") + ")"); } } return result; } std::optional JavaPermissionAnnotation(const AidlAnnotatable& a) { if (auto enforce_expr = a.EnforceExpression(); enforce_expr) { return "@android.annotation.EnforcePermission(" + android::aidl::perm::AsJavaAnnotation(*enforce_expr.get()) + ")"; } else if (a.IsPermissionNone()) { return "@android.annotation.RequiresNoPermission"; } // TODO: Add annotation for @PermissionManuallyEnforced return {}; } struct JavaAnnotationsVisitor : AidlVisitor { JavaAnnotationsVisitor(std::vector& result) : result(result) {} void Visit(const AidlTypeSpecifier& t) override { result = GenerateJavaAnnotations(t); } void Visit(const AidlInterface& t) override { ForDefinedType(t); } void Visit(const AidlParcelable& t) override { ForDefinedType(t); } void Visit(const AidlStructuredParcelable& t) override { ForDefinedType(t); } void Visit(const AidlUnionDecl& t) override { ForDefinedType(t); } void Visit(const AidlEnumDeclaration& t) override { ForDefinedType(t); } void Visit(const AidlEnumerator& e) override { if (e.IsDeprecated()) { result.push_back("@Deprecated"); } } void Visit(const AidlMethod& m) override { ForMember(m); } void Visit(const AidlConstantDeclaration& c) override { ForMember(c); } void Visit(const AidlVariableDeclaration& v) override { ForMember(v); } std::vector& result; void ForDefinedType(const AidlDefinedType& t) { result = GenerateJavaAnnotations(t); if (t.IsDeprecated()) { result.push_back("@Deprecated"); } } template void ForMember(const Member& t) { result = GenerateJavaAnnotations(t.GetType()); if (t.IsDeprecated()) { result.push_back("@Deprecated"); } if (auto permission_annotation = JavaPermissionAnnotation(t.GetType()); permission_annotation) { result.push_back(*permission_annotation); } } }; std::vector JavaAnnotationsFor(const AidlNode& a) { std::vector result; JavaAnnotationsVisitor visitor{result}; a.DispatchVisit(visitor); return result; } void GenerateClass(CodeWriter& out, const AidlDefinedType& defined_type, const AidlTypenames& types, const Options& options) { if (const AidlStructuredParcelable* parcelable = defined_type.AsStructuredParcelable(); parcelable != nullptr) { GenerateParcelableClass(parcelable, types, options)->Write(&out); } else if (const AidlEnumDeclaration* enum_decl = defined_type.AsEnumDeclaration(); enum_decl != nullptr) { GenerateEnumClass(out, *enum_decl); } else if (const AidlInterface* interface = defined_type.AsInterface(); interface != nullptr) { GenerateInterfaceClass(interface, types, options)->Write(&out); } else if (const AidlUnionDecl* union_decl = defined_type.AsUnionDeclaration(); union_decl != nullptr) { GenerateUnionClass(out, union_decl, types, options); } else { AIDL_FATAL(defined_type) << "Unrecognized type sent for Java generation."; } } // In Java, there's 1:1 mapping between AIDL type and Java type. So we generate a single file for // the type. void GenerateJava(const std::string& filename, const Options& options, const AidlTypenames& types, const AidlDefinedType& defined_type, const IoDelegate& io_delegate) { CodeWriterPtr code_writer = io_delegate.GetCodeWriter(filename); /* write header */ { auto& out = *code_writer; GenerateAutoGenHeader(out, options); if (const auto pkg = defined_type.GetPackage(); !pkg.empty()) { out << "package " << pkg << ";\n"; } } GenerateClass(*code_writer, defined_type, types, options); AIDL_FATAL_IF(!code_writer->Close(), defined_type) << "I/O Error!"; } } // namespace java } // namespace aidl } // namespace android ./PaxHeaders.X/generate_java.h0100644 0000000 0000000 00000000034 15172120304 015240 xustar000000000 0000000 28 mtime=1776853188.3390000 generate_java.h0100644 0000000 0000000 00000003524 15172120304 012550 0ustar000000000 0000000 /* * 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. */ #pragma once #include "aidl_language.h" #include "ast_java.h" #include "io_delegate.h" #include "options.h" #include #include namespace android { namespace aidl { namespace java { void GenerateJava(const std::string& filename, const Options& options, const AidlTypenames& typenames, const AidlDefinedType& defined_type, const IoDelegate& io_delegate); void GenerateClass(CodeWriter& out, const AidlDefinedType& defined_type, const AidlTypenames& types, const Options& options); std::unique_ptr GenerateInterfaceClass(const AidlInterface* iface, const AidlTypenames& typenames, const Options& options); void GenerateConstantDeclarations(CodeWriter& out, const AidlDefinedType& type); std::string GenerateComments(const AidlCommentable& node); std::string GenerateAnnotations(const AidlNode& node); std::vector JavaAnnotationsFor(const AidlNode& a); std::optional JavaPermissionAnnotation(const AidlAnnotatable& a); } // namespace java } // namespace aidl } // namespace android ./PaxHeaders.X/generate_java_binder.cpp0100644 0000000 0000000 00000000034 15172120304 017116 xustar000000000 0000000 28 mtime=1776853188.3420000 generate_java_binder.cpp0100644 0000000 0000000 00000166627 15172120304 014444 0ustar000000000 0000000 /* * 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_language.h" #include "aidl_to_common.h" #include "aidl_to_java.h" #include "aidl_typenames.h" #include "ast_java.h" #include "code_writer.h" #include "generate_java.h" #include "logging.h" #include "options.h" #include "parser.h" #include #include #include #include #include #include #include #include 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; explicit VariableFactory(const std::string& base) : base_(base), index_(0) {} std::shared_ptr Get(const AidlTypeSpecifier& type) { auto v = std::make_shared(JavaSignatureOf(type), StringPrintf("%s%d", base_.c_str(), index_)); vars_.push_back(v); index_++; return v; } std::shared_ptr Get(int index) { return vars_[index]; } private: std::vector> vars_; std::string base_; int index_; }; // ================================================= class StubClass : public Class { public: StubClass(const AidlInterface* interfaceType, const Options& options); ~StubClass() override = default; // non-copyable, non-movable StubClass(const StubClass&) = delete; StubClass(StubClass&&) = delete; StubClass& operator=(const StubClass&) = delete; StubClass& operator=(StubClass&&) = delete; std::shared_ptr transact_code; std::shared_ptr transact_data; std::shared_ptr transact_reply; std::shared_ptr transact_flags; std::vector> transact_if_statements_meta; std::shared_ptr transact_switch_user; std::shared_ptr transact_statements; std::shared_ptr 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 outline_methods; // Number of all methods. size_t all_method_count; // Finish generation. This will add a default case to the switch. void Finish(); std::shared_ptr GetTransactDescriptor(const AidlMethod* method); private: void MakeConstructors(const AidlInterface* interfaceType); void MakeAsInterface(const AidlInterface* interfaceType); std::shared_ptr transact_descriptor; const Options& options_; }; StubClass::StubClass(const AidlInterface* interfaceType, 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 = interfaceType->GetCanonicalName() + ".Stub"; this->extends = "android.os.Binder"; this->interfaces.push_back(interfaceType->GetCanonicalName()); MakeConstructors(interfaceType); MakeAsInterface(interfaceType); // asBinder auto asBinder = std::make_shared(); asBinder->modifiers = PUBLIC | OVERRIDE; asBinder->returnType = "android.os.IBinder"; asBinder->name = "asBinder"; asBinder->statements = std::make_shared(); asBinder->statements->Add(std::make_shared(THIS_VALUE)); this->elements.push_back(asBinder); if (options_.GenTransactionNames() || options_.GenTraces()) { // getDefaultTransactionName auto getDefaultTransactionName = std::make_shared(); getDefaultTransactionName->comment = "/** @hide */"; getDefaultTransactionName->modifiers = PUBLIC | STATIC; getDefaultTransactionName->returnType = "java.lang.String"; getDefaultTransactionName->name = "getDefaultTransactionName"; auto code = std::make_shared("int", "transactionCode"); getDefaultTransactionName->parameters.push_back(code); getDefaultTransactionName->statements = std::make_shared(); this->code_to_method_name_switch = std::make_shared(code); getDefaultTransactionName->statements->Add(this->code_to_method_name_switch); this->elements.push_back(getDefaultTransactionName); // getTransactionName auto getTransactionName = std::make_shared(); getTransactionName->comment = "/** @hide */"; getTransactionName->modifiers = PUBLIC; getTransactionName->returnType = "java.lang.String"; getTransactionName->name = "getTransactionName"; auto code2 = std::make_shared("int", "transactionCode"); getTransactionName->parameters.push_back(code2); getTransactionName->statements = std::make_shared(); getTransactionName->statements->Add(std::make_shared( std::make_shared(THIS_VALUE, "getDefaultTransactionName", std::vector>{code2}))); this->elements.push_back(getTransactionName); } // onTransact this->transact_code = std::make_shared("int", "code"); this->transact_data = std::make_shared("android.os.Parcel", "data"); this->transact_reply = std::make_shared("android.os.Parcel", "reply"); this->transact_flags = std::make_shared("int", "flags"); auto onTransact = std::make_shared(); onTransact->modifiers = PUBLIC | OVERRIDE; onTransact->returnType = "boolean"; 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 = std::make_shared(); transact_statements = onTransact->statements; onTransact->exceptions.push_back("android.os.RemoteException"); this->elements.push_back(onTransact); this->transact_switch_user = std::make_shared(this->transact_code); } void StubClass::Finish() { auto default_case = std::make_shared(); auto superCall = std::make_shared( SUPER_VALUE, "onTransact", std::vector>{this->transact_code, this->transact_data, this->transact_reply, this->transact_flags}); default_case->statements->Add(std::make_shared(superCall)); auto case_count = transact_switch_user->cases.size(); transact_switch_user->cases.push_back(default_case); // Interface token validation is done for user-defined transactions. if (case_count > 0) { auto ifStatement = std::make_shared(); ifStatement->expression = std::make_shared( "code >= android.os.IBinder.FIRST_CALL_TRANSACTION && " "code <= android.os.IBinder.LAST_CALL_TRANSACTION"); ifStatement->statements = std::make_shared(); ifStatement->statements->Add(std::make_shared( this->transact_data, "enforceInterface", std::vector>{this->GetTransactDescriptor(nullptr)})); transact_statements->Add(ifStatement); } // Build the if/else chain for the meta methods. There at most 3 different // statements so if/else is more efficient than a switch statement. // Meta transactions are looked up prior to user-defined transactions. AIDL_FATAL_IF(this->transact_if_statements_meta.size() == 0, AIDL_LOCATION_HERE) << "Expecting to have meta methods and found none."; AIDL_FATAL_IF(this->transact_if_statements_meta.size() > 3, AIDL_LOCATION_HERE) << "Expecting to have at most 3 meta methods and found " << this->transact_if_statements_meta.size(); auto ifStatement = this->transact_if_statements_meta[0]; std::shared_ptr currentIfStatement = ifStatement; for (size_t i = 1; i < transact_if_statements_meta.size(); i++) { currentIfStatement->elseif = this->transact_if_statements_meta[i]; currentIfStatement = currentIfStatement->elseif; } transact_statements->Add(ifStatement); transact_statements->Add(this->transact_switch_user); // getTransactionName if (options_.GenTransactionNames() || options_.GenTraces()) { // 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. auto code_switch_default_case = std::make_shared(); code_switch_default_case->statements->Add(std::make_shared(NULL_VALUE)); this->code_to_method_name_switch->cases.push_back(code_switch_default_case); } // There will be at least one statement for the default, but if we emit a // return true after that default, it will be unreachable. if (case_count > 0) { transact_statements->Add(std::make_shared(TRUE_VALUE)); } } // 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. std::shared_ptr StubClass::GetTransactDescriptor(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 std::make_shared("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 std::make_shared("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 = std::make_shared("java.lang.String", "descriptor"); transact_statements->Add(std::make_shared( transact_descriptor, std::make_shared("DESCRIPTOR"))); } return transact_descriptor; } void StubClass::MakeConstructors(const AidlInterface* interfaceType) { string ctors_code; CodeWriterPtr writer = CodeWriter::ForString(&ctors_code); CodeWriter& code = *writer; if (interfaceType->UsesPermissions()) { code << "private final android.os.PermissionEnforcer mEnforcer;\n"; code << "/** Construct the stub using the Enforcer provided. */\n"; code << "public Stub(android.os.PermissionEnforcer enforcer)\n"; } else { code << "/** Construct the stub at attach it to the interface. */\n"; code << "@SuppressWarnings(\"this-escape\")\n"; code << "public Stub()\n"; } code << "{\n"; code.Indent(); if (interfaceType->IsVintfStability()) { code << "this.markVintfStability();\n"; } code << "this.attachInterface(this, DESCRIPTOR);\n"; if (interfaceType->UsesPermissions()) { code << "if (enforcer == null) {\n"; code.Indent(); code << "throw new IllegalArgumentException(\"enforcer cannot be null\");\n"; code.Dedent(); code << "}\n"; code << "mEnforcer = enforcer;\n"; } code.Dedent(); code << "}\n"; // Setup a default constructor for permissions interfaces. if (interfaceType->UsesPermissions()) { code << "@Deprecated\n"; code << "/** Default constructor. */\n"; code << "public Stub() {\n"; code.Indent(); code << "this(android.os.PermissionEnforcer.fromContext(\n"; code << " android.app.ActivityThread.currentActivityThread().getSystemContext()));\n"; code.Dedent(); code << "}\n"; } code.Close(); this->elements.push_back(std::make_shared(ctors_code)); } void StubClass::MakeAsInterface(const AidlInterface* interfaceType) { auto obj = std::make_shared("android.os.IBinder", "obj"); auto m = std::make_shared(); m->comment = "/**\n * Cast an IBinder object into an "; m->comment += interfaceType->GetCanonicalName(); m->comment += " interface,\n"; m->comment += " * generating a proxy if needed.\n */"; m->modifiers = PUBLIC | STATIC; m->returnType = interfaceType->GetCanonicalName(); m->name = "asInterface"; m->parameters.push_back(obj); m->statements = std::make_shared(); auto ifstatement = std::make_shared(); ifstatement->expression = std::make_shared(obj, "==", NULL_VALUE); ifstatement->statements = std::make_shared(); ifstatement->statements->Add(std::make_shared(NULL_VALUE)); m->statements->Add(ifstatement); // IInterface iin = obj.queryLocalInterface(DESCRIPTOR) auto queryLocalInterface = std::make_shared(obj, "queryLocalInterface"); queryLocalInterface->arguments.push_back(std::make_shared("DESCRIPTOR")); auto iin = std::make_shared("android.os.IInterface", "iin"); auto iinVd = std::make_shared(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 ) return () // iin; auto iinNotNull = std::make_shared(iin, "!=", NULL_VALUE); auto instOfCheck = std::make_shared( iin, " instanceof ", std::make_shared(interfaceType->GetCanonicalName())); auto instOfStatement = std::make_shared(); instOfStatement->expression = std::make_shared(iinNotNull, "&&", instOfCheck); instOfStatement->statements = std::make_shared(); instOfStatement->statements->Add(std::make_shared( std::make_shared(interfaceType->GetCanonicalName(), iin))); m->statements->Add(instOfStatement); auto ne = std::make_shared(interfaceType->GetCanonicalName() + ".Stub.Proxy"); ne->arguments.push_back(obj); m->statements->Add(std::make_shared(ne)); this->elements.push_back(m); } // ================================================= class ProxyClass : public Class { public: ProxyClass(const AidlInterface* interfaceType, const Options& options); ~ProxyClass() override; std::shared_ptr mRemote; }; ProxyClass::ProxyClass(const AidlInterface* interfaceType, const Options& options) : Class() { this->modifiers = PRIVATE | STATIC; this->what = Class::CLASS; this->type = interfaceType->GetCanonicalName() + ".Stub.Proxy"; this->interfaces.push_back(interfaceType->GetCanonicalName()); // IBinder mRemote mRemote = std::make_shared("android.os.IBinder", "mRemote"); this->elements.push_back(std::make_shared(PRIVATE, mRemote)); // Proxy() auto remote = std::make_shared("android.os.IBinder", "remote"); auto ctor = std::make_shared(); ctor->name = "Proxy"; ctor->statements = std::make_shared(); ctor->parameters.push_back(remote); ctor->statements->Add(std::make_shared(mRemote, remote)); this->elements.push_back(ctor); if (options.Version() > 0) { std::ostringstream code; code << "private int mCachedVersion = -1;\n"; this->elements.emplace_back(std::make_shared(code.str())); } if (!options.Hash().empty()) { std::ostringstream code; code << "private String mCachedHash = \"-1\";\n"; this->elements.emplace_back(std::make_shared(code.str())); } // IBinder asBinder() auto asBinder = std::make_shared(); asBinder->modifiers = PUBLIC | OVERRIDE; asBinder->returnType = "android.os.IBinder"; asBinder->name = "asBinder"; asBinder->statements = std::make_shared(); asBinder->statements->Add(std::make_shared(mRemote)); this->elements.push_back(asBinder); } ProxyClass::~ProxyClass() {} // ================================================= static void GenerateWriteToParcel(CodeWriter& out, const AidlTypenames& typenames, const AidlTypeSpecifier& type, const std::string& parcel, const std::string& var, uint32_t min_sdk_version, bool is_return_value) { WriteToParcelFor(CodeGeneratorContext{ .writer = out, .typenames = typenames, .type = type, .parcel = parcel, .var = var, .min_sdk_version = min_sdk_version, .write_to_parcel_flag = is_return_value ? "android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE" : "0", }); } static void GenerateWriteToParcel(std::shared_ptr addTo, const AidlTypenames& typenames, const AidlTypeSpecifier& type, const std::string& parcel, const std::string& var, uint32_t min_sdk_version, bool is_return_value) { string code; GenerateWriteToParcel(*CodeWriter::ForString(&code), typenames, type, parcel, var, min_sdk_version, is_return_value); addTo->Add(std::make_shared(code)); } void GenerateConstantDeclarations(CodeWriter& out, const AidlDefinedType& type) { for (const auto& constant : type.GetConstantDeclarations()) { const AidlTypeSpecifier& type = constant->GetType(); out << GenerateComments(*constant); out << GenerateAnnotations(*constant); out << "public static final " << type.Signature() << " " << constant->GetName() << " = " << constant->ValueString(ConstantValueDecorator) << ";\n"; } } static std::shared_ptr GenerateInterfaceMethod(const AidlInterface& iface, const AidlMethod& method) { auto decl = std::make_shared(); decl->comment = GenerateComments(method); decl->modifiers = PUBLIC; decl->returnType = JavaSignatureOf(method.GetType()); decl->name = method.GetName(); decl->annotations = JavaAnnotationsFor(method); // If the interface has some permission annotation, add it to the method. if (auto iface_annotation = JavaPermissionAnnotation(iface); iface_annotation) { decl->annotations.push_back(*iface_annotation); } for (const std::unique_ptr& arg : method.GetArguments()) { auto var = std::make_shared(JavaSignatureOf(arg->GetType()), arg->GetName()); var->annotations = JavaAnnotationsFor(arg->GetType()); decl->parameters.push_back(var); } decl->exceptions.push_back("android.os.RemoteException"); return decl; } // Visitor for the permission declared in the @EnforcePermission annotation. class PermissionVisitor { public: PermissionVisitor(CodeWriter* code, const AidlMethod& method) : code_(code), method_(method) {} ~PermissionVisitor() { code_->Dedent(); *code_ << "}\n"; } string Credentials() const { return "getCallingPid(), getCallingUid()"; } void Prologue() { *code_ << "/** Helper method to enforce permissions for " << method_.GetName() << " */\n"; *code_ << "protected void " << method_.GetName() << "_enforcePermission() " << "throws SecurityException {\n"; code_->Indent(); } void AddStaticArrayPermissions(const std::vector& permissions) { *code_ << "static final String[] PERMISSIONS_" << method_.GetName() << " = {" << Join(permissions, ", ") << "};\n"; } void operator()(const perm::AllOf& quantifier) { std::vector permissions; permissions.reserve(quantifier.operands.size()); for (auto const& permission : quantifier.operands) { permissions.push_back(android::aidl::perm::JavaFullName(permission)); } AddStaticArrayPermissions(permissions); Prologue(); *code_ << "mEnforcer.enforcePermissionAllOf(PERMISSIONS_" << method_.GetName() << ", " << Credentials() << ");\n"; } void operator()(const perm::AnyOf& quantifier) { std::vector permissions; permissions.reserve(quantifier.operands.size()); for (auto const& permission : quantifier.operands) { permissions.push_back(android::aidl::perm::JavaFullName(permission)); } AddStaticArrayPermissions(permissions); Prologue(); *code_ << "mEnforcer.enforcePermissionAnyOf(PERMISSIONS_" << method_.GetName() << ", " << Credentials() << ");\n"; } void operator()(const std::string& permission) { auto permissionName = android::aidl::perm::JavaFullName(permission); Prologue(); *code_ << "mEnforcer.enforcePermission(" << permissionName << ", " << Credentials() << ");\n"; } private: CodeWriter* code_; const AidlMethod& method_; }; static void GeneratePermissionMethod(const AidlInterface& iface, const AidlMethod& method, const std::shared_ptr& addTo) { string code; CodeWriterPtr writer = CodeWriter::ForString(&code); if (auto ifacePermExpr = iface.EnforceExpression(); ifacePermExpr) { std::visit(PermissionVisitor(writer.get(), method), *ifacePermExpr.get()); } else if (auto methodPermExpr = method.GetType().EnforceExpression(); methodPermExpr) { std::visit(PermissionVisitor(writer.get(), method), *methodPermExpr.get()); } writer->Close(); addTo->elements.push_back(std::make_shared(code)); } static void GenerateStubCode(const AidlMethod& method, bool oneway, std::shared_ptr transact_data, std::shared_ptr transact_reply, const AidlTypenames& typenames, std::shared_ptr statement_block, const Options& options) { // try and finally auto& statements = statement_block; auto realCall = std::make_shared(THIS_VALUE, method.GetName()); // args VariableFactory stubArgs("_arg"); { // keep this across different args in order to create the classloader // at most once. bool is_classloader_created = false; if (method.IsNew() && ShouldForceDowngradeFor(CommunicationSide::READ)) { auto if_statement = std::make_shared(); if_statement->expression = std::make_shared("true"); if_statement->statements = std::make_shared(); if_statement->statements->Add( std::make_shared("throw new android.os.RemoteException(\"Method " + method.GetName() + " is unimplemented.\")")); statements->Add(if_statement); } for (const std::unique_ptr& arg : method.GetArguments()) { std::shared_ptr v = stubArgs.Get(arg->GetType()); statements->Add(std::make_shared(v)); string code; CodeWriterPtr writer = CodeWriter::ForString(&code); if (arg->GetDirection() & AidlArgument::IN_DIR) { // "in/inout" parameter should be created from parcel. CodeGeneratorContext context{.writer = *(writer.get()), .typenames = typenames, .type = arg->GetType(), .parcel = transact_data->name, .var = v->name, .min_sdk_version = options.GetMinSdkVersion(), .is_classloader_created = &is_classloader_created}; CreateFromParcelFor(context); } else { // "out" parameter should be instantiated before calling the real impl. string java_type = InstantiableJavaSignatureOf(arg->GetType()); if (arg->GetType().IsDynamicArray()) { // dynamic array should be created with a passed length. string var_length = v->name + "_length"; (*writer) << "int " << var_length << " = data.readInt();\n"; (*writer) << "if (" << var_length << " < 0) {\n"; (*writer) << " " << v->name << " = null;\n"; (*writer) << "} else {\n"; (*writer) << " " << v->name << " = new " << java_type << "[" << var_length << "];\n"; (*writer) << "}\n"; } else if (arg->GetType().IsFixedSizeArray()) { // fixed-size array can be created with a known size string dimensions; for (auto dim : arg->GetType().GetFixedSizeArrayDimensions()) { dimensions += "[" + std::to_string(dim) + "]"; } (*writer) << v->name << " = new " << java_type << dimensions << ";\n"; } else { // otherwise, create a new instance with a default constructor (*writer) << v->name << " = new " << java_type << "();\n"; } } writer->Close(); statements->Add(std::make_shared(code)); realCall->arguments.push_back(v); } } // EOF check if (!method.GetArguments().empty() && options.GetMinSdkVersion() > 32u) { statements->Add(std::make_shared(transact_data, "enforceNoDataAvail")); } // the real call if (method.GetType().GetName() == "void") { statements->Add(realCall); if (!oneway) { // report that there were no exceptions auto ex = std::make_shared(transact_reply, "writeNoException"); statements->Add(ex); } } else { auto _result = std::make_shared(JavaSignatureOf(method.GetType()), "_result"); statements->Add(std::make_shared(_result, realCall)); if (!oneway) { // report that there were no exceptions auto ex = std::make_shared(transact_reply, "writeNoException"); statements->Add(ex); } // marshall the return value GenerateWriteToParcel(statements, typenames, method.GetType(), transact_reply->name, _result->name, options.GetMinSdkVersion(), /*is_return_value=*/true); } // out parameters int i = 0; for (const std::unique_ptr& arg : method.GetArguments()) { std::shared_ptr v = stubArgs.Get(i++); if (arg->GetDirection() & AidlArgument::OUT_DIR) { GenerateWriteToParcel(statements, typenames, arg->GetType(), transact_reply->name, v->name, options.GetMinSdkVersion(), /*is_return_value=*/true); } } } static void GenerateStubCase(const AidlMethod& method, const std::string& transactCodeName, bool oneway, const std::shared_ptr& stubClass, const AidlTypenames& typenames, const Options& options) { auto c = std::make_shared(transactCodeName); GenerateStubCode(method, oneway, stubClass->transact_data, stubClass->transact_reply, typenames, c->statements, options); c->statements->Add(std::make_shared()); stubClass->transact_switch_user->cases.push_back(c); } static void GenerateStubCaseOutline(const AidlMethod& method, const std::string& transactCodeName, bool oneway, const std::shared_ptr& stubClass, const AidlTypenames& typenames, const Options& options) { std::string outline_name = "onTransact$" + method.GetName() + "$"; // Generate an "outlined" method with the actual code. { auto transact_data = std::make_shared("android.os.Parcel", "data"); auto transact_reply = std::make_shared("android.os.Parcel", "reply"); auto onTransact_case = std::make_shared(); onTransact_case->modifiers = PRIVATE; onTransact_case->returnType = "boolean"; onTransact_case->name = outline_name; onTransact_case->parameters.push_back(transact_data); onTransact_case->parameters.push_back(transact_reply); onTransact_case->statements = std::make_shared(); onTransact_case->exceptions.push_back("android.os.RemoteException"); stubClass->elements.push_back(onTransact_case); GenerateStubCode(method, oneway, transact_data, transact_reply, typenames, onTransact_case->statements, options); onTransact_case->statements->Add(std::make_shared(TRUE_VALUE)); } // Generate the case dispatch. { auto c = std::make_shared(transactCodeName); auto helper_call = std::make_shared(THIS_VALUE, outline_name, std::vector>{ stubClass->transact_data, stubClass->transact_reply}); c->statements->Add(std::make_shared(helper_call)); stubClass->transact_switch_user->cases.push_back(c); } } template static std::string ArgList(const AidlMethod& method, Formatter formatter) { vector args; for (const auto& arg : method.GetArguments()) { args.push_back(std::invoke(formatter, *arg)); } return Join(args, ", "); } static std::string FormatArgForDecl(const AidlArgument& arg) { return JavaSignatureOf(arg.GetType()) + " " + arg.GetName(); } static void GenerateProxyMethod(CodeWriter& out, const AidlInterface& iface, const AidlMethod& method, const std::string& transactCodeName, bool oneway, const AidlTypenames& typenames, const Options& options) { bool is_void = method.GetType().GetName() == "void"; out << GenerateComments(method); out << "@Override public " << JavaSignatureOf(method.GetType()) << " " << method.GetName() << "(" << ArgList(method, FormatArgForDecl) << ") throws android.os.RemoteException\n{\n"; out.Indent(); if (method.IsNew() && ShouldForceDowngradeFor(CommunicationSide::WRITE)) { out << "if (true) {\n"; out << " throw new android.os.RemoteException(\"Method " + method.GetName() + " is unimplemented.\");\n"; out << "}\n"; } // the parcels if (options.GenRpc()) { out << "android.os.Parcel _data = android.os.Parcel.obtain(asBinder());\n"; } else { out << "android.os.Parcel _data = android.os.Parcel.obtain();\n"; } if (iface.IsSensitiveData()) { out << "_data.markSensitive();\n"; } if (!oneway) { out << "android.os.Parcel _reply = android.os.Parcel.obtain();\n"; } // the return value if (!is_void) { out << JavaSignatureOf(method.GetType()) << " _result;\n"; } out << "try {\n"; out.Indent(); // the interface identifier token: the DESCRIPTOR constant, marshalled as a // string out << "_data.writeInterfaceToken(DESCRIPTOR);\n"; // the parameters for (const std::unique_ptr& arg : method.GetArguments()) { AidlArgument::Direction dir = arg->GetDirection(); if (dir == AidlArgument::OUT_DIR && arg->GetType().IsDynamicArray()) { // In Java we pass a pre-allocated array for an 'out' argument. For transaction, // we pass the size of the array so that the remote can allocate the array with the same size. out << "_data.writeInt(" << arg->GetName() << ".length);\n"; } else if (dir & AidlArgument::IN_DIR) { GenerateWriteToParcel(out, typenames, arg->GetType(), "_data", arg->GetName(), options.GetMinSdkVersion(), /*is_return_value=*/false); } } std::vector flags; if (oneway) flags.push_back("android.os.IBinder.FLAG_ONEWAY"); if (iface.IsSensitiveData()) flags.push_back("android.os.IBinder.FLAG_CLEAR_BUF"); // the transact call out << "boolean _status = mRemote.transact(Stub." << transactCodeName << ", _data, " << (oneway ? "null" : "_reply") << ", " << (flags.empty() ? "0" : Join(flags, " | ")) << ");\n"; // TODO(b/151102494): annotation is applied on the return type if (method.GetType().IsPropagateAllowBlocking() && !oneway) { if (options.GetMinSdkVersion() < JAVA_PROPAGATE_VERSION) { out << "if (android.os.Build.VERSION.SDK_INT >= " + std::to_string(JAVA_PROPAGATE_VERSION) + ") { _reply.setPropagateAllowBlocking(); }\n"; } else { out << "_reply.setPropagateAllowBlocking();\n"; } } // If the transaction returns false, which means UNKNOWN_TRANSACTION, fall back to the local // method in the default impl, if set before. Otherwise, throw a RuntimeException if the interface // is versioned. We can't throw the exception for unversioned interface because that would be an // app breaking change. if (iface.IsJavaDefault() || options.Version() > 0) { out << "if (!_status) {\n"; out.Indent(); if (iface.IsJavaDefault()) { out << "if (getDefaultImpl() != null) {\n"; out.Indent(); if (is_void) { out << "getDefaultImpl()." << method.GetName() << "(" << ArgList(method, &AidlArgument::GetName) << ");\n"; out << "return;\n"; } else { out << "return getDefaultImpl()." << method.GetName() << "(" << ArgList(method, &AidlArgument::GetName) << ");\n"; } out.Dedent(); out << "}\n"; } // TODO(b/274144762): we shouldn't have different behavior for versioned interfaces // also this set to false for all exceptions, not just unimplemented methods. if (options.Version() > 0) { out << "throw new android.os.RemoteException(\"Method " << method.GetName() << " is unimplemented.\");\n"; } out.Dedent(); out << "}\n"; } if (!oneway) { // keep this across return value and arguments in order to create the // classloader at most once. bool is_classloader_created = false; // throw back exceptions. out << "_reply.readException();\n"; if (!is_void) { CreateFromParcelFor(CodeGeneratorContext{.writer = out, .typenames = typenames, .type = method.GetType(), .parcel = "_reply", .var = "_result", .min_sdk_version = options.GetMinSdkVersion(), .is_classloader_created = &is_classloader_created}); } // the out/inout parameters for (const std::unique_ptr& arg : method.GetArguments()) { if (arg->GetDirection() & AidlArgument::OUT_DIR) { ReadFromParcelFor(CodeGeneratorContext{.writer = out, .typenames = typenames, .type = arg->GetType(), .parcel = "_reply", .var = arg->GetName(), .min_sdk_version = options.GetMinSdkVersion(), .is_classloader_created = &is_classloader_created}); } } } out.Dedent(); out << "}\nfinally {\n"; out.Indent(); // returning and cleanup if (!oneway) { out << "_reply.recycle();\n"; } out << "_data.recycle();\n"; out.Dedent(); out << "}\n"; // finally if (!is_void) { out << "return _result;\n"; } out.Dedent(); out << "}\n"; // method body } static void GenerateMethods(const AidlInterface& iface, const AidlMethod& method, Class* interface, std::shared_ptr stubClass, std::shared_ptr proxyClass, int index, const AidlTypenames& typenames, const Options& options) { const bool oneway = method.IsOneway(); // == the TRANSACT_ constant ============================================= string transactCodeName = "TRANSACTION_"; transactCodeName += method.GetName(); auto transactCode = std::make_shared(STATIC | FINAL, std::make_shared("int", transactCodeName)); transactCode->value = StringPrintf("(android.os.IBinder.FIRST_CALL_TRANSACTION + %d)", index); stubClass->elements.push_back(transactCode); // getTransactionName if (options.GenTransactionNames() || options.GenTraces()) { auto c = std::make_shared(transactCodeName); c->statements->Add(std::make_shared( std::make_shared(method.GetName()))); stubClass->code_to_method_name_switch->cases.push_back(c); } // == the declaration in the interface =================================== std::shared_ptr decl; if (method.IsUserDefined()) { decl = GenerateInterfaceMethod(iface, method); } else { if (method.GetName() == kGetInterfaceVersion && options.Version() > 0) { std::ostringstream code; code << "public int " << kGetInterfaceVersion << "() " << "throws android.os.RemoteException;\n"; decl = std::make_shared(code.str()); } if (method.GetName() == kGetInterfaceHash && !options.Hash().empty()) { std::ostringstream code; code << "public String " << kGetInterfaceHash << "() " << "throws android.os.RemoteException;\n"; decl = std::make_shared(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) { GenerateStubCaseOutline(method, transactCodeName, oneway, stubClass, typenames, options); } else { GenerateStubCase(method, transactCodeName, oneway, stubClass, typenames, options); } if (iface.EnforceExpression() || method.GetType().EnforceExpression()) { GeneratePermissionMethod(iface, method, stubClass); } } else { if (method.GetName() == kGetInterfaceVersion && options.Version() > 0) { auto ifStatement = std::make_shared(); ifStatement->expression = std::make_shared("code == " + transactCodeName); std::ostringstream code; code << "reply.writeNoException();\n" << "reply.writeInt(" << kGetInterfaceVersion << "());\n" << "return true;\n"; ifStatement->statements->Add(std::make_shared(code.str())); stubClass->transact_if_statements_meta.push_back(ifStatement); } if (method.GetName() == kGetInterfaceHash && !options.Hash().empty()) { auto ifStatement = std::make_shared(); ifStatement->expression = std::make_shared("code == " + transactCodeName); std::ostringstream code; code << "reply.writeNoException();\n" << "reply.writeString(" << kGetInterfaceHash << "());\n" << "return true;\n"; ifStatement->statements->Add(std::make_shared(code.str())); stubClass->transact_if_statements_meta.push_back(ifStatement); } } // == the proxy method =================================================== string proxy_code; CodeWriterPtr writer = CodeWriter::ForString(&proxy_code); CodeWriter& code = *writer; if (method.IsUserDefined()) { GenerateProxyMethod(code, iface, method, transactCodeName, oneway, typenames, options); } else { if (method.GetName() == kGetInterfaceVersion && options.Version() > 0) { code << "@Override\n" << "public int " << kGetInterfaceVersion << "()" << " throws " << "android.os.RemoteException {\n" << " if (mCachedVersion == -1) {\n"; if (options.GenRpc()) { code << " android.os.Parcel data = android.os.Parcel.obtain(asBinder());\n"; } else { code << " android.os.Parcel data = android.os.Parcel.obtain();\n"; } code << " android.os.Parcel reply = android.os.Parcel.obtain();\n" << " try {\n" << " data.writeInterfaceToken(DESCRIPTOR);\n" << " boolean _status = mRemote.transact(Stub." << transactCodeName << ", " << "data, reply, 0);\n"; if (iface.IsJavaDefault()) { code << " if (!_status) {\n" << " if (getDefaultImpl() != null) {\n" << " return getDefaultImpl().getInterfaceVersion();\n" << " }\n" << " }\n"; } code << " reply.readException();\n" << " mCachedVersion = reply.readInt();\n" << " } finally {\n" << " reply.recycle();\n" << " data.recycle();\n" << " }\n" << " }\n" << " return mCachedVersion;\n" << "}\n"; } if (method.GetName() == kGetInterfaceHash && !options.Hash().empty()) { code << "@Override\n" << "public synchronized String " << kGetInterfaceHash << "()" << " throws " << "android.os.RemoteException {\n" << " if (\"-1\".equals(mCachedHash)) {\n"; if (options.GenRpc()) { code << " android.os.Parcel data = android.os.Parcel.obtain(asBinder());\n"; } else { code << " android.os.Parcel data = android.os.Parcel.obtain();\n"; } code << " android.os.Parcel reply = android.os.Parcel.obtain();\n" << " try {\n" << " data.writeInterfaceToken(DESCRIPTOR);\n" << " boolean _status = mRemote.transact(Stub." << transactCodeName << ", " << "data, reply, 0);\n"; if (iface.IsJavaDefault()) { code << " if (!_status) {\n" << " if (getDefaultImpl() != null) {\n" << " return getDefaultImpl().getInterfaceHash();\n" << " }\n" << " }\n"; } code << " reply.readException();\n" << " mCachedHash = reply.readString();\n" << " } finally {\n" << " reply.recycle();\n" << " data.recycle();\n" << " }\n" << " }\n" << " return mCachedHash;\n" << "}\n"; } } code.Close(); if (!proxy_code.empty()) { proxyClass->elements.push_back(std::make_shared(proxy_code)); } } static void GenerateInterfaceDescriptors(const Options& options, const AidlInterface* iface, Class* interface, std::shared_ptr stub, std::shared_ptr proxy) { // the interface descriptor transaction handler auto ifStatement = std::make_shared(); ifStatement->expression = std::make_shared("code == INTERFACE_TRANSACTION"); ifStatement->statements->Add(std::make_shared( stub->transact_reply, "writeString", std::vector>{stub->GetTransactDescriptor(nullptr)})); ifStatement->statements->Add(std::make_shared(TRUE_VALUE)); stub->transact_if_statements_meta.push_back(ifStatement); // and the proxy-side method returning the descriptor directly auto getDesc = std::make_shared(); getDesc->modifiers = PUBLIC; getDesc->returnType = "java.lang.String"; getDesc->name = "getInterfaceDescriptor"; getDesc->statements = std::make_shared(); getDesc->statements->Add( std::make_shared(std::make_shared("DESCRIPTOR"))); proxy->elements.push_back(getDesc); // add the DESCRIPTOR field to the interface class Class* classToAddDescriptor = interface; static std::set greylist = { #include "hiddenapi-greylist" }; if (greylist.find(iface->GetCanonicalName()) != greylist.end()) { // For app compatibility, we keep DESCRIPTOR to the stub class for // the interfaces that are in the greylist. classToAddDescriptor = stub.get(); } auto descriptor = std::make_shared( STATIC | FINAL | PUBLIC, std::make_shared("java.lang.String", "DESCRIPTOR")); descriptor->comment = "/** @hide */"; std::string name = iface->GetDescriptor(); // TODO(b/242862858): avoid differentiating behahavior. This is currently blocked // to fix because of a metalava lint which disallows running code to generate // static fields. if (options.IsStructured()) { // mangle the interface name at build time and demangle it at runtime, to avoid // being renamed by jarjar. See b/153843174 std::replace(name.begin(), name.end(), '.', '$'); descriptor->value = "\"" + name + "\".replace('$', '.')"; } else { descriptor->value = "\"" + name + "\""; } classToAddDescriptor->elements.push_back(descriptor); } // 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 ComputeOutlineMethods(const AidlInterface* iface, const std::shared_ptr stub, size_t outline_threshold, size_t non_outline_count) { AIDL_FATAL_IF(non_outline_count > outline_threshold, iface); // 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 methods; methods.reserve(iface->GetMethods().size()); for (const auto& 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 shared_ptr GenerateDefaultImplMethod(const AidlMethod& method) { auto default_method = std::make_shared(); default_method->comment = GenerateComments(method); default_method->modifiers = PUBLIC | OVERRIDE; default_method->returnType = JavaSignatureOf(method.GetType()); default_method->name = method.GetName(); default_method->statements = std::make_shared(); for (const auto& arg : method.GetArguments()) { default_method->parameters.push_back( std::make_shared(JavaSignatureOf(arg->GetType()), arg->GetName())); } default_method->exceptions.push_back("android.os.RemoteException"); if (method.GetType().GetName() != "void") { const string& defaultValue = DefaultJavaValueOf(method.GetType()); default_method->statements->Add( std::make_shared(StringPrintf("return %s;\n", defaultValue.c_str()))); } return default_method; } static shared_ptr GenerateDefaultImplClass(const AidlInterface& iface, const Options& options) { auto default_class = std::make_shared(); default_class->comment = "/** Default implementation for " + iface.GetName() + ". */"; default_class->modifiers = PUBLIC | STATIC; default_class->what = Class::CLASS; default_class->type = iface.GetCanonicalName() + ".Default"; default_class->interfaces.emplace_back(iface.GetCanonicalName()); for (const auto& m : iface.GetMethods()) { if (m->IsUserDefined()) { default_class->elements.emplace_back(GenerateDefaultImplMethod(*m)); } else { // These are called only when the remote side does not implement these // methods, which is normally impossible, because these methods are // automatically declared in the interface class and not implementing // them on the remote side causes a compilation error. But if the remote // side somehow managed to not implement it, that's an error and we // report the case by returning an invalid value here. if (m->GetName() == kGetInterfaceVersion && options.Version() > 0) { std::ostringstream code; code << "@Override\n" << "public int " << kGetInterfaceVersion << "() {\n" << " return 0;\n" << "}\n"; default_class->elements.emplace_back(std::make_shared(code.str())); } if (m->GetName() == kGetInterfaceHash && !options.Hash().empty()) { std::ostringstream code; code << "@Override\n" << "public String " << kGetInterfaceHash << "() {\n" << " return \"\";\n" << "}\n"; default_class->elements.emplace_back(std::make_shared(code.str())); } } } default_class->elements.emplace_back( std::make_shared("@Override\n" "public android.os.IBinder asBinder() {\n" " return null;\n" "}\n")); return default_class; } static shared_ptr GenerateDelegatorMethod(const AidlMethod& method) { auto delegator_method = std::make_shared(); delegator_method->comment = GenerateComments(method); delegator_method->modifiers = PUBLIC | OVERRIDE; delegator_method->returnType = JavaSignatureOf(method.GetType()); delegator_method->name = method.GetName(); delegator_method->statements = std::make_shared(); std::vector argNames; for (const auto& arg : method.GetArguments()) { delegator_method->parameters.push_back( std::make_shared(JavaSignatureOf(arg->GetType()), arg->GetName())); argNames.push_back(arg->GetName()); } delegator_method->exceptions.push_back("android.os.RemoteException"); std::string return_str; if (method.GetType().GetName() != "void") { return_str = "return "; } delegator_method->statements->Add( std::make_shared(return_str + "mImpl." + method.GetName() + "(" + android::base::Join(argNames, ",") + ");\n")); return delegator_method; } static shared_ptr GenerateDelegatorClass(const AidlInterface& iface, const Options& options) { auto delegator_class = std::make_shared(); delegator_class->comment = "/** Delegator implementation for " + iface.GetName() + ". */"; delegator_class->modifiers = PUBLIC | STATIC; delegator_class->what = Class::CLASS; delegator_class->type = iface.GetCanonicalName() + ".Delegator"; delegator_class->extends = iface.GetCanonicalName() + ".Stub"; // constructor delegator_class->elements.emplace_back( std::make_shared("public Delegator(" + iface.GetCanonicalName() + " impl) {\n" " this.mImpl = impl;\n" "}\n")); // meta methods if (!options.Hash().empty()) { delegator_class->elements.emplace_back( std::make_shared("@Override\n" "public String " + kGetInterfaceHash + "() throws android.os.RemoteException {\n" " return mImpl." + kGetInterfaceHash + "();\n" "}\n")); } if (options.Version() > 0) { delegator_class->elements.emplace_back( std::make_shared("@Override\n" "public int " + kGetInterfaceVersion + "() throws android.os.RemoteException {\n" " int implVer = mImpl." + kGetInterfaceVersion + "();\n" " return VERSION < implVer ? VERSION : implVer;\n" "}\n")); } // user defined methods for (const auto& m : iface.GetMethods()) { if (m->IsUserDefined()) { delegator_class->elements.emplace_back(GenerateDelegatorMethod(*m)); } } delegator_class->elements.emplace_back( std::make_shared(iface.GetCanonicalName() + " mImpl;\n")); return delegator_class; } static shared_ptr GenerateMaxTransactionId(int max_transaction_id) { auto getMaxTransactionId = std::make_shared(); getMaxTransactionId->comment = "/** @hide */"; getMaxTransactionId->modifiers = PUBLIC; getMaxTransactionId->returnType = "int"; getMaxTransactionId->name = "getMaxTransactionId"; getMaxTransactionId->statements = std::make_shared(); getMaxTransactionId->statements->Add(std::make_shared( std::make_shared(std::to_string(max_transaction_id)))); return getMaxTransactionId; } std::unique_ptr GenerateInterfaceClass(const AidlInterface* iface, const AidlTypenames& typenames, const Options& options) { // the interface class auto interface = std::make_unique(); interface->comment = GenerateComments(*iface); interface->modifiers = PUBLIC; interface->what = Class::INTERFACE; interface->type = iface->GetCanonicalName(); interface->interfaces.push_back("android.os.IInterface"); interface->annotations = JavaAnnotationsFor(*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 = "; if (options.IsLatestUnfrozenVersion()) { code << "true ? " << options.PreviousVersion() << " : " << options.Version() << ";\n"; } else { code << options.Version() << ";\n"; } interface->elements.emplace_back(std::make_shared(code.str())); } if (!options.Hash().empty() || options.IsLatestUnfrozenVersion()) { std::ostringstream code; if (options.IsLatestUnfrozenVersion()) { code << "public static final String HASH = \"" << options.PreviousHash() << "\";\n"; } else { code << "public static final String HASH = \"" << options.Hash() << "\";\n"; } interface->elements.emplace_back(std::make_shared(code.str())); } // the default impl class auto default_impl = GenerateDefaultImplClass(*iface, options); interface->elements.emplace_back(default_impl); // the delegator class if (iface->IsJavaDelegator()) { auto delegator = GenerateDelegatorClass(*iface, options); interface->elements.emplace_back(delegator); } // the stub inner class auto stub = std::make_shared(iface, options); interface->elements.push_back(stub); ComputeOutlineMethods(iface, stub, options.onTransact_outline_threshold_, options.onTransact_non_outline_count_); // the proxy inner class auto proxy = std::make_shared(iface, options); stub->elements.push_back(proxy); // stub and proxy support for getInterfaceDescriptor() GenerateInterfaceDescriptors(options, iface, interface.get(), stub, proxy); // all the declared constants of the interface string constants; GenerateConstantDeclarations(*CodeWriter::ForString(&constants), *iface); interface->elements.push_back(std::make_shared(constants)); // all the declared methods of the interface int max_transaction_id = 0; for (const auto& item : iface->GetMethods()) { GenerateMethods(*iface, *item, interface.get(), stub, proxy, item->GetId(), typenames, options); max_transaction_id = std::max(max_transaction_id, item->GetId()); } // getMaxTransactionId if (options.GenTransactionNames() || options.GenTraces()) { stub->elements.push_back(GenerateMaxTransactionId(max_transaction_id)); } // all the nested types string code; auto writer = CodeWriter::ForString(&code); for (const auto& nested : iface->GetNestedTypes()) { GenerateClass(*writer, *nested, typenames, options); } GenerateParcelHelpers(*writer, *iface, typenames, options); writer->Close(); interface->elements.push_back(std::make_shared(code)); if (iface->IsJavaDefault()) { // 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 = iface->GetCanonicalName(); stub->elements.emplace_back(std::make_shared( StringPrintf("public static boolean setDefaultImpl(%s impl) {\n" " // Only one user of this interface can use this function\n" " // at a time. This is a heuristic to detect if two different\n" " // users in the same process use this function.\n" " if (Stub.Proxy.sDefaultImpl != null) {\n" " throw new IllegalStateException(\"setDefaultImpl() called twice\");\n" " }\n" " if (impl != null) {\n" " Stub.Proxy.sDefaultImpl = impl;\n" " return true;\n" " }\n" " return false;\n" "}\n", i_name.c_str()))); stub->elements.emplace_back( std::make_shared(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(std::make_shared( StringPrintf("public static %s sDefaultImpl;\n", i_name.c_str()))); } stub->Finish(); return interface; } } // namespace java } // namespace aidl } // namespace android ./PaxHeaders.X/generate_ndk.cpp0100644 0000000 0000000 00000000034 15172120304 015426 xustar000000000 0000000 28 mtime=1776853188.3440000 generate_ndk.cpp0100644 0000000 0000000 00000172224 15172120304 012742 0ustar000000000 0000000 /* * Copyright (C) 2018, The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "generate_ndk.h" #include "aidl.h" #include "aidl_language.h" #include "aidl_to_common.h" #include "aidl_to_cpp_common.h" #include "aidl_to_ndk.h" #include "logging.h" #include namespace android { namespace aidl { namespace ndk { static constexpr const char* kDescriptor = "descriptor"; static constexpr const char* kVersion = "version"; static constexpr const char* kHash = "hash"; static constexpr const char* kCachedVersion = "_aidl_cached_version"; static constexpr const char* kCachedHash = "_aidl_cached_hash"; static constexpr const char* kCachedHashMutex = "_aidl_cached_hash_mutex"; namespace internals { // 4 outputs for NDK for each type: Header, BpHeader, BnHeader, Source void GenerateHeader(CodeWriter& out, const AidlTypenames& types, const AidlDefinedType& defined_type, const Options& options); void GenerateClientHeader(CodeWriter& out, const AidlTypenames& types, const AidlDefinedType& defined_type, const Options& options); void GenerateServerHeader(CodeWriter& out, const AidlTypenames& types, const AidlDefinedType& defined_type, const Options& options); void GenerateSource(CodeWriter& out, const AidlTypenames& types, const AidlDefinedType& defined_type, const Options& options); // Header contains ClassDecl of a root type void GenerateInterfaceClassDecl(CodeWriter& out, const AidlTypenames& types, const AidlInterface& iface, const Options& options); void GenerateParcelClassDecl(CodeWriter& out, const AidlTypenames& types, const AidlStructuredParcelable& parcelable, const Options& options); void GenerateParcelClassDecl(CodeWriter& out, const AidlTypenames& types, const AidlUnionDecl& union_decl, const Options& options); void GenerateEnumClassDecl(CodeWriter& out, const AidlTypenames& types, const AidlEnumDeclaration& enum_decl, const Options& options); // BpHeader/BnHeader for interface void GenerateClientHeader(CodeWriter& out, const AidlTypenames& types, const AidlInterface& defined_type, const Options& options); void GenerateServerHeader(CodeWriter& out, const AidlTypenames& types, const AidlInterface& defined_type, const Options& options); // Source for interface void GenerateSource(CodeWriter& out, const AidlTypenames& types, const AidlInterface& iface, const Options& options); void GenerateClassSource(CodeWriter& out, const AidlTypenames& types, const AidlInterface& defined_type, const Options& options); void GenerateClientSource(CodeWriter& out, const AidlTypenames& types, const AidlInterface& defined_type, const Options& options); void GenerateServerSource(CodeWriter& out, const AidlTypenames& types, const AidlInterface& defined_type, const Options& options); void GenerateInterfaceSource(CodeWriter& out, const AidlTypenames& types, const AidlInterface& defined_type, const Options& options); // Source for structured parcelable void GenerateParcelSource(CodeWriter& out, const AidlTypenames& types, const AidlStructuredParcelable& defined_type, const Options& options); // Source for union void GenerateParcelSource(CodeWriter& out, const AidlTypenames& types, const AidlUnionDecl& defined_type, const Options& options); // Compare headers so that and comes after other (probably) std headers. struct HeaderComp { static int rank(const string& a) { return base::StartsWith(a, "aidl/") ? 2 : base::StartsWith(a, "android/") ? 1 : 0; } bool operator()(const string& a, const string& b) const { return std::make_tuple(rank(a), a) < std::make_tuple(rank(b), b); } }; } // namespace internals using namespace internals; using cpp::ClassNames; using cpp::GetQualifiedName; void GenerateNdk(const string& output_file, const Options& options, const AidlTypenames& types, const AidlDefinedType& defined_type, const IoDelegate& io_delegate) { using GenFn = void (*)(CodeWriter & out, const AidlTypenames& types, const AidlDefinedType& defined_type, const Options& options); // Wrap Generate* function to handle CodeWriter for a file. auto gen = [&](auto file, GenFn fn) { unique_ptr writer(io_delegate.GetCodeWriter(file)); GenerateAutoGenHeader(*writer, options); fn(*writer, types, defined_type, options); AIDL_FATAL_IF(!writer->Close(), defined_type) << "I/O Error!"; }; gen(options.OutputHeaderDir() + NdkHeaderFile(defined_type, ClassNames::RAW), &GenerateHeader); gen(options.OutputHeaderDir() + NdkHeaderFile(defined_type, ClassNames::CLIENT), &GenerateClientHeader); gen(options.OutputHeaderDir() + NdkHeaderFile(defined_type, ClassNames::SERVER), &GenerateServerHeader); gen(output_file, &GenerateSource); } namespace internals { void EnterNdkNamespace(CodeWriter& out, const AidlDefinedType& defined_type) { out << "namespace aidl {\n"; cpp::EnterNamespace(out, defined_type); } void LeaveNdkNamespace(CodeWriter& out, const AidlDefinedType& defined_type) { cpp::LeaveNamespace(out, defined_type); out << "} // namespace aidl\n"; } static void StatusCheckGoto(CodeWriter& out) { out << "if (_aidl_ret_status != STATUS_OK) goto _aidl_error;\n\n"; } static void StatusCheckBreak(CodeWriter& out) { out << "if (_aidl_ret_status != STATUS_OK) break;\n\n"; } static void StatusCheckReturn(CodeWriter& out) { out << "if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status;\n\n"; } void GenerateHeaderIncludes(CodeWriter& out, const AidlTypenames& types, const AidlDefinedType& defined_type, const Options& options); void GenerateClassDecl(CodeWriter& out, const AidlTypenames& types, const AidlDefinedType& defined_type, const Options& options); void GenerateNestedTypeDecls(CodeWriter& out, const AidlTypenames& types, const AidlDefinedType& defined_type, const Options& options) { auto visit = [&](const auto& nested) { GenerateClassDecl(out, types, nested, options); }; AIDL_FATAL_IF(!TopologicalVisit(defined_type.GetNestedTypes(), visit), defined_type) << "Cycle detected."; } void GenerateHeaderDefinitions(CodeWriter& out, const AidlTypenames& types, const AidlDefinedType& defined_type, const Options& options) { struct Visitor : AidlVisitor { CodeWriter& out; const AidlTypenames& types; const Options& options; Visitor(CodeWriter& out, const AidlTypenames& types, const Options& options) : out(out), types(types), options(options) {} void Visit(const AidlEnumDeclaration& enum_decl) override { const auto backing_type = NdkNameOf(types, enum_decl.GetBackingType(), StorageMode::STACK); EnterNdkNamespace(out, enum_decl); out << cpp::GenerateEnumToString(enum_decl, backing_type); LeaveNdkNamespace(out, enum_decl); out << "namespace ndk {\n"; out << "namespace internal {\n"; out << cpp::GenerateEnumValues(enum_decl, {"aidl"}); out << "} // namespace internal\n"; out << "} // namespace ndk\n"; } void Visit(const AidlStructuredParcelable& parcelable) override { if (parcelable.IsGeneric()) { GenerateParcelSource(out, types, parcelable, options); } } void Visit(const AidlUnionDecl& union_decl) override { if (union_decl.IsGeneric()) { GenerateParcelSource(out, types, union_decl, options); } } } v(out, types, options); VisitTopDown(v, defined_type); } void GenerateHeader(CodeWriter& out, const AidlTypenames& types, const AidlDefinedType& defined_type, const Options& options) { out << "#pragma once\n\n"; GenerateHeaderIncludes(out, types, defined_type, options); cpp::GenerateForwardDecls(out, defined_type, true); EnterNdkNamespace(out, defined_type); GenerateClassDecl(out, types, defined_type, options); LeaveNdkNamespace(out, defined_type); GenerateHeaderDefinitions(out, types, defined_type, options); } void GenerateClientHeader(CodeWriter& out, const AidlTypenames& types, const AidlDefinedType& defined_type, const Options& options) { if (auto iface = AidlCast(defined_type); iface) { GenerateClientHeader(out, types, *iface, options); } else if (auto parcelable = AidlCast(defined_type); parcelable) { out << "#error TODO(b/111362593) defined_types do not have bp classes\n"; } else if (auto union_decl = AidlCast(defined_type); union_decl) { out << "#error TODO(b/111362593) defined_types do not have bp classes\n"; } else if (auto enum_decl = AidlCast(defined_type); enum_decl) { out << "#error TODO(b/111362593) enums do not have bp classes\n"; } else { AIDL_FATAL(defined_type) << "Unrecognized type sent for NDK generation."; } } void GenerateServerHeader(CodeWriter& out, const AidlTypenames& types, const AidlDefinedType& defined_type, const Options& options) { if (auto iface = AidlCast(defined_type); iface) { GenerateServerHeader(out, types, *iface, options); } else if (auto parcelable = AidlCast(defined_type); parcelable) { out << "#error TODO(b/111362593) defined_types do not have bn classes\n"; } else if (auto union_decl = AidlCast(defined_type); union_decl) { out << "#error TODO(b/111362593) defined_types do not have bn classes\n"; } else if (auto enum_decl = AidlCast(defined_type); enum_decl) { out << "#error TODO(b/111362593) enums do not have bn classes\n"; } else { AIDL_FATAL(defined_type) << "Unrecognized type sent for CPP generation."; } } void GenerateSource(CodeWriter& out, const AidlTypenames& types, const AidlDefinedType& defined_type, const Options& options) { struct Visitor : AidlVisitor { CodeWriter& out; const AidlTypenames& types; const Options& options; Visitor(CodeWriter& out, const AidlTypenames& types, const Options& options) : out(out), types(types), options(options) {} void Visit(const AidlInterface& interface) override { GenerateSource(out, types, interface, options); } void Visit(const AidlStructuredParcelable& parcelable) override { if (!parcelable.IsGeneric()) { GenerateParcelSource(out, types, parcelable, options); } } void Visit(const AidlUnionDecl& union_decl) override { if (!union_decl.IsGeneric()) { GenerateParcelSource(out, types, union_decl, options); } } void Visit(const AidlEnumDeclaration& enum_decl) override { if (!enum_decl.GetParentType()) { out << "// This file is intentionally left blank as placeholder for enum declaration.\n"; } } } v(out, types, options); VisitTopDown(v, defined_type); } void GenerateHeaderIncludes(CodeWriter& out, const AidlTypenames& types, const AidlDefinedType& defined_type, const Options& options) { // Collect implementation related headers and referenced defined types by recursivly visiting // nested types struct Visitor : AidlVisitor { const AidlTypenames& types; const Options& options; std::set includes; Visitor(const AidlTypenames& types, const Options& options) : types(types), options(options) {} // Collect includes for each type reference void Visit(const AidlTypeSpecifier& type) override { auto defined = type.GetDefinedType(); if (!defined) return; includes.insert(NdkHeaderFile(*defined, ClassNames::RAW, false /*use_os_sep*/)); } // Collect implementation-specific includes for each type definition void Visit(const AidlInterface& interface) override { AddCommonHeaders(interface); includes.insert("android/binder_interface_utils.h"); if (options.GenLog()) { includes.insert("functional"); includes.insert("chrono"); includes.insert("sstream"); } // For nested interfaces client/server classes are defined in the same header. // So we need includes for client/server class as well. if (interface.GetParentType()) { includes.insert("android/binder_ibinder.h"); if (options.GenTraces()) { includes.insert("android/trace.h"); } } } void Visit(const AidlStructuredParcelable& parcelable) override { AddCommonHeaders(parcelable); includes.insert("android/binder_interface_utils.h"); includes.insert("android/binder_parcelable_utils.h"); includes.insert("android/binder_to_string.h"); // used by toString() } void Visit(const AidlUnionDecl& union_decl) override { AddCommonHeaders(union_decl); includes.insert("android/binder_interface_utils.h"); includes.insert("android/binder_parcelable_utils.h"); includes.insert("android/binder_to_string.h"); // used by toString() auto union_headers = cpp::UnionWriter::GetHeaders(union_decl); includes.insert(std::begin(union_headers), std::end(union_headers)); } void Visit(const AidlEnumDeclaration& enum_decl) override { AddCommonHeaders(enum_decl); includes.insert("array"); includes.insert("android/binder_enums.h"); } void AddCommonHeaders(const AidlDefinedType& defined_type) { includes.insert("cstdint"); includes.insert("memory"); includes.insert("optional"); includes.insert("string"); includes.insert("vector"); if (defined_type.IsSensitiveData()) { includes.insert("android/binder_parcel_platform.h"); includes.insert("android/binder_ibinder_platform.h"); } } } v(types, options); VisitTopDown(v, defined_type); for (const auto& path : v.includes) { out << "#include <" << path << ">\n"; } out << "#ifdef BINDER_STABILITY_SUPPORT\n"; out << "#include \n"; out << "#endif // BINDER_STABILITY_SUPPORT\n"; out << "\n"; if (v.includes.count("cassert")) { // TODO(b/31559095) bionic on host should define __assert2 out << "#ifndef __BIONIC__\n#define __assert2(a,b,c,d) ((void)0)\n#endif\n\n"; } } void GenerateClassDecl(CodeWriter& out, const AidlTypenames& types, const AidlDefinedType& defined_type, const Options& options) { if (auto iface = AidlCast(defined_type); iface) { GenerateInterfaceClassDecl(out, types, *iface, options); } else if (auto parcelable = AidlCast(defined_type); parcelable) { GenerateParcelClassDecl(out, types, *parcelable, options); } else if (auto union_decl = AidlCast(defined_type); union_decl) { GenerateParcelClassDecl(out, types, *union_decl, options); } else if (auto enum_decl = AidlCast(defined_type); enum_decl) { GenerateEnumClassDecl(out, types, *enum_decl, options); } else { AIDL_FATAL(defined_type) << "Unrecognized type sent for NDK generation."; } } static void GenerateSourceIncludes(CodeWriter& out, const AidlTypenames& types, const AidlDefinedType& defined_type, const Options& options) { // Once in a .cpp file if (defined_type.GetParentType() != nullptr) { return; } const string self_header = NdkHeaderFile(defined_type, ClassNames::RAW, false /*use_os_sep*/); out << "#include \"" << self_header << "\"\n"; out << "\n"; std::set includes = {self_header}; includes.insert("android/binder_parcel_utils.h"); types.IterateTypes([&](const AidlDefinedType& a_defined_type) { if (a_defined_type.AsInterface() != nullptr) { includes.insert(NdkHeaderFile(a_defined_type, ClassNames::CLIENT, false /*use_os_sep*/)); includes.insert(NdkHeaderFile(a_defined_type, ClassNames::SERVER, false /*use_os_sep*/)); includes.insert(NdkHeaderFile(a_defined_type, ClassNames::RAW, false /*use_os_sep*/)); } }); struct Visitor : AidlVisitor { bool has_interface = false; void Visit(const AidlInterface&) override { has_interface = true; } } v; VisitTopDown(v, defined_type); if (v.has_interface && options.GenLog()) { includes.insert("android/binder_to_string.h"); } // Emit includes except self_header includes.erase(includes.find(self_header)); for (const auto& inc : includes) { out << "#include <" << inc << ">\n"; } out << "\n"; // Emit additional definition for gen_traces if (v.has_interface && options.GenTraces()) { out << "namespace {\n"; out << "struct ScopedTrace {\n"; out.Indent(); out << "inline explicit ScopedTrace(const char* name) { ATrace_beginSection(name); }\n"; out << "inline ~ScopedTrace() { ATrace_endSection(); }\n"; out.Dedent(); out << "};\n"; out << "} // namespace\n"; out << "\n"; } } static void GenerateConstantDeclarations(CodeWriter& out, const AidlTypenames& types, const AidlDefinedType& type) { for (const auto& constant : type.GetConstantDeclarations()) { const AidlTypeSpecifier& type = constant->GetType(); if (type.Signature() == "String") { out << "static const char*"; cpp::GenerateDeprecated(out, *constant); out << " " << constant->GetName() << ";\n"; } else if (type.Signature() == "float" || type.Signature() == "double") { out << "static constexpr " << NdkNameOf(types, type, StorageMode::STACK) << " "; out << constant->GetName(); cpp::GenerateDeprecated(out, *constant); out << " = " << constant->ValueString(ConstantValueDecorator) << ";\n"; } else { out << "enum : " << NdkNameOf(types, type, StorageMode::STACK) << " { "; out << constant->GetName(); cpp::GenerateDeprecated(out, *constant); out << " = " << constant->ValueString(ConstantValueDecorator) << " };\n"; } } } static void GenerateConstantDefinitions(CodeWriter& out, const AidlDefinedType& interface, const std::string& clazz, const std::string& tmpl_decl = "") { for (const auto& constant : interface.GetConstantDeclarations()) { const AidlConstantValue& value = constant->GetValue(); AIDL_FATAL_IF(value.GetType() == AidlConstantValue::Type::UNARY || value.GetType() == AidlConstantValue::Type::BINARY, value); if (value.GetType() == AidlConstantValue::Type::STRING) { out << tmpl_decl; out << "const char* " << clazz << "::" << constant->GetName() << " = " << constant->ValueString(ConstantValueDecorator) << ";\n"; } } } void GenerateSource(CodeWriter& out, const AidlTypenames& types, const AidlInterface& defined_type, const Options& options) { GenerateSourceIncludes(out, types, defined_type, options); EnterNdkNamespace(out, defined_type); GenerateClassSource(out, types, defined_type, options); GenerateClientSource(out, types, defined_type, options); GenerateServerSource(out, types, defined_type, options); GenerateInterfaceSource(out, types, defined_type, options); LeaveNdkNamespace(out, defined_type); } static std::string MethodId(const AidlMethod& m) { return "(FIRST_CALL_TRANSACTION + " + std::to_string(m.GetId()) + " /*" + m.GetName() + "*/)"; } static void GenerateClientMethodDefinition(CodeWriter& out, const AidlTypenames& types, const AidlInterface& defined_type, const AidlMethod& method, const Options& options) { const std::string q_name = GetQualifiedName(defined_type, ClassNames::CLIENT); const std::string clazz = ClassName(defined_type, ClassNames::CLIENT); out << NdkMethodDecl(types, method, q_name) << " {\n"; out.Indent(); out << "binder_status_t _aidl_ret_status = STATUS_OK;\n"; out << "::ndk::ScopedAStatus _aidl_status;\n"; if (method.GetName() == kGetInterfaceHash && !options.Hash().empty()) { out << "const std::lock_guard lock(" << kCachedHashMutex << ");\n"; out << "if (" << kCachedHash << " != \"-1\") {\n"; out.Indent(); out << "*_aidl_return = " << kCachedHash << ";\n" << "_aidl_status.set(AStatus_fromStatus(_aidl_ret_status));\n" << "return _aidl_status;\n"; out.Dedent(); out << "}\n"; } else if (method.GetName() == kGetInterfaceVersion && options.Version() > 0) { out << "if (" << kCachedVersion << " != -1) {\n"; out.Indent(); out << "*_aidl_return = " << kCachedVersion << ";\n" << "_aidl_status.set(AStatus_fromStatus(_aidl_ret_status));\n" << "return _aidl_status;\n"; out.Dedent(); out << "}\n"; } out << "::ndk::ScopedAParcel _aidl_in;\n"; out << "::ndk::ScopedAParcel _aidl_out;\n"; out << "\n"; if (options.GenLog()) { out << cpp::GenLogBeforeExecute(q_name, method, false /* isServer */, true /* isNdk */); } if (options.GenTraces()) { out << "ScopedTrace _aidl_trace(\"AIDL::" << to_string(options.TargetLanguage()) << "::" << ClassName(defined_type, ClassNames::INTERFACE) << "::" << method.GetName() << "::client\");\n"; } if (method.IsNew() && ShouldForceDowngradeFor(CommunicationSide::WRITE) && method.IsUserDefined()) { out << "if (true) {\n"; out << " _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION;\n"; out << " goto _aidl_error;\n"; out << "}\n"; } out << "_aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR());\n"; if (defined_type.IsSensitiveData()) { out << "AParcel_markSensitive(_aidl_in.get());\n"; } StatusCheckGoto(out); for (const auto& arg : method.GetArguments()) { const std::string var_name = cpp::BuildVarName(*arg); if (arg->IsIn()) { out << "_aidl_ret_status = "; const std::string prefix = (arg->IsOut() ? "*" : ""); WriteToParcelFor({out, types, arg->GetType(), "_aidl_in.get()", prefix + var_name}); out << ";\n"; StatusCheckGoto(out); } else if (arg->IsOut() && arg->GetType().IsDynamicArray()) { out << "_aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *" << var_name << ");\n"; StatusCheckGoto(out); } } out << "_aidl_ret_status = AIBinder_transact(\n"; out.Indent(); out << "asBinder().get(),\n"; out << MethodId(method) << ",\n"; out << "_aidl_in.getR(),\n"; out << "_aidl_out.getR(),\n"; std::vector flags; if (method.IsOneway()) flags.push_back("FLAG_ONEWAY"); if (defined_type.IsSensitiveData()) flags.push_back("FLAG_CLEAR_BUF"); out << (flags.empty() ? "0" : base::Join(flags, " | ")) << "\n"; out << "#ifdef BINDER_STABILITY_SUPPORT\n"; out << "| FLAG_PRIVATE_LOCAL\n"; out << "#endif // BINDER_STABILITY_SUPPORT\n"; out << ");\n"; out.Dedent(); // If the method is not implmented in the server side but the client has // provided the default implementation, call it instead of failing hard. const std::string iface = ClassName(defined_type, ClassNames::INTERFACE); out << "if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && "; out << iface << "::getDefaultImpl()) {\n"; out.Indent(); out << "_aidl_status = " << iface << "::getDefaultImpl()->" << method.GetName() << "("; out << NdkArgList(types, method, FormatArgNameOnly) << ");\n"; out << "goto _aidl_status_return;\n"; out.Dedent(); out << "}\n"; StatusCheckGoto(out); if (!method.IsOneway()) { out << "_aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR());\n"; StatusCheckGoto(out); out << "if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return;\n"; } if (method.GetType().GetName() != "void") { out << "_aidl_ret_status = "; ReadFromParcelFor({out, types, method.GetType(), "_aidl_out.get()", "_aidl_return"}); out << ";\n"; StatusCheckGoto(out); if (method.GetName() == kGetInterfaceHash && !options.Hash().empty()) { out << kCachedHash << " = *_aidl_return;\n"; } else if (method.GetName() == kGetInterfaceVersion && options.Version() > 0) { out << kCachedVersion << " = *_aidl_return;\n"; } } for (const AidlArgument* arg : method.GetOutArguments()) { out << "_aidl_ret_status = "; ReadFromParcelFor({out, types, arg->GetType(), "_aidl_out.get()", cpp::BuildVarName(*arg)}); out << ";\n"; StatusCheckGoto(out); } out << "_aidl_error:\n"; out << "_aidl_status.set(AStatus_fromStatus(_aidl_ret_status));\n"; out << "_aidl_status_return:\n"; if (options.GenLog()) { out << cpp::GenLogAfterExecute(q_name, defined_type, method, "_aidl_status", "_aidl_return", false /* isServer */, true /* isNdk */); } out << "return _aidl_status;\n"; out.Dedent(); out << "}\n"; } static void GenerateServerCaseDefinition(CodeWriter& out, const AidlTypenames& types, const AidlInterface& defined_type, const AidlMethod& method, const Options& options) { const string q_name = GetQualifiedName(defined_type, ClassNames::SERVER); out << "case " << MethodId(method) << ": {\n"; out.Indent(); if (defined_type.EnforceExpression() || method.GetType().EnforceExpression()) { out.Write("#error Permission checks not implemented for the ndk backend\n"); } if (method.IsNew() && ShouldForceDowngradeFor(CommunicationSide::READ) && method.IsUserDefined()) { out << "if (true) break;\n"; } for (const auto& arg : method.GetArguments()) { out << NdkNameOf(types, arg->GetType(), StorageMode::STACK) << " " << cpp::BuildVarName(*arg) << ";\n"; } if (method.GetType().GetName() != "void") { out << NdkNameOf(types, method.GetType(), StorageMode::STACK) << " _aidl_return;\n"; } out << "\n"; if (options.GenTraces()) { out << "ScopedTrace _aidl_trace(\"AIDL::" << to_string(options.TargetLanguage()) << "::" << ClassName(defined_type, ClassNames::INTERFACE) << "::" << method.GetName() << "::server\");\n"; } for (const auto& arg : method.GetArguments()) { const std::string var_name = cpp::BuildVarName(*arg); if (arg->IsIn()) { out << "_aidl_ret_status = "; ReadFromParcelFor({out, types, arg->GetType(), "_aidl_in", "&" + var_name}); out << ";\n"; StatusCheckBreak(out); } else if (arg->IsOut() && arg->GetType().IsDynamicArray()) { out << "_aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &" << var_name << ");\n"; StatusCheckBreak(out); } } if (options.GenLog()) { out << cpp::GenLogBeforeExecute(q_name, method, true /* isServer */, true /* isNdk */); } out << "::ndk::ScopedAStatus _aidl_status = _aidl_impl->" << method.GetName() << "(" << NdkArgList(types, method, FormatArgForCall) << ");\n"; if (options.GenLog()) { out << cpp::GenLogAfterExecute(q_name, defined_type, method, "_aidl_status", "_aidl_return", true /* isServer */, true /* isNdk */); } if (method.IsOneway()) { // For a oneway transaction, the kernel will have already returned a result. This is for the // in-process case when a oneway transaction is parceled/unparceled in the same process. out << "_aidl_ret_status = STATUS_OK;\n"; } else { out << "_aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get());\n"; StatusCheckBreak(out); out << "if (!AStatus_isOk(_aidl_status.get())) break;\n\n"; if (method.GetType().GetName() != "void") { out << "_aidl_ret_status = "; WriteToParcelFor({out, types, method.GetType(), "_aidl_out", "_aidl_return"}); out << ";\n"; StatusCheckBreak(out); } for (const AidlArgument* arg : method.GetOutArguments()) { out << "_aidl_ret_status = "; WriteToParcelFor({out, types, arg->GetType(), "_aidl_out", cpp::BuildVarName(*arg)}); out << ";\n"; StatusCheckBreak(out); } } out << "break;\n"; out.Dedent(); out << "}\n"; } static string OnTransactFuncName(const AidlInterface& interface) { string name = interface.GetCanonicalName(); std::replace(name.begin(), name.end(), '.', '_'); return "_aidl_" + name + "_onTransact"; } static string GlobalClassVarName(const AidlInterface& interface) { string name = interface.GetCanonicalName(); std::replace(name.begin(), name.end(), '.', '_'); return "_g_aidl_" + name + "_clazz"; } void GenerateClassSource(CodeWriter& out, const AidlTypenames& types, const AidlInterface& defined_type, const Options& options) { const std::string i_name = GetQualifiedName(defined_type, ClassNames::INTERFACE); const std::string q_name = GetQualifiedName(defined_type, ClassNames::SERVER); const string on_transact = OnTransactFuncName(defined_type); bool deprecated = defined_type.IsDeprecated() || std::any_of(defined_type.GetMethods().begin(), defined_type.GetMethods().end(), [](const auto& m) { return m->IsDeprecated(); }); if (deprecated) { out << "#pragma clang diagnostic push\n"; out << "#pragma clang diagnostic ignored \"-Wdeprecated\"\n"; } out << "static binder_status_t " << on_transact << "(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, " "AParcel* _aidl_out) {\n"; out.Indent(); out << "(void)_aidl_in;\n"; out << "(void)_aidl_out;\n"; out << "binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION;\n"; if (!defined_type.GetMethods().empty()) { // we know this cast is valid because this method is only called by the ICInterface // AIBinder_Class object which is associated with this class. out << "std::shared_ptr<" << q_name << "> _aidl_impl = std::static_pointer_cast<" << q_name << ">(::ndk::ICInterface::asInterface(_aidl_binder));\n"; out << "switch (_aidl_code) {\n"; out.Indent(); for (const auto& method : defined_type.GetMethods()) { GenerateServerCaseDefinition(out, types, defined_type, *method, options); } out.Dedent(); out << "}\n"; } else { out << "(void)_aidl_binder;\n"; out << "(void)_aidl_code;\n"; } out << "return _aidl_ret_status;\n"; out.Dedent(); out << "}\n\n"; out << "static AIBinder_Class* " << GlobalClassVarName(defined_type) << " = ::ndk::ICInterface::defineClass(" << i_name << "::" << kDescriptor << ", " << on_transact << ");\n\n"; if (deprecated) { out << "#pragma clang diagnostic pop\n"; } } void GenerateClientSource(CodeWriter& out, const AidlTypenames& types, const AidlInterface& defined_type, const Options& options) { const std::string q_name = GetQualifiedName(defined_type, ClassNames::CLIENT); const std::string clazz = ClassName(defined_type, ClassNames::CLIENT); out << q_name << "::" << clazz << "(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {}\n"; out << q_name << "::~" << clazz << "() {}\n"; if (options.GenLog()) { out << "std::function " << q_name << "::logFunc;\n"; } out << "\n"; for (const auto& method : defined_type.GetMethods()) { GenerateClientMethodDefinition(out, types, defined_type, *method, options); } } void GenerateServerSource(CodeWriter& out, const AidlTypenames& types, const AidlInterface& defined_type, const Options& options) { const std::string q_name = GetQualifiedName(defined_type, ClassNames::SERVER); const std::string clazz = ClassName(defined_type, ClassNames::SERVER); const std::string iface = ClassName(defined_type, ClassNames::INTERFACE); out << "// Source for " << clazz << "\n"; out << q_name << "::" << clazz << "() {}\n"; out << q_name << "::~" << clazz << "() {}\n"; if (options.GenLog()) { out << "std::function " << q_name << "::logFunc;\n"; } out << "::ndk::SpAIBinder " << q_name << "::createBinder() {\n"; out.Indent(); out << "AIBinder* binder = AIBinder_new(" << GlobalClassVarName(defined_type) << ", static_cast(this));\n"; out << "#ifdef BINDER_STABILITY_SUPPORT\n"; if (defined_type.IsVintfStability()) { out << "AIBinder_markVintfStability(binder);\n"; } else { out << "AIBinder_markCompilationUnitStability(binder);\n"; } out << "#endif // BINDER_STABILITY_SUPPORT\n"; out << "return ::ndk::SpAIBinder(binder);\n"; out.Dedent(); out << "}\n"; // Implement the meta methods for (const auto& method : defined_type.GetMethods()) { if (method->IsUserDefined()) { continue; } if (method->GetName() == kGetInterfaceVersion && options.Version() > 0) { out << NdkMethodDecl(types, *method, q_name) << " {\n"; out.Indent(); out << "*_aidl_return = " << iface << "::" << kVersion << ";\n"; out << "return ::ndk::ScopedAStatus(AStatus_newOk());\n"; out.Dedent(); out << "}\n"; } if (method->GetName() == kGetInterfaceHash && (!options.Hash().empty())) { out << NdkMethodDecl(types, *method, q_name) << " {\n"; out.Indent(); out << "*_aidl_return = " << iface << "::" << kHash << ";\n"; out << "return ::ndk::ScopedAStatus(AStatus_newOk());\n"; out.Dedent(); out << "}\n"; } } } void GenerateInterfaceSource(CodeWriter& out, const AidlTypenames& types, const AidlInterface& defined_type, const Options& options) { const std::string q_name = GetQualifiedName(defined_type, ClassNames::INTERFACE); const std::string clazz = ClassName(defined_type, ClassNames::INTERFACE); const std::string bp_clazz = ClassName(defined_type, ClassNames::CLIENT); out << "// Source for " << clazz << "\n"; out << "const char* " << q_name << "::" << kDescriptor << " = \"" << defined_type.GetDescriptor() << "\";\n"; out << q_name << "::" << clazz << "() {}\n"; out << q_name << "::~" << clazz << "() {}\n"; out << "\n"; GenerateConstantDefinitions(out, defined_type, q_name); out << "\n"; out << "std::shared_ptr<" << q_name << "> " << q_name << "::fromBinder(const ::ndk::SpAIBinder& binder) {\n"; out.Indent(); out << "if (!AIBinder_associateClass(binder.get(), " << GlobalClassVarName(defined_type) << ")) {\n"; out.Indent(); // since NDK users don't use weak symbol support, we don't check builtin available. We could // optionally check it if __ANDROID_UNAVAILABLE_SYMBOLS_ARE_WEAK__ is defined, but this would // also mean that app developers relying on this behavior would be missing test parity, and if // local transactions aren't supported, due to missing the descriptor API, they will need to // work around it a different way, so it's best to check based on __ANDROID_API__ out << "#if __ANDROID_API__ >= 31\n"; out << "const AIBinder_Class* originalClass = AIBinder_getClass(binder.get());\n"; out << "if (originalClass == nullptr) return nullptr;\n"; out << "if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) {\n"; out.Indent(); // parcel transactions in process, e.g. NDK<->Rust (okay..) out << "return ::ndk::SharedRefBase::make<" << GetQualifiedName(defined_type, ClassNames::CLIENT) << ">(binder);\n"; out.Dedent(); out << "}\n"; out << "#endif\n"; out << "return nullptr;\n"; out.Dedent(); out << "}\n"; out << "std::shared_ptr<::ndk::ICInterface> interface = " "::ndk::ICInterface::asInterface(binder.get());\n"; out << "if (interface) {\n"; out.Indent(); out << "return std::static_pointer_cast<" << clazz << ">(interface);\n"; out.Dedent(); out << "}\n"; out << "return ::ndk::SharedRefBase::make<" << GetQualifiedName(defined_type, ClassNames::CLIENT) << ">(binder);\n"; out.Dedent(); out << "}\n\n"; out << "binder_status_t " << q_name << "::writeToParcel(AParcel* parcel, const std::shared_ptr<" << clazz << ">& instance) {\n"; out.Indent(); out << "return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : " "nullptr);\n"; out.Dedent(); out << "}\n"; out << "binder_status_t " << q_name << "::readFromParcel(const AParcel* parcel, std::shared_ptr<" << clazz << ">* instance) {\n"; out.Indent(); out << "::ndk::SpAIBinder binder;\n"; out << "binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR());\n"; out << "if (status != STATUS_OK) return status;\n"; out << "*instance = " << clazz << "::fromBinder(binder);\n"; out << "return STATUS_OK;\n"; out.Dedent(); out << "}\n"; // defintion for static member setDefaultImpl out << "bool " << q_name << "::setDefaultImpl(const std::shared_ptr<" << clazz << ">& impl) {\n"; out.Indent(); out << "// Only one user of this interface can use this function\n"; out << "// at a time. This is a heuristic to detect if two different\n"; out << "// users in the same process use this function.\n"; out << "assert(!" << clazz << "::default_impl);\n"; out << "if (impl) {\n"; out.Indent(); out << clazz << "::default_impl = impl;\n"; out << "return true;\n"; out.Dedent(); out << "}\n"; out << "return false;\n"; out.Dedent(); out << "}\n"; // definition for static member getDefaultImpl out << "const std::shared_ptr<" << q_name << ">& " << q_name << "::getDefaultImpl() {\n"; out.Indent(); out << "return " << clazz << "::default_impl;\n"; out.Dedent(); out << "}\n"; // definition for the static field default_impl out << "std::shared_ptr<" << q_name << "> " << q_name << "::default_impl = nullptr;\n"; // default implementation for the Default class members const std::string defaultClazz = q_name + "Default"; for (const auto& method : defined_type.GetMethods()) { if (method->IsUserDefined()) { out << "::ndk::ScopedAStatus " << defaultClazz << "::" << method->GetName() << "(" << NdkArgList(types, *method, FormatArgNameUnused) << ") {\n"; out.Indent(); out << "::ndk::ScopedAStatus _aidl_status;\n"; out << "_aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION));\n"; out << "return _aidl_status;\n"; out.Dedent(); out << "}\n"; } else { if (method->GetName() == kGetInterfaceVersion && options.Version() > 0) { out << "::ndk::ScopedAStatus " << defaultClazz << "::" << method->GetName() << "(" << "int32_t* _aidl_return) {\n"; out.Indent(); out << "*_aidl_return = 0;\n"; out << "return ::ndk::ScopedAStatus(AStatus_newOk());\n"; out.Dedent(); out << "}\n"; } if (method->GetName() == kGetInterfaceHash && !options.Hash().empty()) { out << "::ndk::ScopedAStatus " << defaultClazz << "::" << method->GetName() << "(" << "std::string* _aidl_return) {\n"; out.Indent(); out << "*_aidl_return = \"\";\n"; out << "return ::ndk::ScopedAStatus(AStatus_newOk());\n"; out.Dedent(); out << "}\n"; } } } out << "::ndk::SpAIBinder " << defaultClazz << "::asBinder() {\n"; out.Indent(); out << "return ::ndk::SpAIBinder();\n"; out.Dedent(); out << "}\n"; out << "bool " << defaultClazz << "::isRemote() {\n"; out.Indent(); out << "return false;\n"; out.Dedent(); out << "}\n"; } void GenerateClientClassDecl(CodeWriter& out, const AidlTypenames& types, const AidlInterface& defined_type, const Options& options) { const std::string clazz = ClassName(defined_type, ClassNames::CLIENT); out << "class"; cpp::GenerateDeprecated(out, defined_type); out << " " << clazz << " : public ::ndk::BpCInterface<" << ClassName(defined_type, ClassNames::INTERFACE) << "> {\n"; out << "public:\n"; out.Indent(); out << "explicit " << clazz << "(const ::ndk::SpAIBinder& binder);\n"; out << "virtual ~" << clazz << "();\n"; out << "\n"; for (const auto& method : defined_type.GetMethods()) { out << NdkMethodDecl(types, *method) << " override"; cpp::GenerateDeprecated(out, *method); out << ";\n"; } if (options.Version() > 0) { out << "int32_t " << kCachedVersion << " = -1;\n"; } if (!options.Hash().empty()) { out << "std::string " << kCachedHash << " = \"-1\";\n"; out << "std::mutex " << kCachedHashMutex << ";\n"; } if (options.GenLog()) { out << cpp::kTransactionLogStruct; out << "static std::function logFunc;\n"; } out.Dedent(); out << "};\n"; } void GenerateClientHeader(CodeWriter& out, const AidlTypenames& types, const AidlInterface& defined_type, const Options& options) { out << "#pragma once\n\n"; out << "#include \"" << NdkHeaderFile(defined_type, ClassNames::RAW, false /*use_os_sep*/) << "\"\n"; out << "\n"; out << "#include \n"; if (options.GenLog()) { out << "#include \n"; out << "#include \n"; out << "#include \n"; } if (options.GenTraces()) { out << "#include \n"; } out << "\n"; EnterNdkNamespace(out, defined_type); GenerateClientClassDecl(out, types, defined_type, options); LeaveNdkNamespace(out, defined_type); } void GenerateDelegatorClassDecl(CodeWriter& out, const AidlTypenames& types, const AidlInterface& defined_type, const Options& options) { const std::string clazz = ClassName(defined_type, ClassNames::DELEGATOR_IMPL); const std::string iface = ClassName(defined_type, ClassNames::INTERFACE); const std::string bn_name = ClassName(defined_type, ClassNames::SERVER); const std::string kDelegateImplVarName = "_impl"; const std::string kStatusType = "::ndk::ScopedAStatus"; out << "class"; cpp::GenerateDeprecated(out, defined_type); out << " " << clazz << " : public " << bn_name << " {\n"; out << "public:\n"; out.Indent(); out << "explicit " << clazz << "(const std::shared_ptr<" << iface << "> &impl)" << " : " << kDelegateImplVarName << "(impl) {\n"; if (options.Version() > 0) { // TODO(b/222347502) If we need to support mismatched versions of delegator and // impl, this check will be removed. The NDK backend can't override the // getInterface* meta methods because they are marked "final". Removing // "final" changes the ABI and breaks prebuilts. out << " int32_t _impl_ver = 0;\n"; out << " if (!impl->" << kGetInterfaceVersion << "(&_impl_ver).isOk()) {;\n"; out << " __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, \"Delegator failed to get " "version of the implementation.\");\n"; out << " }\n"; out << " if (_impl_ver != " << iface << "::" << kVersion << ") {\n"; out << " __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, \"Mismatched versions of " "delegator and implementation is not allowed.\");\n"; out << " }\n"; } out << "}\n\n"; for (const auto& method : defined_type.GetMethods()) { if (method->IsUserDefined()) { out << kStatusType << " " << method->GetName() << "(" << NdkArgList(types, *method, FormatArgForDecl) << ") override"; cpp::GenerateDeprecated(out, *method); out << " {\n" << " return " << kDelegateImplVarName << "->" << method->GetName() << "(" << NdkArgList(types, *method, FormatArgNameOnly) << ");\n"; out << "}\n"; } } out.Dedent(); out << "protected:\n"; out.Indent(); out.Dedent(); out << "private:\n"; out.Indent(); out << "std::shared_ptr<" << iface << "> " << kDelegateImplVarName << ";\n"; out.Dedent(); out << "};\n\n"; } void GenerateServerClassDecl(CodeWriter& out, const AidlTypenames& types, const AidlInterface& defined_type, const Options& options) { const std::string clazz = ClassName(defined_type, ClassNames::SERVER); const std::string iface = ClassName(defined_type, ClassNames::INTERFACE); out << "class"; cpp::GenerateDeprecated(out, defined_type); out << " " << clazz << " : public ::ndk::BnCInterface<" << iface << "> {\n"; out << "public:\n"; out.Indent(); out << clazz << "();\n"; out << "virtual ~" << clazz << "();\n"; // Declare the meta methods for (const auto& method : defined_type.GetMethods()) { if (method->IsUserDefined()) { continue; } if (method->GetName() == kGetInterfaceVersion && options.Version() > 0) { out << NdkMethodDecl(types, *method) << " final;\n"; } else if (method->GetName() == kGetInterfaceHash && !options.Hash().empty()) { out << NdkMethodDecl(types, *method) << " final;\n"; } else { AIDL_FATAL(defined_type) << "Meta method '" << method->GetName() << "' is unimplemented."; } } if (options.GenLog()) { out << cpp::kTransactionLogStruct; out << "static std::function logFunc;\n"; } out.Dedent(); out << "protected:\n"; out.Indent(); out << "::ndk::SpAIBinder createBinder() override;\n"; out.Dedent(); out << "private:\n"; out.Indent(); out.Dedent(); out << "};\n"; } void GenerateServerHeader(CodeWriter& out, const AidlTypenames& types, const AidlInterface& defined_type, const Options& options) { out << "#pragma once\n\n"; out << "#include \"" << NdkHeaderFile(defined_type, ClassNames::RAW, false /*use_os_sep*/) << "\"\n"; out << "\n"; out << "#include \n"; // Needed for *Delegator classes while delegator version is required to be // the same as the implementation version // TODO(b/222347502) If we ever need to support mismatched versions of delegator and // impl, this include can be removed. out << "#include \n\n"; // TODO(b/31559095) bionic on host should define __assert2 out << "#ifndef __BIONIC__\n#ifndef __assert2\n#define __assert2(a,b,c,d) " "((void)0)\n#endif\n#endif\n"; out << "\n"; EnterNdkNamespace(out, defined_type); GenerateServerClassDecl(out, types, defined_type, options); GenerateDelegatorClassDecl(out, types, defined_type, options); LeaveNdkNamespace(out, defined_type); } void GenerateInterfaceClassDecl(CodeWriter& out, const AidlTypenames& types, const AidlInterface& defined_type, const Options& options) { const std::string clazz = ClassName(defined_type, ClassNames::INTERFACE); out << "class " << ClassName(defined_type, ClassNames::DELEGATOR_IMPL) << ";\n\n"; out << "class"; cpp::GenerateDeprecated(out, defined_type); out << " " << clazz << " : public ::ndk::ICInterface {\n"; out << "public:\n"; out.Indent(); out << "typedef " << ClassName(defined_type, ClassNames::DELEGATOR_IMPL) << " DefaultDelegator;\n"; out << "static const char* " << kDescriptor << ";\n"; out << clazz << "();\n"; out << "virtual ~" << clazz << "();\n"; out << "\n"; GenerateNestedTypeDecls(out, types, defined_type, options); GenerateConstantDeclarations(out, types, defined_type); if (options.Version() > 0) { if (options.IsLatestUnfrozenVersion()) { out << "static inline const int32_t " << kVersion << " = true ? " << std::to_string(options.PreviousVersion()) << " : " << std::to_string(options.Version()) << ";\n"; } else { out << "static inline const int32_t " << kVersion << " = " << std::to_string(options.Version()) << ";\n"; } } if (!options.Hash().empty()) { if (options.IsLatestUnfrozenVersion()) { out << "static inline const std::string " << kHash << " = true ? \"" << options.PreviousHash() << "\" : \"" << options.Hash() << "\";\n"; } else { out << "static inline const std::string " << kHash << " = \"" << options.Hash() << "\";\n"; } } for (const auto& method : defined_type.GetMethods()) { if (!method->IsUserDefined()) { continue; } out << "static constexpr uint32_t TRANSACTION_" << method->GetName() << " = " << "FIRST_CALL_TRANSACTION + " << std::to_string(method->GetId()) << ";\n"; } out << "\n"; out << "static std::shared_ptr<" << clazz << "> fromBinder(const ::ndk::SpAIBinder& binder);\n"; out << "static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr<" << clazz << ">& instance);"; out << "\n"; out << "static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr<" << clazz << ">* instance);"; out << "\n"; out << "static bool setDefaultImpl(const std::shared_ptr<" << clazz << ">& impl);"; out << "\n"; out << "static const std::shared_ptr<" << clazz << ">& getDefaultImpl();"; out << "\n"; for (const auto& method : defined_type.GetMethods()) { out << "virtual " << NdkMethodDecl(types, *method); cpp::GenerateDeprecated(out, *method); out << " = 0;\n"; } out.Dedent(); out << "private:\n"; out.Indent(); out << "static std::shared_ptr<" << clazz << "> default_impl;\n"; out.Dedent(); out << "};\n"; const std::string defaultClazz = clazz + "Default"; out << "class"; cpp::GenerateDeprecated(out, defined_type); out << " " << defaultClazz << " : public " << clazz << " {\n"; out << "public:\n"; out.Indent(); for (const auto& method : defined_type.GetMethods()) { if (method->IsUserDefined()) { out << NdkMethodDecl(types, *method) << " override"; cpp::GenerateDeprecated(out, *method); out << ";\n"; } else if (method->GetName() == kGetInterfaceVersion && options.Version() > 0) { out << NdkMethodDecl(types, *method) << " override;\n"; } else if (method->GetName() == kGetInterfaceHash && !options.Hash().empty()) { out << NdkMethodDecl(types, *method) << " override;\n"; } } out << "::ndk::SpAIBinder asBinder() override;\n"; out << "bool isRemote() override;\n"; out.Dedent(); out << "};\n"; // When an interface is nested, every class should be defined together here // because we don't have separate headers for them. // (e.g. IFoo, IFooDefault, BpFoo, BnFoo, IFooDelegator) if (defined_type.GetParentType()) { GenerateClientClassDecl(out, types, defined_type, options); GenerateServerClassDecl(out, types, defined_type, options); } } void GenerateParcelClassDecl(CodeWriter& out, const AidlTypenames& types, const AidlStructuredParcelable& defined_type, const Options& options) { const std::string clazz = ClassName(defined_type, ClassNames::RAW); cpp::ClangDiagnosticIgnoreDeprecated guard(out, cpp::HasDeprecatedField(defined_type)); out << cpp::TemplateDecl(defined_type); out << "class"; cpp::GenerateDeprecated(out, defined_type); out << " " << clazz << " {\n"; out << "public:\n"; out.Indent(); if (defined_type.IsFixedSize()) { out << "typedef std::true_type fixed_size;\n"; } else { out << "typedef std::false_type fixed_size;\n"; } out << "static const char* descriptor;\n"; out << "\n"; GenerateNestedTypeDecls(out, types, defined_type, options); for (const auto& variable : defined_type.GetFields()) { const auto& type = variable->GetType(); std::string cpp_type = NdkNameOf(types, type, StorageMode::STACK); out << cpp_type; cpp::GenerateDeprecated(out, *variable); out << " " << variable->GetName(); if (defined_type.IsFixedSize()) { int alignment = cpp::AlignmentOf(type, types); if (alignment > 0) { out << " __attribute__((aligned (" << std::to_string(alignment) << ")))"; } } if (variable->GetDefaultValue()) { out << " = " << variable->ValueString(ConstantValueDecorator); } else { // Some types needs to be explicitly initialized even when no default value is set. // - ParcelableHolder should be initialized with stability. // - enum should be zero initialized, otherwise the value will be indeterminate // - fixed-size arrays should be initialized, otherwise the value will be indeterminate if (type.GetName() == "ParcelableHolder") { if (defined_type.IsVintfStability()) { out << "{::ndk::STABILITY_VINTF}"; } else { out << "{::ndk::STABILITY_LOCAL}"; } } else if (types.GetEnumDeclaration(type) && !type.IsArray()) { out << " = " << cpp_type << "(0)"; } else if (type.IsFixedSizeArray() && !type.IsNullable()) { out << " = {{}}"; } } out << ";\n"; } out << "\n"; out << "binder_status_t readFromParcel(const AParcel* parcel);\n"; out << "binder_status_t writeToParcel(AParcel* parcel) const;\n"; out << "\n"; cpp::GenerateParcelableComparisonOperators(out, defined_type); out << "static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::" << (defined_type.IsVintfStability() ? "STABILITY_VINTF" : "STABILITY_LOCAL") << ";\n"; GenerateConstantDeclarations(out, types, defined_type); cpp::GenerateToString(out, defined_type); out.Dedent(); out << "};\n"; } void GenerateParcelSource(CodeWriter& out, const AidlTypenames& types, const AidlStructuredParcelable& defined_type, const Options& options) { std::string clazz = GetQualifiedName(defined_type); if (defined_type.IsGeneric()) { std::vector template_params; for (const auto& parameter : defined_type.GetTypeParameters()) { template_params.push_back(parameter); } clazz += base::StringPrintf("<%s>", base::Join(template_params, ", ").c_str()); } GenerateSourceIncludes(out, types, defined_type, options); EnterNdkNamespace(out, defined_type); out << cpp::TemplateDecl(defined_type); out << "const char* " << clazz << "::" << kDescriptor << " = \"" << defined_type.GetCanonicalName() << "\";\n"; out << "\n"; GenerateConstantDefinitions(out, defined_type, clazz, cpp::TemplateDecl(defined_type)); { cpp::ClangDiagnosticIgnoreDeprecated guard(out, cpp::HasDeprecatedField(defined_type)); out << cpp::TemplateDecl(defined_type); out << "binder_status_t " << clazz << "::readFromParcel(const AParcel* _aidl_parcel) {\n"; out.Indent(); out << "binder_status_t _aidl_ret_status = STATUS_OK;\n"; out << "int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel);\n"; out << "int32_t _aidl_parcelable_size = 0;\n"; out << "_aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size);\n"; StatusCheckReturn(out); out << "if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE;\n"; out << "if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE;\n"; for (const auto& variable : defined_type.GetFields()) { if (variable->IsNew() && ShouldForceDowngradeFor(CommunicationSide::READ)) { out << "if (false) {\n"; out.Indent(); } out << "if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= " "_aidl_parcelable_size) " "{\n" << " AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size);\n" << " return _aidl_ret_status;\n" << "}\n"; out << "_aidl_ret_status = "; ReadFromParcelFor( {out, types, variable->GetType(), "_aidl_parcel", "&" + variable->GetName()}); out << ";\n"; StatusCheckReturn(out); if (variable->IsNew() && ShouldForceDowngradeFor(CommunicationSide::READ)) { out.Dedent(); out << "}\n"; } } out << "AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size);\n" << "return _aidl_ret_status;\n"; out.Dedent(); out << "}\n"; out << cpp::TemplateDecl(defined_type); out << "binder_status_t " << clazz << "::writeToParcel(AParcel* _aidl_parcel) const {\n"; out.Indent(); out << "binder_status_t _aidl_ret_status;\n"; out << "size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel);\n"; out << "_aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0);\n"; StatusCheckReturn(out); for (const auto& variable : defined_type.GetFields()) { if (variable->IsNew() && ShouldForceDowngradeFor(CommunicationSide::WRITE)) { out << "if (false) {\n"; out.Indent(); } out << "_aidl_ret_status = "; WriteToParcelFor({out, types, variable->GetType(), "_aidl_parcel", variable->GetName()}); out << ";\n"; StatusCheckReturn(out); if (variable->IsNew() && ShouldForceDowngradeFor(CommunicationSide::WRITE)) { out.Dedent(); out << "}\n"; } } out << "size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel);\n"; out << "AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos);\n"; out << "AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos);\n"; out << "AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos);\n"; out << "return _aidl_ret_status;\n"; out.Dedent(); out << "}\n"; } out << "\n"; LeaveNdkNamespace(out, defined_type); } void GenerateParcelClassDecl(CodeWriter& out, const AidlTypenames& types, const AidlUnionDecl& defined_type, const Options& options) { const std::string clazz = ClassName(defined_type, ClassNames::RAW); cpp::ClangDiagnosticIgnoreDeprecated guard(out, cpp::HasDeprecatedField(defined_type)); cpp::UnionWriter uw{defined_type, types, [&](const AidlTypeSpecifier& type, const AidlTypenames& types) { return NdkNameOf(types, type, StorageMode::STACK); }, &ConstantValueDecorator}; out << cpp::TemplateDecl(defined_type); out << "class"; cpp::GenerateDeprecated(out, defined_type); out << " " << clazz << " {\n"; out << "public:\n"; out.Indent(); if (defined_type.IsFixedSize()) { out << "typedef std::true_type fixed_size;\n"; } else { out << "typedef std::false_type fixed_size;\n"; } out << "static const char* descriptor;\n"; out << "\n"; GenerateNestedTypeDecls(out, types, defined_type, options); uw.PublicFields(out); out << "binder_status_t readFromParcel(const AParcel* _parcel);\n"; out << "binder_status_t writeToParcel(AParcel* _parcel) const;\n"; out << "\n"; cpp::GenerateParcelableComparisonOperators(out, defined_type); out << "static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::" << (defined_type.IsVintfStability() ? "STABILITY_VINTF" : "STABILITY_LOCAL") << ";\n"; GenerateConstantDeclarations(out, types, defined_type); cpp::GenerateToString(out, defined_type); out.Dedent(); out << "private:\n"; out.Indent(); uw.PrivateFields(out); out.Dedent(); out << "};\n"; } void GenerateParcelSource(CodeWriter& out, const AidlTypenames& types, const AidlUnionDecl& defined_type, const Options& options) { std::string clazz = GetQualifiedName(defined_type); if (defined_type.IsGeneric()) { std::vector template_params; for (const auto& parameter : defined_type.GetTypeParameters()) { template_params.push_back(parameter); } clazz += base::StringPrintf("<%s>", base::Join(template_params, ", ").c_str()); } cpp::UnionWriter uw{defined_type, types, [&](const AidlTypeSpecifier& type, const AidlTypenames& types) { return NdkNameOf(types, type, StorageMode::STACK); }, &ConstantValueDecorator}; cpp::ParcelWriterContext ctx{ .status_type = "binder_status_t", .status_ok = "STATUS_OK", .status_bad = "STATUS_BAD_VALUE", .read_func = [&](CodeWriter& out, const std::string& var, const AidlTypeSpecifier& type) { ReadFromParcelFor({out, types, type, "_parcel", "&" + var}); }, .write_func = [&](CodeWriter& out, const std::string& value, const AidlTypeSpecifier& type) { WriteToParcelFor({out, types, type, "_parcel", value}); }, }; GenerateSourceIncludes(out, types, defined_type, options); EnterNdkNamespace(out, defined_type); out << cpp::TemplateDecl(defined_type); out << "const char* " << clazz << "::" << kDescriptor << " = \"" << defined_type.GetCanonicalName() << "\";\n"; out << "\n"; GenerateConstantDefinitions(out, defined_type, clazz, cpp::TemplateDecl(defined_type)); { cpp::ClangDiagnosticIgnoreDeprecated guard(out, cpp::HasDeprecatedField(defined_type)); out << cpp::TemplateDecl(defined_type); out << "binder_status_t " << clazz << "::readFromParcel(const AParcel* _parcel) {\n"; out.Indent(); uw.ReadFromParcel(out, ctx); out.Dedent(); out << "}\n"; out << cpp::TemplateDecl(defined_type); out << "binder_status_t " << clazz << "::writeToParcel(AParcel* _parcel) const {\n"; out.Indent(); uw.WriteToParcel(out, ctx); out.Dedent(); out << "}\n"; } out << "\n"; LeaveNdkNamespace(out, defined_type); } void GenerateEnumClassDecl(CodeWriter& out, const AidlTypenames& types, const AidlEnumDeclaration& enum_decl, const Options&) { cpp::GenerateEnumClassDecl(out, enum_decl, NdkNameOf(types, enum_decl.GetBackingType(), StorageMode::STACK), ConstantValueDecorator); out << "\n"; } } // namespace internals } // namespace ndk } // namespace aidl } // namespace android ./PaxHeaders.X/generate_ndk.h0100644 0000000 0000000 00000000034 15172120304 015073 xustar000000000 0000000 28 mtime=1776853188.3500000 generate_ndk.h0100644 0000000 0000000 00000001777 15172120304 012413 0ustar000000000 0000000 /* * Copyright (C) 2018, The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #pragma once #include #include #include "aidl_language.h" #include "options.h" namespace android { namespace aidl { namespace ndk { void GenerateNdk(const string& output_file, const Options& options, const AidlTypenames& types, const AidlDefinedType& defined_type, const IoDelegate& io_delegate); } // namespace ndk } // namespace aidl } // namespace android ./PaxHeaders.X/generate_rust.cpp0100644 0000000 0000000 00000000034 15172120304 015647 xustar000000000 0000000 28 mtime=1776853188.3510000 generate_rust.cpp0100644 0000000 0000000 00000140312 15172120304 013154 0ustar000000000 0000000 /* * 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 #include #include #include #include #include #include #include #include "aidl_to_common.h" #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"; struct MangledAliasVisitor : AidlVisitor { CodeWriter& out; MangledAliasVisitor(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); } template void VisitType(const T& type) { out << " pub use " << Qname(type) << " as " << Mangled(type) << ";\n"; } // Return a mangled name for a type (including AIDL package) template string Mangled(const T& type) const { ostringstream alias; for (const auto& component : Split(type.GetCanonicalName(), ".")) { alias << "_" << component.size() << "_" << component; } return alias.str(); } template string Typename(const T& type) const { if constexpr (std::is_same_v) { return ClassName(type, cpp::ClassNames::INTERFACE); } else { return type.GetName(); } } // Return a fully qualified name for a type in the current file (excluding AIDL package) template string Qname(const T& type) const { return Module(type) + "::r#" + Typename(type); } // Return a module name for a type (relative to the file) template string Module(const T& type) const { if (type.GetParentType()) { return Module(*type.GetParentType()) + "::r#" + type.GetName(); } else { return "super"; } } }; void GenerateMangledAliases(CodeWriter& out, const AidlDefinedType& type) { MangledAliasVisitor 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& arg : method.GetArguments()) { parameters += ", "; parameters += BuildArg(*arg, typenames, lifetime); } return fn_prefix + "fn r#" + 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& arg : method.GetArguments()) { parameters += ", "; parameters += BuildArg(*arg, typenames, Lifetime::NONE); } // Generate build_parcel helper. out << "fn build_parcel_" + method.GetName() + "(" + parameters + ") -> binder::Result {\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& 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::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& 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) = ::getDefaultImpl() {\n"; out << " return _aidl_default_impl.r#" << 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& 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 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: if (method.IsNew() && ShouldForceDowngradeFor(CommunicationSide::WRITE) && method.IsUserDefined()) { out << "if (true) {\n"; out << " return Err(binder::Status::from(binder::StatusCode::UNKNOWN_TRANSACTION));\n"; out << "} else {\n"; out.Indent(); } // 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::r#" << method.GetName() << ", _aidl_data, " << transact_flags << ");\n"; // Deserialize response. out << "self.read_response_" + method.GetName() + "(" + read_response_args + ")\n"; break; case MethodKind::READY_FUTURE: if (method.IsNew() && ShouldForceDowngradeFor(CommunicationSide::WRITE) && method.IsUserDefined()) { out << "if (true) {\n"; out << " return " "std::future::ready(Err(binder::Status::from(binder::StatusCode::UNKNOWN_" "TRANSACTION)));\n"; out << "} else {\n"; out.Indent(); } // 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::r#" << 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: if (method.IsNew() && ShouldForceDowngradeFor(CommunicationSide::WRITE) && method.IsUserDefined()) { out << "if (true) {\n"; out << " return " "Box::pin(std::future::ready(Err(binder::Status::from(binder::StatusCode::UNKNOWN_" "TRANSACTION))));\n"; out << "} else {\n"; out.Indent(); } // 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::r#" << 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; } if (method.IsNew() && ShouldForceDowngradeFor(CommunicationSide::WRITE) && method.IsUserDefined()) { out.Dedent(); out << "}\n"; } out.Dedent(); out << "}\n"; } void GenerateServerTransaction(CodeWriter& out, const AidlInterface& interface, const AidlMethod& method, const AidlTypenames& typenames) { out << "transactions::r#" << method.GetName() << " => {\n"; out.Indent(); if (method.IsUserDefined() && method.IsNew() && ShouldForceDowngradeFor(CommunicationSide::READ)) { out << "if (true) {\n"; out << " Err(binder::StatusCode::UNKNOWN_TRANSACTION)\n"; out << "} else {\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.r#" << 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> 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 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"; if (method.IsUserDefined() && method.IsNew() && ShouldForceDowngradeFor(CommunicationSide::READ)) { out.Dedent(); out << "}\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& arg : method->GetArguments()) { if (!args.empty()) { args += ", "; } args += kArgumentPrefix; args += arg->GetName(); } out << BuildMethod(*method, typenames) << " { " << "self.0.r#" << 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 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" || type.Signature() == "float" || type.Signature() == "double") { const_type = RustNameOf(type, typenames, StorageMode::VALUE, Lifetime::NONE); } else { AIDL_FATAL(value) << "Unrecognized constant type: " << type.Signature(); } GenerateDeprecated(out, *constant); out << "pub const r#" << 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> = " "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 << "

: 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(inner: T, rt: R, features: " "binder::BinderFeatures) -> binder::Strong\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 {\n"; code_writer->Indent(); *code_writer << "_inner: T,\n"; *code_writer << "_rt: R,\n"; code_writer->Dedent(); *code_writer << "}\n"; *code_writer << "impl binder::Interface for Wrapper where T: binder::Interface, R: " "Send + Sync + 'static {\n"; code_writer->Indent(); *code_writer << "fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() }\n"; *code_writer << "fn dump(&self, _writer: &mut dyn std::io::Write, _args: " "&[&std::ffi::CStr]) -> " "std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) }\n"; code_writer->Dedent(); *code_writer << "}\n"; *code_writer << "impl " << trait_name << " for Wrapper\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& 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.r#" << 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 r#" << 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>;\n"; *code_writer << "static DEFAULT_IMPL: std::sync::Mutex<" << default_ref_name << "> = std::sync::Mutex::new(None);\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) { if (options.IsLatestUnfrozenVersion()) { *code_writer << "pub const VERSION: i32 = if true {" << std::to_string(options.PreviousVersion()) << "} else {" << std::to_string(options.Version()) << "};\n"; } else { *code_writer << "pub const VERSION: i32 = " << std::to_string(options.Version()) << ";\n"; } } if (!options.Hash().empty() || options.IsLatestUnfrozenVersion()) { if (options.IsLatestUnfrozenVersion()) { *code_writer << "pub const HASH: &str = if true {\"" << options.PreviousHash() << "\"} else {\"" << options.Hash() << "\"};\n"; } else { *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 " << trait_name_async << "

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 RemoveUsed(std::set* params, const AidlTypeSpecifier& type) { if (!type.IsResolved()) { params->erase(type.GetName()); } if (type.IsGeneric()) { for (const auto& param : type.GetTypeParameters()) { RemoveUsed(params, *param); } } } std::set FreeParams(const AidlStructuredParcelable* parcel) { if (!parcel->IsGeneric()) { return std::set(); } auto typeParams = parcel->GetTypeParameters(); std::set unusedParams(typeParams.begin(), typeParams.end()); for (const auto& variable : parcel->GetFields()) { RemoveUsed(&unusedParams, variable->GetType()); } return unusedParams; } void WriteParams(CodeWriter& out, const AidlParameterizable* parcel, std::string extra) { if (parcel->IsGeneric()) { out << "<"; for (const auto& param : parcel->GetTypeParameters()) { out << param << extra << ","; } out << ">"; } } void WriteParams(CodeWriter& out, const AidlParameterizable* parcel) { WriteParams(out, parcel, ""); } void GenerateParcelBody(CodeWriter& out, const AidlStructuredParcelable* parcel, const AidlTypenames& typenames) { GenerateDeprecated(out, *parcel); out << "pub struct r#" << parcel->GetName(); WriteParams(out, parcel); out << " {\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 r#" << variable->GetName() << ": " << field_type << ",\n"; } for (const auto& unused_param : FreeParams(parcel)) { out << "_phantom_" << unused_param << ": std::marker::PhantomData<" << unused_param << ">,\n"; } out.Dedent(); out << "}\n"; } void GenerateParcelDefault(CodeWriter& out, const AidlStructuredParcelable* parcel) { out << "impl"; WriteParams(out, parcel, ": Default"); out << " Default for r#" << parcel->GetName(); WriteParams(out, parcel); out << " {\n"; out.Indent(); out << "fn default() -> Self {\n"; out.Indent(); out << "Self {\n"; out.Indent(); for (const auto& variable : parcel->GetFields()) { out << "r#" << 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"; } for (const auto& unused_param : FreeParams(parcel)) { out << "r#_phantom_" << unused_param << ": Default::default(),\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 (variable->IsNew() && ShouldForceDowngradeFor(CommunicationSide::WRITE)) { out << "if (false) {\n"; out.Indent(); } if (TypeNeedsOption(variable->GetType(), typenames)) { out << "let __field_ref = self.r#" << variable->GetName() << ".as_ref().ok_or(binder::StatusCode::UNEXPECTED_NULL)?;\n"; out << "subparcel.write(__field_ref)?;\n"; } else { out << "subparcel.write(&self.r#" << variable->GetName() << ")?;\n"; } if (variable->IsNew() && ShouldForceDowngradeFor(CommunicationSide::WRITE)) { out.Dedent(); out << "}\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()) { if (variable->IsNew() && ShouldForceDowngradeFor(CommunicationSide::READ)) { out << "if (false) {\n"; out.Indent(); } out << "if subparcel.has_more_data() {\n"; out.Indent(); if (TypeNeedsOption(variable->GetType(), typenames)) { out << "self.r#" << variable->GetName() << " = Some(subparcel.read()?);\n"; } else { out << "self.r#" << variable->GetName() << " = subparcel.read()?;\n"; } if (variable->IsNew() && ShouldForceDowngradeFor(CommunicationSide::READ)) { out.Dedent(); out << "}\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 r#" << 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"; WriteParams(out, parcel, ": Default"); out << " Default for r#" << parcel->GetName(); WriteParams(out, parcel); out << " {\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(); if (variable->IsNew() && ShouldForceDowngradeFor(CommunicationSide::WRITE)) { out << "if (true) {\n"; out << " Err(binder::StatusCode::BAD_VALUE)\n"; out << "} else {\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"; } if (variable->IsNew() && ShouldForceDowngradeFor(CommunicationSide::WRITE)) { out.Dedent(); out << "}\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(); if (variable->IsNew() && ShouldForceDowngradeFor(CommunicationSide::READ)) { out << "if (true) {\n"; out << " Err(binder::StatusCode::BAD_VALUE)\n"; out << "} else {\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"; if (variable->IsNew() && ShouldForceDowngradeFor(CommunicationSide::READ)) { out.Dedent(); out << "}\n"; } out.Dedent(); out << "}\n"; } out << "_ => {\n"; out << " Err(binder::StatusCode::BAD_VALUE)\n"; out << "}\n"; out.Dedent(); out << "}\n"; } template void GenerateParcelableTrait(CodeWriter& out, const ParcelableType* parcel, const AidlTypenames& typenames) { out << "impl"; WriteParams(out, parcel); out << " binder::Parcelable for r#" << parcel->GetName(); WriteParams(out, parcel); out << " {\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!(r#" << parcel->GetName(); WriteParams(out, parcel); out << ");\n"; out << "binder::impl_deserialize_for_parcelable!(r#" << parcel->GetName(); WriteParams(out, parcel); out << ");\n"; } template void GenerateMetadataTrait(CodeWriter& out, const ParcelableType* parcel) { out << "impl"; WriteParams(out, parcel); out << " binder::binder_impl::ParcelableMetadata for r#" << parcel->GetName(); WriteParams(out, parcel); out << " {\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 void GenerateRustParcel(CodeWriter* code_writer, const ParcelableType* parcel, const AidlTypenames& typenames) { vector derives = parcel->RustDerive(); // 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 derives.insert(derives.begin(), "Debug"); *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 << "r#" << 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 << "r#" << 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 r#" << 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); GenerateAutoGenHeader(*code_writer, options); // 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 << "#![cfg_attr(rustfmt, 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 ./PaxHeaders.X/generate_rust.h0100644 0000000 0000000 00000000034 15172120304 015314 xustar000000000 0000000 28 mtime=1776853188.3530000 generate_rust.h0100644 0000000 0000000 00000002007 15172120304 012617 0ustar000000000 0000000 /* * 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. */ #pragma once #include "aidl_language.h" #include "io_delegate.h" #include "options.h" #include namespace android { namespace aidl { namespace rust { void GenerateRust(const string& filename, const Options& options, const AidlTypenames& types, const AidlDefinedType& defined_type, const IoDelegate& io_delegate); } // namespace rust } // namespace aidl } // namespace android ./PaxHeaders.X/hiddenapi-greylist0100644 0000000 0000000 00000000034 15172120304 016004 xustar000000000 0000000 28 mtime=1776853188.3530000 hiddenapi-greylist0100644 0000000 0000000 00000056143 15172120304 013321 0ustar000000000 0000000 "android.accessibilityservice.IAccessibilityServiceClient", "android.accessibilityservice.IAccessibilityServiceConnection", "android.accounts.IAccountAuthenticator", "android.accounts.IAccountAuthenticatorResponse", "android.accounts.IAccountManager", "android.accounts.IAccountManagerResponse", "android.app.admin.IDeviceAdminService", "android.app.admin.IDevicePolicyManager", "android.app.backup.IBackupManager", "android.app.backup.IBackupManagerMonitor", "android.app.backup.IBackupObserver", "android.app.backup.IFullBackupRestoreObserver", "android.app.backup.IRestoreObserver", "android.app.backup.IRestoreSession", "android.app.backup.ISelectBackupTransportCallback", "android.app.IActivityController", "android.app.IActivityManager", "android.app.IActivityPendingResult", "android.app.IAlarmCompleteListener", "android.app.IAlarmListener", "android.app.IAlarmManager", "android.app.IApplicationThread", "android.app.IAppTask", "android.app.IAssistDataReceiver", "android.app.IBackupAgent", "android.app.IEphemeralResolver", "android.app.IInputForwarder", "android.app.IInstantAppResolver", "android.app.IInstrumentationWatcher", "android.app.INotificationManager", "android.app.IProcessObserver", "android.app.ISearchManager", "android.app.ISearchManagerCallback", "android.app.IServiceConnection", "android.app.IStopUserCallback", "android.app.ITaskStackListener", "android.app.ITransientNotification", "android.app.IUiAutomationConnection", "android.app.IUidObserver", "android.app.IUiModeManager", "android.app.IUserSwitchObserver", "android.app.IWallpaperManager", "android.app.IWallpaperManagerCallback", "android.app.job.IJobCallback", "android.app.job.IJobScheduler", "android.app.job.IJobService", "android.app.slice.ISliceListener", "android.app.slice.ISliceManager", "android.app.trust.IStrongAuthTracker", "android.app.trust.ITrustListener", "android.app.trust.ITrustManager", "android.app.usage.ICacheQuotaService", "android.app.usage.IStorageStatsManager", "android.app.usage.IUsageStatsManager", "android.bluetooth.IBluetooth", "android.bluetooth.IBluetoothA2dp", "android.bluetooth.IBluetoothA2dpSink", "android.bluetooth.IBluetoothAvrcpController", "android.bluetooth.IBluetoothAvrcpTarget", "android.bluetooth.IBluetoothCallback", "android.bluetooth.IBluetoothGatt", "android.bluetooth.IBluetoothGattCallback", "android.bluetooth.IBluetoothGattServerCallback", "android.bluetooth.IBluetoothHeadset", "android.bluetooth.IBluetoothHeadsetClient", "android.bluetooth.IBluetoothHeadsetPhone", "android.bluetooth.IBluetoothHealth", "android.bluetooth.IBluetoothHealthCallback", "android.bluetooth.IBluetoothHearingAid", "android.bluetooth.IBluetoothHidDevice", "android.bluetooth.IBluetoothHidDeviceCallback", "android.bluetooth.IBluetoothHidHost", "android.bluetooth.IBluetoothManager", "android.bluetooth.IBluetoothManagerCallback", "android.bluetooth.IBluetoothMap", "android.bluetooth.IBluetoothMapClient", "android.bluetooth.IBluetoothPan", "android.bluetooth.IBluetoothPbap", "android.bluetooth.IBluetoothPbapClient", "android.bluetooth.IBluetoothProfileServiceConnection", "android.bluetooth.IBluetoothSap", "android.bluetooth.IBluetoothSocketManager", "android.bluetooth.IBluetoothStateChangeCallback", "android.bluetooth.le.IAdvertisingSetCallback", "android.bluetooth.le.IPeriodicAdvertisingCallback", "android.bluetooth.le.IScannerCallback", "android.companion.ICompanionDeviceDiscoveryService", "android.companion.ICompanionDeviceDiscoveryServiceCallback", "android.companion.ICompanionDeviceManager", "android.companion.IFindDeviceCallback", "android.content.IClipboard", "android.content.IContentService", "android.content.IIntentReceiver", "android.content.IIntentSender", "android.content.IOnPrimaryClipChangedListener", "android.content.IRestrictionsManager", "android.content.ISyncAdapter", "android.content.ISyncAdapterUnsyncableAccountCallback", "android.content.ISyncContext", "android.content.ISyncServiceAdapter", "android.content.ISyncStatusObserver", "android.content.om.IOverlayManager", "android.content.pm.dex.IArtManager", "android.content.pm.dex.ISnapshotRuntimeProfileCallback", "android.content.pm.ICrossProfileApps", "android.content.pm.IDexModuleRegisterCallback", "android.content.pm.ILauncherApps", "android.content.pm.IOnAppsChangedListener", "android.content.pm.IOnPermissionsChangeListener", "android.content.pm.IOtaDexopt", "android.content.pm.IPackageDataObserver", "android.content.pm.IPackageDeleteObserver", "android.content.pm.IPackageDeleteObserver2", "android.content.pm.IPackageInstaller", "android.content.pm.IPackageInstallerCallback", "android.content.pm.IPackageInstallerSession", "android.content.pm.IPackageInstallObserver2", "android.content.pm.IPackageManager", "android.content.pm.IPackageManagerNative", "android.content.pm.IPackageMoveObserver", "android.content.pm.IPackageStatsObserver", "android.content.pm.IPinItemRequest", "android.content.pm.IShortcutService", "android.content.pm.permission.IRuntimePermissionPresenter", "android.database.IContentObserver", "android.hardware.biometrics.IBiometricPromptReceiver", "android.hardware.camera2.ICameraDeviceCallbacks", "android.hardware.camera2.ICameraDeviceUser", "android.hardware.display.IDisplayManager", "android.hardware.display.IDisplayManagerCallback", "android.hardware.display.IVirtualDisplayCallback", "android.hardware.fingerprint.IFingerprintClientActiveCallback", "android.hardware.fingerprint.IFingerprintService", "android.hardware.fingerprint.IFingerprintServiceLockoutResetCallback", "android.hardware.fingerprint.IFingerprintServiceReceiver", "android.hardware.hdmi.IHdmiControlCallback", "android.hardware.hdmi.IHdmiControlService", "android.hardware.hdmi.IHdmiDeviceEventListener", "android.hardware.hdmi.IHdmiHotplugEventListener", "android.hardware.hdmi.IHdmiInputChangeListener", "android.hardware.hdmi.IHdmiMhlVendorCommandListener", "android.hardware.hdmi.IHdmiRecordListener", "android.hardware.hdmi.IHdmiSystemAudioModeChangeListener", "android.hardware.hdmi.IHdmiVendorCommandListener", "android.hardware.ICamera", "android.hardware.ICameraClient", "android.hardware.ICameraService", "android.hardware.ICameraServiceListener", "android.hardware.ICameraServiceProxy", "android.hardware.IConsumerIrService", "android.hardware.input.IInputDevicesChangedListener", "android.hardware.input.IInputManager", "android.hardware.input.ITabletModeChangedListener", "android.hardware.ISerialManager", "android.hardware.location.IActivityRecognitionHardware", "android.hardware.location.IActivityRecognitionHardwareClient", "android.hardware.location.IActivityRecognitionHardwareSink", "android.hardware.location.IActivityRecognitionHardwareWatcher", "android.hardware.location.IContextHubCallback", "android.hardware.location.IContextHubClient", "android.hardware.location.IContextHubClientCallback", "android.hardware.location.IContextHubService", "android.hardware.location.IContextHubTransactionCallback", "android.hardware.location.IGeofenceHardware", "android.hardware.location.IGeofenceHardwareCallback", "android.hardware.location.IGeofenceHardwareMonitorCallback", "android.hardware.radio.IAnnouncementListener", "android.hardware.radio.ICloseHandle", "android.hardware.radio.IRadioService", "android.hardware.radio.ITuner", "android.hardware.radio.ITunerCallback", "android.hardware.soundtrigger.IRecognitionStatusCallback", "android.hardware.usb.IUsbManager", "android.location.IBatchedLocationCallback", "android.location.ICountryDetector", "android.location.ICountryListener", "android.location.IFusedGeofenceHardware", "android.location.IGeocodeProvider", "android.location.IGeofenceProvider", "android.location.IGnssMeasurementsListener", "android.location.IGnssNavigationMessageListener", "android.location.IGnssStatusListener", "android.location.IGnssStatusProvider", "android.location.IGpsGeofenceHardware", "android.location.ILocationListener", "android.location.ILocationManager", "android.location.INetInitiatedListener", "android.media.audiopolicy.IAudioPolicyCallback", "android.media.IAudioFocusDispatcher", "android.media.IAudioRoutesObserver", "android.media.IAudioServerStateDispatcher", "android.media.IAudioService", "android.media.IMediaHTTPConnection", "android.media.IMediaHTTPService", "android.media.IMediaResourceMonitor", "android.media.IMediaRouterClient", "android.media.IMediaRouterService", "android.media.IMediaScannerListener", "android.media.IMediaScannerService", "android.media.IPlaybackConfigDispatcher", "android.media.IPlayer", "android.media.IRecordingConfigDispatcher", "android.media.IRemoteDisplayCallback", "android.media.IRemoteDisplayProvider", "android.media.IRemoteVolumeController", "android.media.IRemoteVolumeObserver", "android.media.IRingtonePlayer", "android.media.ISessionTokensListener", "android.media.IVolumeController", "android.media.midi.IBluetoothMidiService", "android.media.midi.IMidiDeviceListener", "android.media.midi.IMidiDeviceOpenCallback", "android.media.midi.IMidiDeviceServer", "android.media.midi.IMidiManager", "android.media.projection.IMediaProjection", "android.media.projection.IMediaProjectionCallback", "android.media.projection.IMediaProjectionManager", "android.media.projection.IMediaProjectionWatcherCallback", "android.media.session.IActiveSessionsListener", "android.media.session.ICallback", "android.media.session.IOnMediaKeyListener", "android.media.session.IOnVolumeKeyLongPressListener", "android.media.session.ISession", "android.media.session.ISessionCallback", "android.media.session.ISessionController", "android.media.session.ISessionControllerCallback", "android.media.session.ISessionManager", "android.media.soundtrigger.ISoundTriggerDetectionService", "android.media.soundtrigger.ISoundTriggerDetectionServiceClient", "android.media.tv.ITvInputClient", "android.media.tv.ITvInputHardware", "android.media.tv.ITvInputHardwareCallback", "android.media.tv.ITvInputManager", "android.media.tv.ITvInputManagerCallback", "android.media.tv.ITvInputService", "android.media.tv.ITvInputServiceCallback", "android.media.tv.ITvInputSession", "android.media.tv.ITvInputSessionCallback", "android.media.tv.ITvRemoteProvider", "android.media.tv.ITvRemoteServiceInput", "android.net.ICaptivePortal", "android.net.IConnectivityManager", "android.net.IEthernetManager", "android.net.IEthernetServiceListener", "android.net.IIpConnectivityMetrics", "android.net.IIpSecService", "android.net.INetd", "android.net.INetdEventCallback", "android.net.INetworkManagementEventObserver", "android.net.INetworkPolicyListener", "android.net.INetworkPolicyManager", "android.net.INetworkRecommendationProvider", "android.net.INetworkScoreCache", "android.net.INetworkScoreService", "android.net.INetworkStatsService", "android.net.INetworkStatsSession", "android.net.ITetheringStatsProvider", "android.net.nsd.INsdManager", "android.net.sip.ISipService", "android.net.sip.ISipSession", "android.net.sip.ISipSessionListener", "android.net.wifi.aware.IWifiAwareDiscoverySessionCallback", "android.net.wifi.aware.IWifiAwareEventCallback", "android.net.wifi.aware.IWifiAwareMacAddressProvider", "android.net.wifi.aware.IWifiAwareManager", "android.net.wifi.hotspot2.IProvisioningCallback", "android.net.wifi.ISoftApCallback", "android.net.wifi.IWifiManager", "android.net.wifi.IWifiScanner", "android.net.wifi.p2p.IWifiP2pManager", "android.net.wifi.rtt.IRttCallback", "android.net.wifi.rtt.IWifiRttManager", "android.nfc.IAppCallback", "android.nfc.INfcAdapter", "android.nfc.INfcAdapterExtras", "android.nfc.INfcCardEmulation", "android.nfc.INfcDta", "android.nfc.INfcFCardEmulation", "android.nfc.INfcTag", "android.nfc.INfcUnlockHandler", "android.nfc.ITagRemovedCallback", "android.os.IBatteryPropertiesListener", "android.os.IBatteryPropertiesRegistrar", "android.os.ICancellationSignal", "android.os.IDeviceIdentifiersPolicyService", "android.os.IDeviceIdleController", "android.os.IHardwarePropertiesManager", "android.os.IIncidentManager", "android.os.IIncidentReportStatusListener", "android.os.IInstalld", "android.os.IMaintenanceActivityListener", "android.os.IMessenger", "android.os.INetworkActivityListener", "android.os.INetworkManagementService", "android.os.IPermissionController", "android.os.IPowerManager", "android.os.IProcessInfoService", "android.os.IProgressListener", "android.os.IRecoverySystem", "android.os.IRecoverySystemProgressListener", "android.os.IRemoteCallback", "android.os.ISchedulingPolicyService", "android.os.IStatsCompanionService", "android.os.IStatsManager", "android.os.IStoraged", "android.os.ISystemUpdateManager", "android.os.IThermalEventListener", "android.os.IThermalService", "android.os.IUpdateEngine", "android.os.IUpdateEngineCallback", "android.os.IUpdateLock", "android.os.IUserManager", "android.os.IVibratorService", "android.os.IVold", "android.os.IVoldListener", "android.os.IVoldTaskListener", "android.os.storage.IObbActionListener", "android.os.storage.IStorageEventListener", "android.os.storage.IStorageManager", "android.os.storage.IStorageShutdownObserver", "android.print.ILayoutResultCallback", "android.print.IPrintDocumentAdapter", "android.print.IPrintDocumentAdapterObserver", "android.print.IPrinterDiscoveryObserver", "android.print.IPrintJobStateChangeListener", "android.print.IPrintManager", "android.print.IPrintServicesChangeListener", "android.print.IPrintSpooler", "android.print.IPrintSpoolerCallbacks", "android.print.IPrintSpoolerClient", "android.print.IWriteResultCallback", "android.printservice.IPrintService", "android.printservice.IPrintServiceClient", "android.printservice.recommendation.IRecommendationsChangeListener", "android.printservice.recommendation.IRecommendationService", "android.printservice.recommendation.IRecommendationServiceCallbacks", "android.se.omapi.ISecureElementChannel", "android.se.omapi.ISecureElementListener", "android.se.omapi.ISecureElementReader", "android.se.omapi.ISecureElementService", "android.se.omapi.ISecureElementSession", "android.security.IConfirmationPromptCallback", "android.security.IKeyChainAliasCallback", "android.security.IKeyChainService", "android.security.IKeystoreService", "android.security.keymaster.IKeyAttestationApplicationIdProvider", "android.service.autofill.IAutofillFieldClassificationService", "android.service.autofill.IAutoFillService", "android.service.autofill.IFillCallback", "android.service.autofill.ISaveCallback", "android.service.carrier.ICarrierMessagingCallback", "android.service.carrier.ICarrierMessagingService", "android.service.carrier.ICarrierService", "android.service.chooser.IChooserTargetResult", "android.service.chooser.IChooserTargetService", "android.service.dreams.IDreamManager", "android.service.dreams.IDreamService", "android.service.euicc.IDeleteSubscriptionCallback", "android.service.euicc.IDownloadSubscriptionCallback", "android.service.euicc.IEraseSubscriptionsCallback", "android.service.euicc.IEuiccService", "android.service.euicc.IGetDefaultDownloadableSubscriptionListCallback", "android.service.euicc.IGetDownloadableSubscriptionMetadataCallback", "android.service.euicc.IGetEidCallback", "android.service.euicc.IGetEuiccInfoCallback", "android.service.euicc.IGetEuiccProfileInfoListCallback", "android.service.euicc.IGetOtaStatusCallback", "android.service.euicc.IOtaStatusChangedCallback", "android.service.euicc.IRetainSubscriptionsForFactoryResetCallback", "android.service.euicc.ISwitchToSubscriptionCallback", "android.service.euicc.IUpdateSubscriptionNicknameCallback", "android.service.media.IMediaBrowserService", "android.service.media.IMediaBrowserServiceCallbacks", "android.service.notification.IConditionListener", "android.service.notification.IConditionProvider", "android.service.notification.INotificationListener", "android.service.notification.IStatusBarNotificationHolder", "android.service.oemlock.IOemLockService", "android.service.persistentdata.IPersistentDataBlockService", "android.service.quicksettings.IQSService", "android.service.quicksettings.IQSTileService", "android.service.resolver.IResolverRankerResult", "android.service.resolver.IResolverRankerService", "android.service.settings.suggestions.ISuggestionService", "android.service.textclassifier.ITextClassificationCallback", "android.service.textclassifier.ITextClassifierService", "android.service.textclassifier.ITextLinksCallback", "android.service.textclassifier.ITextSelectionCallback", "android.service.trust.ITrustAgentService", "android.service.trust.ITrustAgentServiceCallback", "android.service.voice.IVoiceInteractionService", "android.service.voice.IVoiceInteractionSession", "android.service.voice.IVoiceInteractionSessionService", "android.service.vr.IPersistentVrStateCallbacks", "android.service.vr.IVrListener", "android.service.vr.IVrManager", "android.service.vr.IVrStateCallbacks", "android.service.wallpaper.IWallpaperConnection", "android.service.wallpaper.IWallpaperEngine", "android.service.wallpaper.IWallpaperService", "android.speech.IRecognitionListener", "android.speech.IRecognitionService", "android.speech.tts.ITextToSpeechCallback", "android.speech.tts.ITextToSpeechService", "android.telephony.data.IDataService", "android.telephony.data.IDataServiceCallback", "android.telephony.INetworkService", "android.telephony.INetworkServiceCallback", "android.telephony.mbms.IDownloadProgressListener", "android.telephony.mbms.IDownloadStatusListener", "android.telephony.mbms.IMbmsDownloadSessionCallback", "android.telephony.mbms.IMbmsStreamingSessionCallback", "android.telephony.mbms.IStreamingServiceCallback", "android.telephony.mbms.vendor.IMbmsDownloadService", "android.telephony.mbms.vendor.IMbmsStreamingService", "android.view.accessibility.IAccessibilityInteractionConnection", "android.view.accessibility.IAccessibilityInteractionConnectionCallback", "android.view.accessibility.IAccessibilityManager", "android.view.accessibility.IAccessibilityManagerClient", "android.view.autofill.IAutoFillManager", "android.view.autofill.IAutoFillManagerClient", "android.view.autofill.IAutofillWindowPresenter", "android.view.IApplicationToken", "android.view.IAppTransitionAnimationSpecsFuture", "android.view.IDockedStackListener", "android.view.IGraphicsStats", "android.view.IGraphicsStatsCallback", "android.view.IInputFilter", "android.view.IInputFilterHost", "android.view.IOnKeyguardExitResult", "android.view.IPinnedStackController", "android.view.IPinnedStackListener", "android.view.IRecentsAnimationController", "android.view.IRecentsAnimationRunner", "android.view.IRemoteAnimationFinishedCallback", "android.view.IRemoteAnimationRunner", "android.view.IRotationWatcher", "android.view.IWallpaperVisibilityListener", "android.view.IWindow", "android.view.IWindowFocusObserver", "android.view.IWindowId", "android.view.IWindowManager", "android.view.IWindowSession", "android.view.IWindowSessionCallback", "android.webkit.IWebViewUpdateService", "com.android.ims.ImsConfigListener", "com.android.ims.internal.IImsCallSession", "com.android.ims.internal.IImsCallSessionListener", "com.android.ims.internal.IImsConfig", "com.android.ims.internal.IImsEcbm", "com.android.ims.internal.IImsEcbmListener", "com.android.ims.internal.IImsExternalCallStateListener", "com.android.ims.internal.IImsFeatureStatusCallback", "com.android.ims.internal.IImsMMTelFeature", "com.android.ims.internal.IImsMultiEndpoint", "com.android.ims.internal.IImsRcsFeature", "com.android.ims.internal.IImsRegistrationListener", "com.android.ims.internal.IImsService", "com.android.ims.internal.IImsServiceController", "com.android.ims.internal.IImsServiceFeatureCallback", "com.android.ims.internal.IImsStreamMediaSession", "com.android.ims.internal.IImsUt", "com.android.ims.internal.IImsUtListener", "com.android.ims.internal.IImsVideoCallCallback", "com.android.ims.internal.IImsVideoCallProvider", "com.android.ims.internal.uce.options.IOptionsListener", "com.android.ims.internal.uce.options.IOptionsService", "com.android.ims.internal.uce.presence.IPresenceListener", "com.android.ims.internal.uce.presence.IPresenceService", "com.android.ims.internal.uce.uceservice.IUceListener", "com.android.ims.internal.uce.uceservice.IUceService", "com.android.internal.app.IAppOpsActiveCallback", "com.android.internal.app.IAppOpsCallback", "com.android.internal.app.IAppOpsService", "com.android.internal.app.IBatteryStats", "com.android.internal.app.IMediaContainerService", "com.android.internal.app.ISoundTriggerService", "com.android.internal.app.IVoiceInteractionManagerService", "com.android.internal.app.IVoiceInteractionSessionListener", "com.android.internal.app.IVoiceInteractionSessionShowCallback", "com.android.internal.app.IVoiceInteractor", "com.android.internal.app.IVoiceInteractorCallback", "com.android.internal.app.IVoiceInteractorRequest", "com.android.internal.appwidget.IAppWidgetHost", "com.android.internal.appwidget.IAppWidgetService", "com.android.internal.backup.IBackupTransport", "com.android.internal.backup.IObbBackupService", "com.android.internal.location.ILocationProvider", "com.android.internal.net.INetworkWatchlistManager", "com.android.internal.os.IDropBoxManagerService", "com.android.internal.os.IParcelFileDescriptorFactory", "com.android.internal.os.IResultReceiver", "com.android.internal.os.IShellCallback", "com.android.internal.policy.IKeyguardDismissCallback", "com.android.internal.policy.IKeyguardDrawnCallback", "com.android.internal.policy.IKeyguardExitCallback", "com.android.internal.policy.IKeyguardService", "com.android.internal.policy.IKeyguardStateCallback", "com.android.internal.policy.IShortcutService", "com.android.internal.statusbar.IStatusBar", "com.android.internal.statusbar.IStatusBarService", "com.android.internal.telecom.ICallScreeningAdapter", "com.android.internal.telecom.ICallScreeningService", "com.android.internal.telecom.IConnectionService", "com.android.internal.telecom.IConnectionServiceAdapter", "com.android.internal.telecom.IInCallAdapter", "com.android.internal.telecom.IInCallService", "com.android.internal.telecom.ITelecomService", "com.android.internal.telecom.IVideoCallback", "com.android.internal.telecom.IVideoProvider", "com.android.internal.telecom.RemoteServiceCallback", "com.android.internal.telephony.IApnSourceService", "com.android.internal.telephony.ICarrierConfigLoader", "com.android.internal.telephony.IMms", "com.android.internal.telephony.IOnSubscriptionsChangedListener", "com.android.internal.telephony.IPhoneStateListener", "com.android.internal.telephony.IPhoneSubInfo", "com.android.internal.telephony.ISms", "com.android.internal.telephony.ISub", "com.android.internal.telephony.ITelephonyRegistry", "com.android.internal.telephony.IWapPushManager", "com.android.internal.textservice.ISpellCheckerService", "com.android.internal.textservice.ISpellCheckerServiceCallback", "com.android.internal.textservice.ISpellCheckerSession", "com.android.internal.textservice.ISpellCheckerSessionListener", "com.android.internal.textservice.ITextServicesManager", "com.android.internal.textservice.ITextServicesSessionListener", "com.android.internal.view.IDragAndDropPermissions", "com.android.internal.view.IInputContext", "com.android.internal.view.IInputContextCallback", "com.android.internal.view.IInputMethod", "com.android.internal.view.IInputMethodClient", "com.android.internal.view.IInputMethodManager", "com.android.internal.view.IInputMethodSession", "com.android.internal.view.IInputSessionCallback", "com.android.internal.widget.ICheckCredentialProgressCallback", "com.android.internal.widget.ILockSettings", "com.android.internal.widget.IRemoteViewsFactory", "com.android.internal.telephony.ITelephony" ./PaxHeaders.X/import_resolver.cpp0100644 0000000 0000000 00000000034 15172120304 016233 xustar000000000 0000000 28 mtime=1776853188.3540000 import_resolver.cpp0100644 0000000 0000000 00000005354 15172120304 013546 0ustar000000000 0000000 /* * Copyright (C) 2015, 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 "import_resolver.h" #include "aidl_language.h" #include "logging.h" #include #include #include #include #ifdef _WIN32 #include #endif #include "os.h" using std::set; using std::string; using std::vector; namespace android { namespace aidl { ImportResolver::ImportResolver(const IoDelegate& io_delegate, const string& input_file_name, const set& import_paths) : io_delegate_(io_delegate), input_file_name_(input_file_name) { for (string path : import_paths) { if (path.empty()) { path = "."; } if (path[path.size() - 1] != OS_PATH_SEPARATOR) { path += OS_PATH_SEPARATOR; } import_paths_.emplace(std::move(path)); } } string ImportResolver::FindImportFile(const string& canonical_name) const { auto parts = base::Split(canonical_name, "."); while (!parts.empty()) { string relative_path = base::Join(parts, OS_PATH_SEPARATOR) + ".aidl"; auto candidates = ScanImportPaths(relative_path); if (candidates.size() == 0) { // remove the last part & keep searching parts.pop_back(); continue; } if (candidates.size() == 1) { // found! ("legacy" logic: may still be ambiguous path if we try other relative paths) return *candidates.begin(); } if (candidates.size() > 1) { AIDL_ERROR(input_file_name_) << "Duplicate files found for " << canonical_name << " from:\n" << base::Join(candidates, "\n"); return ""; } } AIDL_ERROR(input_file_name_) << "Couldn't find import for class " << canonical_name << ". Searched here:\n - " << base::Join(import_paths_, "\n - "); return ""; } set ImportResolver::ScanImportPaths(const string& relative_path) const { // Look for that relative path at each of our import roots. set found; for (const auto& path : import_paths_) { if (io_delegate_.FileIsReadable(path + relative_path)) { found.emplace(path + relative_path); } } return found; } } // namespace aidl } // namespace android ./PaxHeaders.X/import_resolver.h0100644 0000000 0000000 00000000034 15172120304 015700 xustar000000000 0000000 28 mtime=1776853188.3540000 import_resolver.h0100644 0000000 0000000 00000003156 15172120304 013211 0ustar000000000 0000000 /* * Copyright (C) 2015, 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. */ #pragma once #include #include #include "io_delegate.h" namespace android { namespace aidl { class ImportResolver { public: ImportResolver(const IoDelegate& io_delegate, const std::string& input_file_name, const std::set& import_paths); virtual ~ImportResolver() = default; // non-copyable, non-movable ImportResolver(const ImportResolver&) = delete; ImportResolver(ImportResolver&&) = delete; ImportResolver& operator=(const ImportResolver&) = delete; ImportResolver& operator=(ImportResolver&&) = delete; // Resolve the canonical name for a class to a file that exists // in one of the import paths given to the ImportResolver. std::string FindImportFile(const std::string& canonical_name) const; private: std::set ScanImportPaths(const std::string& relative_path) const; const IoDelegate& io_delegate_; const std::string& input_file_name_; std::set import_paths_; }; } // namespace aidl } // namespace android ./PaxHeaders.X/io_delegate.cpp0100644 0000000 0000000 00000000034 15172120304 015241 xustar000000000 0000000 28 mtime=1776853188.3540000 io_delegate.cpp0100644 0000000 0000000 00000017527 15172120304 012561 0ustar000000000 0000000 /* * Copyright (C) 2015, 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 "io_delegate.h" #include #include #include #include #ifdef _WIN32 #include #include #undef ERROR #else #include #include #include #include #endif #include #include "logging.h" #include "os.h" using std::string; using std::unique_ptr; using std::vector; using android::base::Error; using android::base::Result; using android::base::Split; using android::base::StartsWith; namespace android { namespace aidl { bool IoDelegate::GetAbsolutePath(const string& path, string* absolute_path) { #ifdef _WIN32 char buf[4096]; DWORD path_len = GetFullPathName(path.c_str(), sizeof(buf), buf, nullptr); if (path_len <= 0 || path_len >= sizeof(buf)) { AIDL_ERROR(path) << "Failed to GetFullPathName"; return false; } *absolute_path = buf; return true; #else if (path.empty()) { AIDL_ERROR(path) << "Giving up on finding an absolute path to represent the empty string."; return false; } if (path[0] == OS_PATH_SEPARATOR) { *absolute_path = path; return true; } char buf[4096]; if (getcwd(buf, sizeof(buf)) == nullptr) { AIDL_ERROR(path) << "Path of current working directory does not fit in " << sizeof(buf) << " bytes"; return false; } *absolute_path = buf; *absolute_path += OS_PATH_SEPARATOR; *absolute_path += path; return true; #endif } unique_ptr IoDelegate::GetFileContents( const string& filename, const string& content_suffix) const { unique_ptr contents; std::ifstream in(filename, std::ios::in | std::ios::binary); if (!in) { return contents; } contents.reset(new string); in.seekg(0, std::ios::end); ssize_t file_size = in.tellg(); contents->resize(file_size + content_suffix.length()); in.seekg(0, std::ios::beg); // Read the file contents into the beginning of the string in.read(&(*contents)[0], file_size); // Drop the suffix in at the end. contents->replace(file_size, content_suffix.length(), content_suffix); in.close(); return contents; } bool IoDelegate::FileIsReadable(const string& path) const { #ifdef _WIN32 // check that the file exists and is not write-only return (0 == _access(path.c_str(), 0)) && // mode 0=exist (0 == _access(path.c_str(), 4)); // mode 4=readable #else return (0 == access(path.c_str(), R_OK)); #endif } static bool CreateNestedDirs(const string& caller_base_dir, const vector& nested_subdirs) { string base_dir = caller_base_dir; if (base_dir.empty()) { base_dir = "."; } for (const string& subdir : nested_subdirs) { if (base_dir[base_dir.size() - 1] != OS_PATH_SEPARATOR) { base_dir += OS_PATH_SEPARATOR; } base_dir += subdir; bool success; #ifdef _WIN32 success = _mkdir(base_dir.c_str()) == 0; #else success = mkdir(base_dir.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) == 0; #endif // On darwin when you try to mkdir("/", ...) we get EISDIR. if (!success && (errno != EEXIST && errno != EISDIR)) { AIDL_ERROR(caller_base_dir) << "Error while creating " << base_dir << ": " << strerror(errno); return false; } } return true; } bool IoDelegate::CreateDirForPath(const string& path) const { if (path.empty()) { return true; } string absolute_path; if (!GetAbsolutePath(path, &absolute_path)) { return false; } auto directories = Split(absolute_path, string{OS_PATH_SEPARATOR}); // The "base" directory is just the root of the file system. On Windows, // this will look like "C:\" but on Unix style file systems we get an empty // string after splitting "/foo" with "/" string base = directories[0]; if (base.empty()) { base = "/"; } directories.erase(directories.begin()); // Remove the actual file in question, we're just creating the directory path. bool is_file = path.back() != OS_PATH_SEPARATOR; if (is_file) { directories.pop_back(); } return CreateNestedDirs(base, directories); } unique_ptr IoDelegate::GetCodeWriter( const string& file_path) const { if (CreateDirForPath(file_path)) { return CodeWriter::ForFile(file_path); } else { return nullptr; } } #ifdef _WIN32 static Result add_list_files(const string& dirname, vector* result) { AIDL_FATAL_IF(result == nullptr, dirname); WIN32_FIND_DATA find_data; // Look up the first file. // See https://stackoverflow.com/a/14841564/112950 for why we use remove_pointer_t // here. // Note: we need to use a wildcard expression like `\*` to ensure we traverse // the directory. Otherwise Find{First,Next}File will only return the directory // itself and stop. const string path(dirname + "\\*"); std::unique_ptr, decltype(&FindClose)> search_handle( FindFirstFile(path.c_str(), &find_data), FindClose); if (search_handle.get() == INVALID_HANDLE_VALUE) { return Error() << "Failed to read directory '" << dirname << "': " << GetLastError(); } bool has_more_files = true; do { const bool skip = !strcmp(find_data.cFileName, ".") || !strcmp(find_data.cFileName, ".."); if (!skip) { if (find_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { if (auto ret = add_list_files(dirname + OS_PATH_SEPARATOR + find_data.cFileName, result); !ret.ok()) { return ret; } } else { result->emplace_back(dirname + OS_PATH_SEPARATOR + find_data.cFileName); } } has_more_files = FindNextFile(search_handle.get(), &find_data); if (!has_more_files) { const DWORD err = GetLastError(); if (err != ERROR_NO_MORE_FILES) { return Error() << "Failed to read directory entry in '" << dirname << "': " << err; } } } while (has_more_files); return Result(); } #else static Result add_list_files(const string& dirname, vector* result) { AIDL_FATAL_IF(result == nullptr, dirname); std::unique_ptr dir(opendir(dirname.c_str()), closedir); if (dir == nullptr) { return Error() << "Failed to read directory '" << dirname << "': " << strerror(errno); } while (true) { errno = 0; struct dirent* ent = readdir(dir.get()); if (ent == nullptr) { if (errno != 0) { return Error() << "Failed to read directory entry in '" << dirname << "': " << strerror(errno); } break; } if (!strcmp(ent->d_name, ".") || !strcmp(ent->d_name, "..")) { continue; } if (ent->d_type == DT_REG) { result->emplace_back(dirname + OS_PATH_SEPARATOR + ent->d_name); } else if (ent->d_type == DT_DIR) { if (auto ret = add_list_files(dirname + OS_PATH_SEPARATOR + ent->d_name, result); !ret.ok()) { return ret; } } } return Result(); } #endif Result> IoDelegate::ListFiles(const string& dir) const { vector result; if (auto ret = add_list_files(dir, &result); !ret.ok()) { return ret.error(); } return result; } string IoDelegate::CleanPath(const string& path) { if (base::StartsWith(path, string{'.', OS_PATH_SEPARATOR})) { return path.substr(2); } return path; } } // namespace android } // namespace aidl ./PaxHeaders.X/io_delegate.h0100644 0000000 0000000 00000000034 15172120304 014706 xustar000000000 0000000 28 mtime=1776853188.3540000 io_delegate.h0100644 0000000 0000000 00000004343 15172120304 012216 0ustar000000000 0000000 /* * Copyright (C) 2015, 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. */ #pragma once #include #include #include #include #include "code_writer.h" namespace android { namespace aidl { class IoDelegate { public: IoDelegate() = default; virtual ~IoDelegate() = default; IoDelegate(const IoDelegate&) = delete; IoDelegate(IoDelegate&&) = delete; IoDelegate& operator=(const IoDelegate&) = delete; IoDelegate& operator=(IoDelegate&&) = delete; // Stores an absolute version of |path| to |*absolute_path|, // possibly prefixing it with the current working directory. // Returns false and does not set |*absolute_path| on error. static bool GetAbsolutePath(const std::string& path, std::string* absolute_path); // Remove leading "./" from |path|. static std::string CleanPath(const std::string& path); // Returns a unique_ptr to the contents of |filename|. // Will append the optional |content_suffix| to the returned contents. virtual std::unique_ptr GetFileContents( const std::string& filename, const std::string& content_suffix = "") const; virtual bool FileIsReadable(const std::string& path) const; virtual std::unique_ptr GetCodeWriter( const std::string& file_path) const; virtual android::base::Result> ListFiles(const std::string& dir) const; private: // Create the directory when path is a dir or the parent directory when // path is a file. Path is a dir if it ends with the path separator. bool CreateDirForPath(const std::string& path) const; }; // class IoDelegate } // namespace aidl } // namespace android ./PaxHeaders.X/io_delegate_unittest.cpp0100644 0000000 0000000 00000000034 15172120304 017200 xustar000000000 0000000 28 mtime=1776853188.3550000 io_delegate_unittest.cpp0100644 0000000 0000000 00000003341 15172120304 014505 0ustar000000000 0000000 /* * 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 "io_delegate.h" #include #include using std::string; using testing::internal::CaptureStderr; using testing::internal::GetCapturedStderr; namespace android { namespace aidl { TEST(IoDelegateTest, CannotGetAbsolutePathFromEmptyString) { string expected_error = "ERROR: : Giving up on finding an absolute path to represent the empty string.\n"; CaptureStderr(); string absolute_path; EXPECT_FALSE(IoDelegate::GetAbsolutePath("", &absolute_path)); EXPECT_TRUE(absolute_path.empty()); EXPECT_EQ(expected_error, GetCapturedStderr()); } TEST(IoDelegateTest, CurrentlyInfersLinuxAbsolutePath) { string absolute_path; EXPECT_TRUE(IoDelegate::GetAbsolutePath("foo", &absolute_path)); ASSERT_FALSE(absolute_path.empty()); // Should find our desired file at the end of |absolute_path| // But we don't know the prefix, since it's the current working directory EXPECT_TRUE(absolute_path.rfind("/foo") == absolute_path.length() - 4); // Whatever our current working directory, the path is absolute. EXPECT_EQ(absolute_path[0], '/'); } } // namespace aidl } // namespace android ./PaxHeaders.X/location.cpp0100644 0000000 0000000 00000000034 15172120304 014610 xustar000000000 0000000 28 mtime=1776853188.3550000 location.cpp0100644 0000000 0000000 00000002113 15172120304 012111 0ustar000000000 0000000 /* * 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 "location.h" AidlLocation::AidlLocation(const std::string& file, Point begin, Point end, Source source) : file_(file), begin_(begin), end_(end), source_(source) {} std::ostream& operator<<(std::ostream& os, const AidlLocation& l) { os << l.file_; if (l.LocationKnown()) { os << ":" << l.begin_.line << "." << l.begin_.column << "-"; if (l.begin_.line != l.end_.line) { os << l.end_.line << "."; } os << l.end_.column; } return os; } ./PaxHeaders.X/location.h0100644 0000000 0000000 00000000034 15172120304 014255 xustar000000000 0000000 28 mtime=1776853188.3550000 location.h0100644 0000000 0000000 00000003444 15172120304 011566 0ustar000000000 0000000 /* * 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. */ #pragma once #include #include class AidlLocation { public: struct Point { int line; int column; }; enum class Source { // From internal aidl source code INTERNAL = 0, // From a parsed file EXTERNAL = 1 }; AidlLocation(const std::string& file, Point begin, Point end, Source source); AidlLocation(const std::string& file, Source source) : AidlLocation(file, {0, 0}, {0, 0}, source) {} bool IsInternal() const { return source_ == Source::INTERNAL; } // The first line of a file is line 1. bool LocationKnown() const { return begin_.line != 0; } std::string GetFile() const { return file_; } friend std::ostream& operator<<(std::ostream& os, const AidlLocation& l); friend class AidlNode; private: // INTENTIONALLY HIDDEN: only operator<< should access details here. // Otherwise, locations should only ever be copied around to construct new // objects. const std::string file_; Point begin_; Point end_; Source source_; }; #define AIDL_LOCATION_HERE \ (AidlLocation{__FILE__, {__LINE__, 0}, {__LINE__, 0}, AidlLocation::Source::INTERNAL}) std::ostream& operator<<(std::ostream& os, const AidlLocation& l);./PaxHeaders.X/logging.cpp0100644 0000000 0000000 00000000034 15172120304 014426 xustar000000000 0000000 28 mtime=1776853188.3550000 logging.cpp0100644 0000000 0000000 00000003232 15172120304 011732 0ustar000000000 0000000 /* * 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 "logging.h" #include "aidl_language.h" bool AidlErrorLog::sHadError = false; AidlErrorLog::AidlErrorLog(Severity severity, const AidlLocation& location, const std::string& suffix /* = "" */) : os_(&std::cerr), severity_(severity), location_(location), suffix_(suffix) { sHadError |= severity_ >= ERROR; if (severity_ != NO_OP) { (*os_) << (severity_ == WARNING ? "WARNING: " : "ERROR: "); (*os_) << location << ": "; } } AidlErrorLog::AidlErrorLog(Severity severity, const AidlNode& node) : AidlErrorLog(severity, node.location_) {} AidlErrorLog::AidlErrorLog(Severity severity, const std::string& filename) : AidlErrorLog(severity, AidlLocation(filename, AidlLocation::Source::EXTERNAL)) {} AidlErrorLog::~AidlErrorLog() { if (severity_ == NO_OP) return; (*os_) << suffix_ << std::endl; if (severity_ == FATAL) abort(); if (location_.IsInternal()) { (*os_) << "Logging an internal location should not happen. Offending location: " << location_ << std::endl; abort(); } } ./PaxHeaders.X/logging.h0100644 0000000 0000000 00000000034 15172120304 014073 xustar000000000 0000000 28 mtime=1776853188.3550000 logging.h0100644 0000000 0000000 00000005157 15172120304 011407 0ustar000000000 0000000 /* * Copyright (C) 2015, 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. */ #pragma once #include #include #include #include "location.h" class AidlNode; // Generic point for printing any error in the AIDL compiler. class AidlErrorLog { public: enum Severity { NO_OP, WARNING, ERROR, FATAL }; AidlErrorLog(Severity severity, const AidlLocation& location, const std::string& suffix = ""); AidlErrorLog(Severity severity, const std::string& filename); AidlErrorLog(Severity severity, const AidlNode& node); AidlErrorLog(Severity severity, const AidlNode* node) : AidlErrorLog(severity, *node) {} template AidlErrorLog(Severity severity, const std::unique_ptr& node) : AidlErrorLog(severity, *node) {} ~AidlErrorLog(); // AidlErrorLog is a single use object. No need to copy AidlErrorLog(const AidlErrorLog&) = delete; AidlErrorLog& operator=(const AidlErrorLog&) = delete; // btw, making it movable so that functions can return it. AidlErrorLog(AidlErrorLog&&) = default; AidlErrorLog& operator=(AidlErrorLog&&) = delete; template AidlErrorLog& operator<<(T&& arg) { if (severity_ != NO_OP) { (*os_) << std::forward(arg); } return *this; } static void clearError() { sHadError = false; } static bool hadError() { return sHadError; } private: std::ostream* os_; Severity severity_; const AidlLocation location_; const std::string suffix_; static bool sHadError; }; // A class used to make it obvious to clang that code is going to abort. This // informs static analyses of the aborting behavior of `AIDL_FATAL`, and // helps generate slightly faster/smaller code. class AidlAbortOnDestruction { public: __attribute__((noreturn)) ~AidlAbortOnDestruction() { abort(); } }; #define AIDL_ERROR(CONTEXT) ::AidlErrorLog(AidlErrorLog::ERROR, (CONTEXT)) #define AIDL_FATAL(CONTEXT) \ (::AidlAbortOnDestruction(), ::AidlErrorLog(AidlErrorLog::FATAL, (CONTEXT))) #define AIDL_FATAL_IF(CONDITION, CONTEXT) \ if (CONDITION) AIDL_FATAL(CONTEXT) << "Bad internal state: " << #CONDITION << ": " ./PaxHeaders.X/main.cpp0100644 0000000 0000000 00000000034 15172120304 013724 xustar000000000 0000000 28 mtime=1776853188.3550000 main.cpp0100644 0000000 0000000 00000002362 15172120304 011233 0ustar000000000 0000000 /* * Copyright (C) 2015, 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 "io_delegate.h" #include "logging.h" #include "options.h" #include using android::aidl::Options; #ifdef AIDL_CPP_BUILD constexpr Options::Language kDefaultLang = Options::Language::CPP; #else constexpr Options::Language kDefaultLang = Options::Language::JAVA; #endif int main(int argc, char* argv[]) { Options options(argc, argv, kDefaultLang); // Only minimal functionality should go here, so that as much of possible of // the aidl compiler is mocked with the single function `aidl_entry` android::aidl::IoDelegate io_delegate; int ret = aidl_entry(options, io_delegate); return ret; } ./PaxHeaders.X/metadata_0100644 0000000 0000000 00000000034 15172120304 014136 xustar000000000 0000000 28 mtime=1776853188.3550000 metadata/0040755 0000000 0000000 00000000000 15172120304 011363 5ustar000000000 0000000 ./PaxHeaders.X/metadata_Android.bp0100644 0000000 0000000 00000000034 15172120304 016037 xustar000000000 0000000 28 mtime=1776853188.3550000 metadata/Android.bp0100644 0000000 0000000 00000002737 15172120304 013274 0ustar000000000 0000000 // build time C++ available list of all AIDL interfaces in the tree package { // See: http://go/android-license-faq // A large-scale-change added 'default_applicable_licenses' to import // all of the 'license_kinds' from "system_tools_aidl_license" // to get the below license kinds: // SPDX-license-identifier-Apache-2.0 default_applicable_licenses: ["system_tools_aidl_license"], } cc_test_library { name: "libaidlmetadata", host_supported: true, srcs: [":aidl_metadata_in_cpp"], export_include_dirs: ["include"], cflags: ["-O0"], } cc_library_headers { name: "libaidlmetadata_headers", product_available: true, recovery_available: true, host_supported: true, export_include_dirs: ["include"], } // private impl below cc_binary { name: "aidl_metadata_parser", host_supported: true, srcs: ["parser.cpp"], shared_libs: ["libjsoncpp"], visibility: [":__subpackages__"], } cc_genrule { name: "aidl_metadata_in_cpp", host_supported: true, cmd: "$(location aidl_metadata_parser) $(in) > $(genDir)/metadata.cpp", srcs: [ ":aidl_metadata_json", ], tools: ["aidl_metadata_parser"], visibility: [":__subpackages__"], out: ["metadata.cpp"], } cc_test_host { name: "libaidlmetadata_test", static_libs: [ "libaidlmetadata", "libgmock", ], srcs: ["test.cpp"], test_options: { unit_test: true, }, test_suites: ["general-tests"], } ./PaxHeaders.X/metadata_include_0100644 0000000 0000000 00000000034 15172120304 015641 xustar000000000 0000000 28 mtime=1776853188.3560000 metadata/include/0040755 0000000 0000000 00000000000 15172120304 013006 5ustar000000000 0000000 ./PaxHeaders.X/metadata_include_aidl_0100644 0000000 0000000 00000000034 15172120304 016632 xustar000000000 0000000 28 mtime=1776853188.3560000 metadata/include/aidl/0040755 0000000 0000000 00000000000 15172120304 013717 5ustar000000000 0000000 ./PaxHeaders.X/metadata_include_aidl_metadata.h0100644 0000000 0000000 00000000034 15172120304 020561 xustar000000000 0000000 28 mtime=1776853188.3560000 metadata/include/aidl/metadata.h0100644 0000000 0000000 00000002517 15172120304 015652 0ustar000000000 0000000 /* * 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. */ #pragma once #include #include namespace android { struct AidlInterfaceMetadata { // name of module defining package std::string name; // stability of interface (e.g. "vintf") std::string stability; // list of types e.g. android.hardware.foo.IFoo std::vector types; // list of all hashes std::vector hashes; // true if the interface is different from the last frozen version bool has_development; // true if the unfrozen interface is allowed to be used at runtime // in this build configuration bool use_unfrozen; // list of all frozen versions std::vector versions; static std::vector all(); }; } // namespace android ./PaxHeaders.X/metadata_parser.cpp0100644 0000000 0000000 00000000034 15172120304 016134 xustar000000000 0000000 28 mtime=1776853188.3560000 metadata/parser.cpp0100644 0000000 0000000 00000005437 15172120304 013371 0ustar000000000 0000000 /* * 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 #include #include int main(int argc, char** argv) { if (argc != 2) { std::cerr << "Usage: aidl_metadata_parser *.json" << std::endl; return EXIT_FAILURE; } const std::string path = argv[1]; Json::Value root; Json::CharReaderBuilder builder; std::ifstream stream(path); std::string errorMessage; if (!Json::parseFromStream(builder, stream, &root, &errorMessage)) { std::cerr << "Failed to read interface metadata file: " << path << std::endl << errorMessage << std::endl; return EXIT_FAILURE; } std::cout << "#include " << std::endl; std::cout << "namespace android {" << std::endl; std::cout << "std::vector AidlInterfaceMetadata::all() {" << std::endl; std::cout << "return std::vector{" << std::endl; for (const Json::Value& entry : root) { std::cout << "AidlInterfaceMetadata{" << std::endl; // AIDL interface characters guaranteed to be accepted in C++ string std::cout << "std::string(\"" << entry["name"].asString() << "\")," << std::endl; std::cout << "std::string(\"" << entry["stability"].asString() << "\")," << std::endl; std::cout << "std::vector{" << std::endl; for (const Json::Value& intf : entry["types"]) { std::cout << "std::string(\"" << intf.asString() << "\")," << std::endl; } std::cout << "}," << std::endl; std::cout << "std::vector{" << std::endl; for (const Json::Value& intf : entry["hashes"]) { std::cout << "std::string(\"" << intf.asString() << "\")," << std::endl; } std::cout << "}," << std::endl; std::cout << entry["has_development"].asString() << "," << std::endl; std::cout << entry["use_unfrozen"].asString() << "," << std::endl; std::cout << "std::vector{" << std::endl; for (const Json::Value& intf : entry["versions"]) { std::cout << intf.asString() << "," << std::endl; } std::cout << "}," << std::endl; std::cout << "}," << std::endl; } std::cout << "};" << std::endl; std::cout << "}" << std::endl; std::cout << "} // namespace android" << std::endl; return EXIT_SUCCESS; } ./PaxHeaders.X/metadata_test.cpp0100644 0000000 0000000 00000000034 15172120304 015617 xustar000000000 0000000 28 mtime=1776853188.3560000 metadata/test.cpp0100644 0000000 0000000 00000004647 15172120304 013056 0ustar000000000 0000000 /* * 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 #include #include #include using ::android::AidlInterfaceMetadata; using ::testing::ElementsAre; static std::optional metadataForModule(const std::string& name) { for (const AidlInterfaceMetadata& info : AidlInterfaceMetadata::all()) { if (name == info.name) return info; } return std::nullopt; } TEST(AidlMetadata, HasTestInstances) { const auto& info = metadataForModule("test-piece-1"); ASSERT_NE(info, std::nullopt); EXPECT_EQ(info->stability, ""); EXPECT_THAT(info->types, ElementsAre("some_package.IFoo", "some_package.Thing", "some_package.sub_package.IFoo", "some_package.sub_package.SubThing")); EXPECT_THAT(info->hashes, ElementsAre("13e24b2fac6a979971819fba2ab0d6d7c4182122", "dc2a9292847e43b4360bb183f7491f0e9895eaa9", "54f935920ab0934c242145cf00f9852ae3f5a63e", "be5dd6bf9c9000ee053621f118b7d6a7cfd1e79e")); EXPECT_THAT(info->versions, ElementsAre(1, 2, 3, 4)); EXPECT_EQ(info->has_development, false); } TEST(AidlMetadata, HasTestInstancesNoDevelopment) { const auto& info = metadataForModule("test-piece-2"); ASSERT_NE(info, std::nullopt); EXPECT_EQ(info->stability, ""); EXPECT_THAT(info->types, ElementsAre("INoPackage", "some_package.IBar")); EXPECT_THAT(info->hashes, ElementsAre("c544902ab8a1d2e72ae9396032ba113e9b9698c4", "fcd36db451cdbeeb049833fd7f499a987acf3930")); EXPECT_THAT(info->versions, ElementsAre(1)); EXPECT_EQ(info->has_development, false); } TEST(AidlMetadata, UseUnfrozen) { const auto& info = metadataForModule("tests-unfrozen-vendor"); EXPECT_TRUE(info->use_unfrozen); } ./PaxHeaders.X/options.cpp0100644 0000000 0000000 00000000034 15172120304 014473 xustar000000000 0000000 28 mtime=1776853188.3560000 options.cpp0100644 0000000 0000000 00000065353 15172120304 012013 0ustar000000000 0000000 /* * Copyright (C) 2015, 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 "options.h" #include #include #include #include #include #include #include #include #include #include #include #include "aidl_language.h" #include "logging.h" #include "os.h" using android::base::Join; using android::base::Result; using android::base::Split; using android::base::StringReplace; using android::base::Trim; using std::endl; using std::string; #ifndef PLATFORM_SDK_VERSION #define PLATFORM_SDK_VERSION "" #endif namespace android { namespace aidl { string Options::GetUsage() const { std::ostringstream sstr; sstr << "AIDL Compiler: built for platform SDK version " << PLATFORM_SDK_VERSION << endl; sstr << "usage:" << endl << myname_ << " --lang={java|cpp|ndk|rust} [OPTION]... INPUT..." << endl << " Generate Java, C++ or Rust files for AIDL file(s)." << endl << endl << myname_ << " --preprocess OUTPUT INPUT..." << endl << " Create an AIDL file having declarations of AIDL file(s)." << endl << endl << myname_ << " --dumpapi --out=DIR INPUT..." << endl << " Dump API signature of AIDL file(s) to DIR." << endl << endl << myname_ << " --checkapi[={compatible|equal}] OLD_DIR NEW_DIR" << endl << " Check whether NEW_DIR API dump is {compatible|equal} extension " << endl << " of the API dump OLD_DIR. Default: compatible" << endl << endl << myname_ << " --apimapping OUTPUT INPUT..." << endl << " Generate a mapping of declared aidl method signatures to" << endl << " the original line number. e.g.: " << endl << " If line 39 of foo/bar/IFoo.aidl contains:" << " void doFoo(int bar, String baz);" << endl << " Then the result would be:" << endl << " foo.bar.Baz|doFoo|int,String,|void" << endl << " foo/bar/IFoo.aidl:39" << endl << endl; // Legacy option formats if (language_ == Options::Language::JAVA) { sstr << myname_ << " [OPTION]... INPUT [OUTPUT]" << endl << " Generate a Java file for an AIDL file." << endl << endl; } else if (language_ == Options::Language::CPP) { sstr << myname_ << " [OPTION]... INPUT HEADER_DIR OUTPUT" << endl << " Generate C++ headers and source for an AIDL file." << endl << endl; } else if (language_ == Options::Language::RUST) { sstr << myname_ << " [OPTION]... INPUT [OUTPUT]" << endl << " Generate Rust file for an AIDL file." << endl << endl; } sstr << "OPTION:" << endl << " -I DIR, --include=DIR" << endl << " Use DIR as a search path for import statements of dependencies." << endl << " -N DIR, --next_include=DIR" << endl << " Use DIR as a search path for local import statements." << endl << " -p FILE, --preprocessed=FILE" << endl << " Include FILE which is created by --preprocess." << endl << " -d FILE, --dep=FILE" << endl << " Generate dependency file as FILE. Don't use this when" << endl << " there are multiple input files. Use -a then." << endl << " -o DIR, --out=DIR" << endl << " Use DIR as the base output directory for generated files." << endl << " -h DIR, --header_out=DIR" << endl << " Generate C++ headers under DIR." << endl << " --previous_api_dir=DIR" << endl << " The aidl_api directory of the previous version of this interface." << endl << " -a" << endl << " Generate dependency file next to the output file with the" << endl << " name based on the input file." << endl << " -b" << endl << " Trigger fail when trying to compile a parcelable declaration." << endl << " --ninja" << endl << " Generate dependency file in a format ninja understands." << endl << " --rpc" << endl << " (for Java) whether to generate support for RPC transactions." << endl << " --structured" << endl << " Whether this interface is defined exclusively in AIDL." << endl << " It is therefore a candidate for stabilization." << endl << " --stability=" << endl << " The stability requirement of this interface." << endl << " --min_sdk_version=" << endl << " Minimum SDK version that the generated code should support." << endl << " Defaults to " << DEFAULT_SDK_VERSION_JAVA << " for --lang=java, " << endl << " " << DEFAULT_SDK_VERSION_CPP << " for --lang=cpp, " << endl << " " << DEFAULT_SDK_VERSION_NDK << " for --lang=ndk, " << endl << " " << DEFAULT_SDK_VERSION_RUST << " for --lang=rust, " << endl << " --omit_invocation" << endl << " Do not print full commandline in output. This is required " << endl << " for certain build systems." << endl << " -t, --trace" << endl << " Include tracing code for systrace. Note that if either" << endl << " the client or service code is not auto-generated by this" << endl << " tool, that part will not be traced." << endl << " --transaction_names" << endl << " Generate transaction names." << endl << " -v VER, --version=VER" << endl << " Set the version of the interface and parcelable to VER." << endl << " VER must be an interger greater than 0." << endl << " --hash=HASH" << endl << " Set the interface hash to HASH." << endl << " --previous_hash=HASH" << endl << " Set the interface previous version's hash to HASH." << endl << " --log" << endl << " Information about the transaction, e.g., method name, argument" << endl << " values, execution time, etc., is provided via callback." << endl << " -Werror" << endl << " Turn warnings into errors." << endl << " -Wno-error=" << endl << " Turn the specified warning into a warning even if -Werror is specified." << endl << " -W" << endl << " Enable the specified warning." << endl << " -Wno-" << endl << " Disable the specified warning." << endl << " -w" << endl << " Disable all diagnostics. -w wins -Weverything" << endl << " -Weverything" << endl << " Enable all diagnostics." << endl << " --help" << endl << " Show this help." << endl << endl << "INPUT:" << endl << " An AIDL file." << endl << endl << "OUTPUT:" << endl << " Path to the generated Java or C++ source file. This is ignored when" << endl << " -o or --out is specified or the number of the input files are" << endl << " more than one." << endl << " For Java, if omitted, Java source file is generated at the same" << endl << " place as the input AIDL file," << endl << endl << "HEADER_DIR:" << endl << " Path to where C++ headers are generated." << endl; return sstr.str(); } string to_string(Options::Language language) { switch (language) { case Options::Language::CPP: return "cpp"; case Options::Language::JAVA: return "java"; case Options::Language::NDK: return "ndk"; case Options::Language::RUST: return "rust"; case Options::Language::CPP_ANALYZER: return "cpp-analyzer"; case Options::Language::UNSPECIFIED: return "unspecified"; default: AIDL_FATAL(AIDL_LOCATION_HERE) << "Unexpected Options::Language enumerator: " << static_cast(language); } } bool Options::StabilityFromString(const std::string& stability, Stability* out_stability) { if (stability == "vintf") { *out_stability = Stability::VINTF; return true; } return false; } static const std::map codeNameToVersion = { {"S", 31}, {"Tiramisu", SDK_VERSION_Tiramisu}, {"UpsideDownCake", SDK_VERSION_UpsideDownCake}, {"VanillaIceCream", SDK_VERSION_current}, // this is an alias for the latest in-development platform version {"current", SDK_VERSION_current}, // this is an alias for use of all APIs, including those not in any API surface {"platform_apis", 10001}, }; Result MinSdkVersionFromString(const std::string& str) { uint32_t num; if (!android::base::ParseUint(str, &num, 10000u /* max */)) { if (auto found = codeNameToVersion.find(str); found != codeNameToVersion.end()) { return found->second; } return Errorf("Invalid SDK version: {}", str); } return num; } static uint32_t DefaultMinSdkVersionForLang(const Options::Language lang) { switch (lang) { case Options::Language::CPP: return DEFAULT_SDK_VERSION_CPP; case Options::Language::JAVA: return DEFAULT_SDK_VERSION_JAVA; case Options::Language::NDK: return DEFAULT_SDK_VERSION_NDK; case Options::Language::RUST: return DEFAULT_SDK_VERSION_RUST; case Options::Language::CPP_ANALYZER: return DEFAULT_SDK_VERSION_CPP; case Options::Language::UNSPECIFIED: return DEFAULT_SDK_VERSION_JAVA; // The safest option default: AIDL_FATAL(AIDL_LOCATION_HERE) << "Unexpected Options::Language enumerator: " << static_cast(lang); } } Options Options::From(const string& cmdline) { vector args = Split(cmdline, " "); return From(args); } Options Options::From(const vector& args) { Options::Language lang = Options::Language::JAVA; int argc = args.size(); if (argc >= 1 && args.at(0) == "aidl-cpp") { lang = Options::Language::CPP; } const char* argv[argc + 1]; for (int i = 0; i < argc; i++) { argv[i] = args.at(i).c_str(); } argv[argc] = nullptr; return Options(argc, argv, lang); } static std::string ComputeRawArgs(int argc, const char* const raw_argv[]) { std::vector args; for (int i = 0; i < argc; i++) { // First pass. This is mostly for devs to understand where files come from, and // there may be more complicated rules, but we can at least do better than the // typical paste that would break args with spaces in them. args.push_back(StringReplace(raw_argv[i], " ", "\\ ", true)); } return Join(args, " "); } static std::string ToCanonicalDirectory(const std::string& optarg) { std::string dir = Trim(optarg); if (!dir.empty() && dir.back() != OS_PATH_SEPARATOR) { dir.push_back(OS_PATH_SEPARATOR); } return dir; } Options Options::PlusImportDir(const std::string& import_dir) const { Options copy(*this); copy.import_dirs_.insert(ToCanonicalDirectory(import_dir)); return copy; } Options::Options(int argc, const char* const raw_argv[], Options::Language default_lang) : myname_(argc >= 1 ? raw_argv[0] : "aidl"), raw_args_(ComputeRawArgs(argc, raw_argv)), language_(default_lang) { std::vector argv = warning_options_.Parse(argc, raw_argv, error_message_); if (!Ok()) return; argc = argv.size(); argv.push_back(nullptr); bool lang_option_found = false; optind = 0; while (true) { static struct option long_options[] = { {"lang", required_argument, 0, 'l'}, {"preprocess", no_argument, 0, 's'}, {"dumpapi", no_argument, 0, 'u'}, {"no_license", no_argument, 0, 'x'}, {"checkapi", optional_argument, 0, 'A'}, {"apimapping", required_argument, 0, 'i'}, {"include", required_argument, 0, 'I'}, {"next_include", required_argument, 0, 'N'}, {"preprocessed", required_argument, 0, 'p'}, {"dep", required_argument, 0, 'd'}, {"out", required_argument, 0, 'o'}, {"header_out", required_argument, 0, 'h'}, {"ninja", no_argument, 0, 'n'}, {"rpc", no_argument, 0, 'r'}, {"stability", required_argument, 0, 'Y'}, {"omit_invocation", no_argument, 0, 'O'}, {"min_sdk_version", required_argument, 0, 'm'}, {"structured", no_argument, 0, 'S'}, {"trace", no_argument, 0, 't'}, {"transaction_names", no_argument, 0, 'c'}, {"previous_api_dir", required_argument, 0, 'f'}, {"version", required_argument, 0, 'v'}, {"log", no_argument, 0, 'L'}, {"hash", required_argument, 0, 'H'}, {"previous_hash", required_argument, 0, 'P'}, {"help", no_argument, 0, 'e'}, {0, 0, 0, 0}, }; const int c = getopt_long(argc, const_cast(argv.data()), "I:N:p:d:o:h:abtv:i:", long_options, nullptr); if (c == -1) { // no more options break; } switch (c) { case 'l': if (language_ == Options::Language::CPP) { // aidl-cpp can't set language. aidl-cpp exists only for backwards // compatibility. error_message_ << "aidl-cpp does not support --lang." << endl; return; } else { lang_option_found = true; string lang = Trim(optarg); if (lang == "java") { language_ = Options::Language::JAVA; task_ = Options::Task::COMPILE; } else if (lang == "cpp") { language_ = Options::Language::CPP; task_ = Options::Task::COMPILE; } else if (lang == "ndk") { language_ = Options::Language::NDK; task_ = Options::Task::COMPILE; } else if (lang == "rust") { language_ = Options::Language::RUST; task_ = Options::Task::COMPILE; } else if (lang == "cpp-analyzer") { language_ = Options::Language::CPP_ANALYZER; task_ = Options::Task::COMPILE; } else { error_message_ << "Unsupported language: '" << lang << "'" << endl; return; } } break; case 's': task_ = Options::Task::PREPROCESS; break; case 'u': task_ = Options::Task::DUMP_API; break; case 'x': dump_no_license_ = true; break; case 'A': task_ = Options::Task::CHECK_API; // to ensure that all parcelables in the api dumpes are structured structured_ = true; if (optarg) { if (strcmp(optarg, "compatible") == 0) check_api_level_ = CheckApiLevel::COMPATIBLE; else if (strcmp(optarg, "equal") == 0) check_api_level_ = CheckApiLevel::EQUAL; else { error_message_ << "Unsupported --checkapi level: '" << optarg << "'" << endl; return; } } break; case 'I': { // imports for dependencies import_dirs_.emplace(ToCanonicalDirectory(optarg)); previous_import_dirs_.emplace(ToCanonicalDirectory(optarg)); break; } case 'p': preprocessed_files_.emplace_back(Trim(optarg)); break; case 'd': dependency_file_ = Trim(optarg); break; case 'o': output_dir_ = ToCanonicalDirectory(optarg); break; case 'N': import_dirs_.emplace(ToCanonicalDirectory(optarg)); break; case 'f': previous_api_dir_ = ToCanonicalDirectory(optarg); previous_import_dirs_.emplace(ToCanonicalDirectory(optarg)); break; case 'O': raw_args_ = "cmd not shown due to `--omit_invocation`"; break; case 'h': output_header_dir_ = ToCanonicalDirectory(optarg); break; case 'n': dependency_file_ninja_ = true; break; case 'S': structured_ = true; break; case 'Y': { const string stability_str = Trim(optarg); if (!StabilityFromString(stability_str, &stability_)) { error_message_ << "Unrecognized stability level: '" << stability_str << "'. Must be vintf." << endl; return; } break; } case 'm': if (auto ret = MinSdkVersionFromString(Trim(optarg)); ret.ok()) { min_sdk_version_ = *ret; } else { error_message_ << ret.error(); return; } break; case 'r': gen_rpc_ = true; break; case 't': gen_traces_ = true; break; case 'a': auto_dep_file_ = true; break; case 'b': fail_on_parcelable_ = true; break; case 'c': gen_transaction_names_ = true; break; case 'v': { const string ver_str = Trim(optarg); int ver = atoi(ver_str.c_str()); if (ver > 0) { version_ = ver; } else { error_message_ << "Invalid version number: '" << ver_str << "'. " << "Version must be a positive natural number." << endl; return; } break; } case 'H': hash_ = Trim(optarg); break; case 'P': previous_hash_ = Trim(optarg); break; case 'L': gen_log_ = true; break; case 'e': std::cerr << GetUsage(); task_ = Task::HELP; CHECK(Ok()); return; case 'i': output_file_ = Trim(optarg); task_ = Task::DUMP_MAPPINGS; break; default: error_message_ << GetUsage(); CHECK(!Ok()); return; } } // while // Positional arguments if (!lang_option_found && task_ == Options::Task::COMPILE) { // the legacy arguments format if (argc - optind <= 0) { error_message_ << "No input file" << endl; return; } if (language_ == Options::Language::JAVA || language_ == Options::Language::RUST) { input_files_.emplace_back(argv[optind++]); if (argc - optind >= 1) { output_file_ = argv[optind++]; } else if (output_dir_.empty()) { // when output is omitted and -o option isn't set, the output is by // default set to the input file path with .aidl is replaced to .java. // If -o option is set, the output path is calculated by // GetOutputFilePath which returns "// // .java" output_file_ = input_files_.front(); if (android::base::EndsWith(output_file_, ".aidl")) { output_file_ = output_file_.substr(0, output_file_.length() - strlen(".aidl")); } output_file_ += (language_ == Options::Language::JAVA) ? ".java" : ".rs"; } } else if (IsCppOutput()) { input_files_.emplace_back(argv[optind++]); if (argc - optind < 2) { error_message_ << "No HEADER_DIR or OUTPUT." << endl; return; } output_header_dir_ = ToCanonicalDirectory(argv[optind++]); output_file_ = argv[optind++]; } if (argc - optind > 0) { error_message_ << "Too many arguments: "; for (int i = optind; i < argc; i++) { error_message_ << " " << argv[i]; } error_message_ << endl; } } else { // the new arguments format if (task_ == Options::Task::COMPILE || task_ == Options::Task::DUMP_API || task_ == Options::Task::DUMP_MAPPINGS) { if (argc - optind < 1) { error_message_ << "No input file." << endl; return; } } else { if (argc - optind < 2) { error_message_ << "Insufficient arguments. At least 2 required, but " << "got " << (argc - optind) << "." << endl; return; } if (task_ != Options::Task::CHECK_API) { output_file_ = argv[optind++]; } } while (optind < argc) { input_files_.emplace_back(argv[optind++]); } } // filter out invalid combinations if (lang_option_found) { if (IsCppOutput() && task_ == Options::Task::COMPILE) { if (output_dir_.empty()) { error_message_ << "Output directory is not set. Set with --out." << endl; return; } if (output_header_dir_.empty()) { error_message_ << "Header output directory is not set. Set with " << "--header_out." << endl; return; } } if (language_ == Options::Language::JAVA && task_ == Options::Task::COMPILE) { if (output_dir_.empty()) { error_message_ << "Output directory is not set. Set with --out." << endl; return; } if (!output_header_dir_.empty()) { error_message_ << "Header output directory is set, which does not make " << "sense for Java." << endl; return; } } if (language_ == Options::Language::RUST && task_ == Options::Task::COMPILE) { if (output_dir_.empty()) { error_message_ << "Output directory is not set. Set with --out." << endl; return; } if (!output_header_dir_.empty()) { error_message_ << "Header output directory is set, which does not make " << "sense for Rust." << endl; return; } } } if (!previous_api_dir_.empty()) { if (previous_hash_.empty()) { error_message_ << "--previous_hash must be set if --previous_api_dir is set" << endl; return; } } else { if (!previous_hash_.empty()) { error_message_ << "--previous_hash must not be set if --previous_api_dir is not set" << endl; return; } } if (task_ == Options::Task::COMPILE) { for (const string& input : input_files_) { if (!android::base::EndsWith(input, ".aidl")) { error_message_ << "Expected .aidl file for input but got '" << input << "'" << endl; return; } } if (!output_file_.empty() && input_files_.size() > 1) { error_message_ << "Multiple AIDL files can't be compiled to a single " << "output file '" << output_file_ << "'. " << "Use --out=DIR instead for output files." << endl; return; } if (!dependency_file_.empty() && input_files_.size() > 1) { error_message_ << "-d or --dep doesn't work when compiling multiple AIDL " << "files. Use '-a' to generate dependency file next to " << "the output file with the name based on the input " << "file." << endl; return; } if (gen_log_ && (language_ != Options::Language::CPP && language_ != Options::Language::NDK)) { error_message_ << "--log is currently supported for either --lang=cpp or --lang=ndk" << endl; return; } } if (task_ == Options::Task::PREPROCESS) { if (version_ > 0) { error_message_ << "--version should not be used with '--preprocess'." << endl; return; } } if (task_ == Options::Task::CHECK_API) { if (input_files_.size() != 2) { error_message_ << "--checkapi requires two inputs for comparing, " << "but got " << input_files_.size() << "." << endl; return; } } if (task_ == Options::Task::DUMP_API) { if (output_dir_.empty()) { error_message_ << "--dumpapi requires output directory. Use --out." << endl; return; } } if (task_ != Options::Task::COMPILE) { if (min_sdk_version_ != 0) { error_message_ << "--min_sdk_version is available only for compilation." << endl; return; } // For other tasks, use "current" min_sdk_version_ = MinSdkVersionFromString("current").value(); } uint32_t default_ver = DefaultMinSdkVersionForLang(language_); if (min_sdk_version_ == 0) { // --min_sdk_version flag not specified min_sdk_version_ = default_ver; } else if (min_sdk_version_ < default_ver) { error_message_ << "Min SDK version should at least be " << default_ver << "." << endl; return; } uint32_t rpc_version = MinSdkVersionFromString("Tiramisu").value(); // note: we would like to always generate (Java) code to support RPC out of // the box, but doing so causes an unclear error for people trying to use RPC // - now we require them to add the gen_rpc build rule and get this clear message. if (gen_rpc_ && min_sdk_version_ < rpc_version) { error_message_ << "RPC code requires minimum SDK version of at least " << rpc_version << endl; return; } if (min_sdk_version_ >= rpc_version) gen_rpc_ = true; AIDL_FATAL_IF(!output_dir_.empty() && output_dir_.back() != OS_PATH_SEPARATOR, output_dir_); AIDL_FATAL_IF(!output_header_dir_.empty() && output_header_dir_.back() != OS_PATH_SEPARATOR, output_header_dir_); } std::vector WarningOptions::Parse(int argc, const char* const raw_argv[], ErrorMessage& error_message) { std::vector remains; for (int i = 0; i < argc; i++) { auto arg = raw_argv[i]; if (strcmp(arg, "-Weverything") == 0) { enable_all_ = true; } else if (strcmp(arg, "-Werror") == 0) { as_errors_ = true; } else if (strcmp(arg, "-w") == 0) { disable_all_ = true; } else if (base::StartsWith(arg, "-Wno-error=")) { no_errors_.insert(arg + strlen("-Wno-error=")); } else if (base::StartsWith(arg, "-Wno-")) { disabled_.insert(arg + strlen("-Wno-")); } else if (base::StartsWith(arg, "-W")) { enabled_.insert(arg + strlen("-W")); } else { remains.push_back(arg); } } for (const auto& names : {no_errors_, disabled_, enabled_}) { for (const auto& name : names) { if (kAllDiagnostics.count(name) == 0) { error_message << "unknown warning: " << name << "\n"; return {}; } } } return remains; } DiagnosticMapping WarningOptions::GetDiagnosticMapping() const { DiagnosticMapping mapping; for (const auto& [_, d] : kAllDiagnostics) { bool enabled = d.default_enabled; if (enable_all_ || enabled_.find(d.name) != enabled_.end()) { enabled = true; } if (disable_all_ || disabled_.find(d.name) != disabled_.end()) { enabled = false; } DiagnosticSeverity severity = DiagnosticSeverity::DISABLED; if (enabled) { severity = DiagnosticSeverity::WARNING; if (as_errors_ && no_errors_.find(d.name) == no_errors_.end()) { severity = DiagnosticSeverity::ERROR; } } mapping.Severity(d.id, severity); } return mapping; } } // namespace aidl } // namespace android ./PaxHeaders.X/options.h0100644 0000000 0000000 00000000034 15172120304 014140 xustar000000000 0000000 28 mtime=1776853188.3570000 options.h0100644 0000000 0000000 00000021204 15172120304 011443 0ustar000000000 0000000 /* * Copyright (C) 2015, 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. */ #pragma once #include #include #include #include #include #include "diagnostics.h" #include "logging.h" namespace android { namespace aidl { using std::set; using std::string; using std::vector; // The oldest SDK version that is supported for each backend. For non-Java backends, these are the // platform SDK version where the support for the backend was added. For Java backend, this is 1. // TODO(b/205065703) switch back to DEFAULT_SDK_VERSION_JAVA = 23 constexpr uint32_t DEFAULT_SDK_VERSION_JAVA = 1; constexpr uint32_t DEFAULT_SDK_VERSION_CPP = 23; constexpr uint32_t DEFAULT_SDK_VERSION_NDK = 29; constexpr uint32_t DEFAULT_SDK_VERSION_RUST = 31; constexpr uint32_t SDK_VERSION_current = 10000; constexpr uint32_t SDK_VERSION_Tiramisu = 33; constexpr uint32_t SDK_VERSION_UpsideDownCake = 34; constexpr uint32_t JAVA_PROPAGATE_VERSION = SDK_VERSION_Tiramisu; // A simple wrapper around ostringstream. This is just to make Options class // copiable by the implicit copy constructor. If ostingstream is not wrapped, // the implcit copy constructor is not generated because ostringstream isn't // copiable. This class makes the field copiable by having a copy constructor // that does not copy the underlying stream. class ErrorMessage { public: ErrorMessage() = default; ErrorMessage(const ErrorMessage&) {} std::ostringstream stream_; template ErrorMessage& operator<<(T& t) { stream_ << t; return *this; } template ErrorMessage& operator<<(const T& t) { stream_ << t; return *this; } // for "<< endl" ErrorMessage& operator<<(std::ostream& (*f)(std::ostream&)) { f(stream_); return *this; } }; // Handles warning-related options (e.g. -W, -w, ...) class WarningOptions { public: std::vector Parse(int argc, const char* const argv[], ErrorMessage& error_message); DiagnosticMapping GetDiagnosticMapping() const; private: bool as_errors_ = false; // -Werror bool enable_all_ = false; // -Weverything bool disable_all_ = false; // -w std::set enabled_; // -Wfoo std::set disabled_; // -Wno-foo std::set no_errors_; // -Wno-error=foo }; // Options for AIDL // // These are passed all throughout the compiler, but they should not affect the // code which is generated. In order to avoid ODR issues, and also in order to // make sure the language is orthogonal and portable, we should only generate // different things based on the file contents themselves. class Options final { public: enum class Language { UNSPECIFIED, JAVA, CPP, NDK, RUST, CPP_ANALYZER }; enum class Task { HELP, COMPILE, PREPROCESS, DUMP_API, CHECK_API, DUMP_MAPPINGS }; enum class CheckApiLevel { COMPATIBLE, EQUAL }; enum class Stability { UNSPECIFIED, VINTF }; bool StabilityFromString(const std::string& stability, Stability* out_stability); Options(int argc, const char* const argv[], Language default_lang = Language::UNSPECIFIED); Options PlusImportDir(const std::string& import_dir) const; Options AsPreviousVersion() const { Options copy(*this); copy.as_previous_version_ = true; return copy; } Options WithoutVersion() const { Options copy(*this); copy.version_ = 0; copy.hash_ = ""; return copy; } Options WithNoWarnings() const { Options copy(*this); copy.warning_options_ = WarningOptions(); return copy; } static Options From(const string& cmdline); static Options From(const vector& args); // to print in output files std::string RawArgs() const { return raw_args_; } // Contain no references to unstructured data types (such as a parcelable that is // implemented in Java). These interfaces aren't inherently stable but they have the // capacity to be stabilized. bool IsStructured() const { return structured_; } Stability GetStability() const { return stability_; } uint32_t GetMinSdkVersion() const { return min_sdk_version_; } Language TargetLanguage() const { return language_; } bool IsCppOutput() const { return language_ == Language::CPP || language_ == Language::NDK || language_ == Language::CPP_ANALYZER; } Task GetTask() const { return task_; } CheckApiLevel GetCheckApiLevel() const { return check_api_level_; } const set& ImportDirs() const { if (as_previous_version_) { return previous_import_dirs_; } else { return import_dirs_; } } const vector& PreprocessedFiles() const { return preprocessed_files_; } string DependencyFile() const { return dependency_file_; } bool AutoDepFile() const { return auto_dep_file_; } bool GenRpc() const { return gen_rpc_; } bool GenTraces() const { return gen_traces_; } bool GenTransactionNames() const { return gen_transaction_names_; } bool DependencyFileNinja() const { return dependency_file_ninja_; } const string& PreviousApiDir() const { return previous_api_dir_; } const vector& InputFiles() const { return input_files_; } // Path to the output file. This is used only when there is only one // output file for the invocation. When there are multiple outputs // (e.g. compile multiple AIDL files), output files are created under // OutputDir(). const string& OutputFile() const { return output_file_; } // Path to the directory where output file(s) will be generated under. const string& OutputDir() const { return output_dir_; } // Path to the directory where header file(s) will be generated under. // Only used when TargetLanguage() == Language::CPP const string& OutputHeaderDir() const { return output_header_dir_; } bool FailOnParcelable() const { return fail_on_parcelable_; } int Version() const { return version_; } int PreviousVersion() const { AIDL_FATAL_IF(version_ <= 1, "This should only be called on versions greater than 1"); return version_ - 1; } bool IsLatestUnfrozenVersion() const { return !PreviousApiDir().empty(); } string Hash() const { return hash_; } string PreviousHash() const { return previous_hash_; } bool GenLog() const { return gen_log_; } bool DumpNoLicense() const { return dump_no_license_; } bool Ok() const { return error_message_.stream_.str().empty(); } string GetErrorMessage() const { return error_message_.stream_.str(); } string GetUsage() const; bool GenApiMapping() const { return task_ == Task::DUMP_MAPPINGS; } DiagnosticMapping GetDiagnosticMapping() const { return warning_options_.GetDiagnosticMapping(); } // The following are for testability, but cannot be influenced on the command line. // Threshold of interface methods to enable outlining of onTransact cases. size_t onTransact_outline_threshold_{275u}; // Number of cases to _not_ outline, if outlining is enabled. size_t onTransact_non_outline_count_{275u}; private: Options() = default; const string myname_; std::string raw_args_; Language language_ = Language::UNSPECIFIED; Task task_ = Task::COMPILE; CheckApiLevel check_api_level_ = CheckApiLevel::COMPATIBLE; set import_dirs_; set previous_import_dirs_; bool as_previous_version_ = false; vector preprocessed_files_; string dependency_file_; bool gen_rpc_ = false; bool gen_traces_ = false; bool gen_transaction_names_ = false; bool dependency_file_ninja_ = false; string previous_api_dir_; bool structured_ = false; Stability stability_ = Stability::UNSPECIFIED; uint32_t min_sdk_version_ = 0; // invalid version string output_dir_; string output_header_dir_; bool fail_on_parcelable_ = false; bool auto_dep_file_ = false; vector input_files_; string output_file_; int version_ = 0; string hash_ = ""; string previous_hash_ = ""; bool gen_log_ = false; bool dump_no_license_ = false; ErrorMessage error_message_; WarningOptions warning_options_; }; std::string to_string(Options::Language language); android::base::Result MinSdkVersionFromString(const std::string& str); } // namespace aidl } // namespace android ./PaxHeaders.X/options_unittest.cpp0100644 0000000 0000000 00000000034 15172120304 016432 xustar000000000 0000000 28 mtime=1776853188.3570000 options_unittest.cpp0100644 0000000 0000000 00000044525 15172120304 013750 0ustar000000000 0000000 /* * Copyright (C) 2015, 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 "options.h" #include #include #include #include #include #include #include "diagnostics.h" using android::aidl::DiagnosticID; using android::aidl::DiagnosticSeverity; using std::cerr; using std::endl; using std::string; using std::unique_ptr; using std::vector; using testing::internal::CaptureStderr; using testing::internal::GetCapturedStderr; namespace android { namespace aidl { namespace { const char kPreprocessCommandOutputFile[] = "output_file_name"; const char kPreprocessCommandInput1[] = "input1.aidl"; const char kPreprocessCommandInput2[] = "input2.aidl"; const char kPreprocessCommandInput3[] = "input3.aidl"; const char* kPreprocessCommand[] = { "aidl", "--preprocess", kPreprocessCommandOutputFile, kPreprocessCommandInput1, kPreprocessCommandInput2, kPreprocessCommandInput3, nullptr, }; const char kCompileCommandInput[] = "directory/ITool.aidl"; const char kCompileCommandIncludePath[] = "-Iinclude_path"; const char* kCompileJavaCommand[] = { "aidl", "-b", kCompileCommandIncludePath, kCompileCommandInput, nullptr, }; const char kCompileCommandJavaOutput[] = "directory/ITool.java"; const char kCompileDepFileNinja[] = "--ninja"; const char* kCompileJavaCommandNinja[] = { "aidl", "-b", kCompileDepFileNinja, kCompileCommandIncludePath, kCompileCommandInput, nullptr, }; const char kCompileDepFile[] = "-doutput.deps"; const char kCompileCommandHeaderDir[] = "output/dir/"; const char kCompileCommandCppOutput[] = "some/file.cpp"; const char* kCompileCppCommand[] = { "aidl-cpp", kCompileCommandIncludePath, kCompileDepFile, kCompileCommandInput, kCompileCommandHeaderDir, kCompileCommandCppOutput, nullptr, }; const char* kCompileCppCommandNinja[] = { "aidl-cpp", kCompileCommandIncludePath, kCompileDepFile, kCompileDepFileNinja, kCompileCommandInput, kCompileCommandHeaderDir, kCompileCommandCppOutput, nullptr, }; unique_ptr GetOptions(const char* command[], Options::Language default_lang = Options::Language::JAVA) { int argc = 0; const char** command_part = command; for (; *command_part; ++argc, ++command_part) {} unique_ptr ret(new Options(argc, command, default_lang)); if (!ret->Ok()) { cerr << ret->GetErrorMessage(); cerr << "Failed to parse command line:"; for (int i = 0; i < argc; ++i) { cerr << " " << command[i]; cerr << endl; } } EXPECT_NE(ret, nullptr) << "Failed to parse options!"; return ret; } } // namespace TEST(OptionsTests, ParsesPreprocess) { unique_ptr options = GetOptions(kPreprocessCommand); EXPECT_EQ(Options::Task::PREPROCESS, options->GetTask()); EXPECT_EQ(false, options->FailOnParcelable()); EXPECT_EQ(0u, options->ImportDirs().size()); EXPECT_EQ(0u, options->PreprocessedFiles().size()); EXPECT_EQ(string{kPreprocessCommandOutputFile}, options->OutputFile()); EXPECT_EQ(false, options->AutoDepFile()); const vector expected_input{kPreprocessCommandInput1, kPreprocessCommandInput2, kPreprocessCommandInput3}; EXPECT_EQ(expected_input, options->InputFiles()); } TEST(OptionsTests, ParsesCompileJava) { unique_ptr options = GetOptions(kCompileJavaCommand); EXPECT_EQ(Options::Task::COMPILE, options->GetTask()); EXPECT_EQ(Options::Language::JAVA, options->TargetLanguage()); EXPECT_EQ(true, options->FailOnParcelable()); EXPECT_EQ(1u, options->ImportDirs().size()); EXPECT_EQ(0u, options->PreprocessedFiles().size()); EXPECT_EQ(string{kCompileCommandInput}, options->InputFiles().front()); EXPECT_EQ(string{kCompileCommandJavaOutput}, options->OutputFile()); EXPECT_EQ(false, options->AutoDepFile()); EXPECT_EQ(false, options->DependencyFileNinja()); } TEST(OptionsTests, ParsesCompileJavaNinja) { unique_ptr options = GetOptions(kCompileJavaCommandNinja); EXPECT_EQ(Options::Task::COMPILE, options->GetTask()); EXPECT_EQ(Options::Language::JAVA, options->TargetLanguage()); EXPECT_EQ(true, options->FailOnParcelable()); EXPECT_EQ(1u, options->ImportDirs().size()); EXPECT_EQ(0u, options->PreprocessedFiles().size()); EXPECT_EQ(string{kCompileCommandInput}, options->InputFiles().front()); EXPECT_EQ(string{kCompileCommandJavaOutput}, options->OutputFile()); EXPECT_EQ(false, options->AutoDepFile()); EXPECT_EQ(true, options->DependencyFileNinja()); } TEST(OptionsTests, ParsesCompileCpp) { unique_ptr options = GetOptions(kCompileCppCommand, Options::Language::CPP); ASSERT_EQ(1u, options->ImportDirs().size()); EXPECT_EQ(string{kCompileCommandIncludePath}.substr(2) + "/", *options->ImportDirs().begin()); EXPECT_EQ(string{kCompileDepFile}.substr(2), options->DependencyFile()); EXPECT_EQ(false, options->DependencyFileNinja()); EXPECT_EQ(kCompileCommandInput, options->InputFiles().front()); EXPECT_EQ(kCompileCommandHeaderDir, options->OutputHeaderDir()); EXPECT_EQ(kCompileCommandCppOutput, options->OutputFile()); } TEST(OptionsTests, ParsesCompileCppNinja) { unique_ptr options = GetOptions(kCompileCppCommandNinja, Options::Language::CPP); ASSERT_EQ(1u, options->ImportDirs().size()); EXPECT_EQ(string{kCompileCommandIncludePath}.substr(2) + "/", *options->ImportDirs().begin()); EXPECT_EQ(string{kCompileDepFile}.substr(2), options->DependencyFile()); EXPECT_EQ(true, options->DependencyFileNinja()); EXPECT_EQ(kCompileCommandInput, options->InputFiles().front()); EXPECT_EQ(kCompileCommandHeaderDir, options->OutputHeaderDir()); EXPECT_EQ(kCompileCommandCppOutput, options->OutputFile()); } TEST(OptionsTests, ParsesCompileJavaMultiInput) { const char* argv[] = { "aidl", "--lang=java", kCompileCommandIncludePath, "-o src_out", "directory/input1.aidl", "directory/input2.aidl", "directory/input3.aidl", nullptr, }; unique_ptr options = GetOptions(argv); EXPECT_EQ(Options::Task::COMPILE, options->GetTask()); EXPECT_EQ(Options::Language::JAVA, options->TargetLanguage()); EXPECT_EQ(false, options->FailOnParcelable()); EXPECT_EQ(1u, options->ImportDirs().size()); EXPECT_EQ(0u, options->PreprocessedFiles().size()); const vector expected_input{"directory/input1.aidl", "directory/input2.aidl", "directory/input3.aidl"}; EXPECT_EQ(expected_input, options->InputFiles()); EXPECT_EQ(string{""}, options->OutputFile()); EXPECT_EQ(false, options->AutoDepFile()); EXPECT_EQ(false, options->DependencyFileNinja()); EXPECT_EQ(string{""}, options->OutputHeaderDir()); EXPECT_EQ(string{"src_out/"}, options->OutputDir()); } TEST(OptionsTests, ParsesCompileRust) { const char* argv[] = { "aidl", "--lang=rust", kCompileCommandIncludePath, "-o src_out", kCompileCommandInput, nullptr, }; unique_ptr options = GetOptions(argv); EXPECT_EQ(Options::Task::COMPILE, options->GetTask()); EXPECT_EQ(Options::Language::RUST, options->TargetLanguage()); EXPECT_EQ(false, options->FailOnParcelable()); EXPECT_EQ(1u, options->ImportDirs().size()); EXPECT_EQ(0u, options->PreprocessedFiles().size()); EXPECT_EQ(string{kCompileCommandInput}, options->InputFiles().front()); EXPECT_EQ(string{""}, options->OutputFile()); EXPECT_EQ(string{""}, options->OutputHeaderDir()); EXPECT_EQ(string{"src_out/"}, options->OutputDir()); EXPECT_EQ(false, options->AutoDepFile()); EXPECT_EQ(false, options->DependencyFileNinja()); } TEST(OptionsTests, ParsesCompileJavaInvalid_OutRequired) { // -o option is required string expected_error = "Output directory is not set. Set with --out."; CaptureStderr(); const char* arg_with_no_out_dir[] = { "aidl", "--lang=java", kCompileCommandIncludePath, "directory/input1.aidl", "directory/input2.aidl", "directory/input3.aidl", nullptr, }; EXPECT_EQ(false, GetOptions(arg_with_no_out_dir)->Ok()); EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr(expected_error)); } TEST(OptionsTests, ParsesCompileJavaInvalid_RejectHeaderOut) { string expected_error = "Header output directory is set, which does not make sense for Java."; CaptureStderr(); // -h options is not for Java const char* arg_with_header_dir[] = { "aidl", "--lang=java", kCompileCommandIncludePath, "-o src_out", "-h header_out", "directory/input1.aidl", "directory/input2.aidl", "directory/input3.aidl", nullptr, }; EXPECT_EQ(false, GetOptions(arg_with_header_dir)->Ok()); EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr(expected_error)); } TEST(OptionsTests, ParsesCompileCppMultiInput) { const char* argv[] = { "aidl", "--lang=cpp", kCompileCommandIncludePath, "-h header_out", "-o src_out", "directory/input1.aidl", "directory/input2.aidl", "directory/input3.aidl", nullptr, }; unique_ptr options = GetOptions(argv); EXPECT_EQ(Options::Task::COMPILE, options->GetTask()); EXPECT_EQ(Options::Language::CPP, options->TargetLanguage()); EXPECT_EQ(false, options->FailOnParcelable()); EXPECT_EQ(1u, options->ImportDirs().size()); EXPECT_EQ(0u, options->PreprocessedFiles().size()); const vector expected_input{"directory/input1.aidl", "directory/input2.aidl", "directory/input3.aidl"}; EXPECT_EQ(expected_input, options->InputFiles()); EXPECT_EQ(string{""}, options->OutputFile()); EXPECT_EQ(false, options->AutoDepFile()); EXPECT_EQ(false, options->DependencyFileNinja()); EXPECT_EQ(string{"header_out/"}, options->OutputHeaderDir()); EXPECT_EQ(string{"src_out/"}, options->OutputDir()); } TEST(OptionsTests, ParsesCompileCppInvalid_OutRequired) { // -o option is required string expected_error = "Output directory is not set. Set with --out."; CaptureStderr(); const char* arg_with_no_out_dir[] = { "aidl", "--lang=cpp", kCompileCommandIncludePath, "directory/input1.aidl", "directory/input2.aidl", "directory/input3.aidl", nullptr, }; EXPECT_EQ(false, GetOptions(arg_with_no_out_dir)->Ok()); EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr(expected_error)); } TEST(OptionsTests, ParsesCompileCppInvalid_HeaderOutRequired) { // -h options is required as well string expected_error = "Header output directory is not set. Set with --header_out"; CaptureStderr(); const char* arg_with_no_header_dir[] = { "aidl", "--lang=cpp", kCompileCommandIncludePath, "-o src_out", "directory/input1.aidl", "directory/input2.aidl", "directory/input3.aidl", nullptr, }; EXPECT_EQ(false, GetOptions(arg_with_no_header_dir)->Ok()); EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr(expected_error)); } TEST(OptionsTests, ParsesCompileRustInvalid_OutRequired) { // -o option is required string expected_error = "Output directory is not set. Set with --out"; CaptureStderr(); const char* arg_with_no_out_dir[] = { "aidl", "--lang=rust", kCompileCommandIncludePath, "directory/input1.aidl", "directory/input2.aidl", "directory/input3.aidl", nullptr, }; EXPECT_EQ(false, GetOptions(arg_with_no_out_dir)->Ok()); EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr(expected_error)); } TEST(OptionsTests, ParsesCompileRustInvalid_RejectHeaderOut) { string expected_error = "Header output directory is set, which does not make sense for Rust."; CaptureStderr(); // -h options is not for Rust const char* arg_with_header_dir[] = { "aidl", "--lang=rust", kCompileCommandIncludePath, "-o src_out", "-h header_out", "directory/input1.aidl", "directory/input2.aidl", "directory/input3.aidl", nullptr, }; EXPECT_EQ(false, GetOptions(arg_with_header_dir)->Ok()); EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr(expected_error)); } TEST(OptionsTests, ParsesWarningEnableAll) { const char* args[] = { "aidl", "--lang=java", "-Weverything", "--out=out", "input.aidl", nullptr, }; auto options = GetOptions(args); EXPECT_TRUE(options->Ok()); auto mapping = options->GetDiagnosticMapping(); EXPECT_EQ(DiagnosticSeverity::WARNING, mapping.Severity(DiagnosticID::interface_name)); } TEST(OptionsTests, ParsesWarningEnableSpecificWarning) { const char* args[] = { "aidl", "--lang=java", "-Winterface-name", "--out=out", "input.aidl", nullptr, }; auto options = GetOptions(args); EXPECT_TRUE(options->Ok()); auto mapping = options->GetDiagnosticMapping(); EXPECT_EQ(DiagnosticSeverity::WARNING, mapping.Severity(DiagnosticID::interface_name)); } TEST(OptionsTests, ParsesWarningDisableSpecificWarning) { const char* args[] = { "aidl", "--lang=java", "-Weverything", "-Wno-interface-name", "--out=out", "input.aidl", nullptr, }; auto options = GetOptions(args); EXPECT_TRUE(options->Ok()); auto mapping = options->GetDiagnosticMapping(); EXPECT_EQ(DiagnosticSeverity::DISABLED, mapping.Severity(DiagnosticID::interface_name)); } TEST(OptionsTests, ParsesWarningAsErrors) { const char* args[] = { "aidl", "--lang=java", "-Werror", "-Weverything", "--out=out", "input.aidl", nullptr, }; auto options = GetOptions(args); EXPECT_TRUE(options->Ok()); auto mapping = options->GetDiagnosticMapping(); EXPECT_EQ(DiagnosticSeverity::ERROR, mapping.Severity(DiagnosticID::interface_name)); } TEST(OptionsTests, RejectsUnknownWarning) { const char* args[] = { "aidl", "--lang=java", "-Wfoobar", "--out=out", "input.aidl", nullptr, }; CaptureStderr(); auto options = GetOptions(args); EXPECT_FALSE(options->Ok()); EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr("unknown warning: foobar")); } TEST(OptionsTests, CheckApi) { const char* args[] = { "aidl", "--checkapi", "old", "new", nullptr, }; CaptureStderr(); auto options = GetOptions(args); EXPECT_TRUE(options->Ok()); EXPECT_EQ("", GetCapturedStderr()); EXPECT_EQ(Options::Task::CHECK_API, options->GetTask()); EXPECT_EQ(Options::CheckApiLevel::COMPATIBLE, options->GetCheckApiLevel()); } TEST(OptionsTests, CheckApiWithCompatible) { const char* args[] = { "aidl", "--checkapi=compatible", "old", "new", nullptr, }; CaptureStderr(); auto options = GetOptions(args); EXPECT_TRUE(options->Ok()); EXPECT_EQ("", GetCapturedStderr()); EXPECT_EQ(Options::Task::CHECK_API, options->GetTask()); EXPECT_EQ(Options::CheckApiLevel::COMPATIBLE, options->GetCheckApiLevel()); } TEST(OptionsTests, CheckApiWithEqual) { const char* args[] = { "aidl", "--checkapi=equal", "old", "new", nullptr, }; CaptureStderr(); auto options = GetOptions(args); EXPECT_TRUE(options->Ok()); EXPECT_EQ("", GetCapturedStderr()); EXPECT_EQ(Options::Task::CHECK_API, options->GetTask()); EXPECT_EQ(Options::CheckApiLevel::EQUAL, options->GetCheckApiLevel()); } TEST(OptionsTests, CheckApiWithUnknown) { const char* args[] = { "aidl", "--checkapi=unknown", "old", "new", nullptr, }; CaptureStderr(); auto options = GetOptions(args); EXPECT_FALSE(options->Ok()); EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr("Unsupported --checkapi level: 'unknown'")); } TEST(OptionsTest, AcceptValidMinSdkVersion) { const char* args[] = { "aidl", "--lang=java", "--min_sdk_version=30", "--out=out", "input.aidl", nullptr, }; auto options = GetOptions(args); EXPECT_TRUE(options->Ok()); EXPECT_EQ(30u, options->GetMinSdkVersion()); } TEST(OptionsTests, AcceptTCodeNameAsMinSdkVersion) { const char* args[] = { "aidl", "--lang=java", "--min_sdk_version=Tiramisu", "--out=out", "input.aidl", nullptr, }; auto options = GetOptions(args); EXPECT_TRUE(options->Ok()); EXPECT_EQ(33u, options->GetMinSdkVersion()); } TEST(OptionsTests, AcceptUCodeNameAsMinSdkVersion) { const char* args[] = { "aidl", "--lang=java", "--min_sdk_version=UpsideDownCake", "--out=out", "input.aidl", nullptr, }; auto options = GetOptions(args); EXPECT_TRUE(options->Ok()); EXPECT_EQ(34u, options->GetMinSdkVersion()); } TEST(OptionsTests, AcceptVCodeNameAsMinSdkVersion) { const char* args[] = { "aidl", "--lang=java", "--min_sdk_version=VanillaIceCream", "--out=out", "input.aidl", nullptr, }; auto options = GetOptions(args); EXPECT_TRUE(options->Ok()); EXPECT_EQ(10000u, options->GetMinSdkVersion()); // TODO: finalize to version } TEST(OptionsTest, DefaultMinSdkVersion) { const char* args[] = { "aidl", "--lang=java", "--out=out", "input.aidl", nullptr, }; auto options = GetOptions(args); EXPECT_TRUE(options->Ok()); EXPECT_EQ(DEFAULT_SDK_VERSION_JAVA, options->GetMinSdkVersion()); } TEST(OptionsTest, RejectInvalidMinSdkVersion) { const char* args[] = { "aidl", "--lang=java", "--min_sdk_version=NOT_A_VERSION", "--out=out", "input.aidl", nullptr, }; CaptureStderr(); auto options = GetOptions(args); EXPECT_FALSE(options->Ok()); EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr("Invalid SDK version: NOT_A_VERSION")); } TEST(OptionsTest, RejectOldMinSdkVersion) { const char* args[] = { "aidl", "--lang=cpp", "--min_sdk_version=22", "--out=out", "--header_out=out", "input.aidl", nullptr, }; CaptureStderr(); auto options = GetOptions(args); EXPECT_FALSE(options->Ok()); EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr("Min SDK version should at least be 23")); } TEST(OptionsTest, RejectRpcOnOldSdkVersion) { const char* args[] = { "aidl", "--lang=java", "--rpc", "--min_sdk_version=23", "--out=out", "input.aidl", nullptr, }; CaptureStderr(); auto options = GetOptions(args); EXPECT_FALSE(options->Ok()); EXPECT_THAT(GetCapturedStderr(), testing::HasSubstr("RPC code requires minimum SDK version of at least")); } } // namespace aidl } // namespace android ./PaxHeaders.X/os.h0100644 0000000 0000000 00000000034 15172120304 013066 xustar000000000 0000000 28 mtime=1776853188.3580000 os.h0100644 0000000 0000000 00000001325 15172120304 010373 0ustar000000000 0000000 /* * Copyright 2015, 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. */ #pragma once #if defined(_WIN32) #define OS_PATH_SEPARATOR '\\' #else #define OS_PATH_SEPARATOR '/' #endif ./PaxHeaders.X/parser.cpp0100644 0000000 0000000 00000000034 15172120304 014274 xustar000000000 0000000 28 mtime=1776853188.3580000 parser.cpp0100644 0000000 0000000 00000026046 15172120304 011610 0ustar000000000 0000000 /* * Copyright (C) 2019, 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 "parser.h" #include #include "aidl_language_y.h" #include "logging.h" void yylex_init(void**); void yylex_destroy(void*); void yyset_in(FILE* f, void*); int yyparse(Parser*); YY_BUFFER_STATE yy_scan_buffer(char*, size_t, void*); void yy_delete_buffer(YY_BUFFER_STATE, void*); // For each union, generate nested "Tag" enum type so that "Tag" can be used as a valid type. // union Foo { int a; int b; } => union Foo { ... enum Tag { a, b }} struct UnionTagGenerater : AidlVisitor { void Visit(const AidlUnionDecl& decl) override { std::vector> enumerators; for (const auto& field : decl.GetFields()) { enumerators.push_back(std::make_unique(AIDL_LOCATION_HERE, field->GetName(), nullptr, field->GetComments())); } auto tag_enum = std::make_unique(AIDL_LOCATION_HERE, "Tag", &enumerators, decl.GetPackage(), Comments{}); // Tag for @FixedSize union is limited to "byte" type so that it can be passed via FMQ with // with lower overhead. std::shared_ptr backing_type{ AidlConstantValue::String(AIDL_LOCATION_HERE, decl.IsFixedSize() ? "\"byte\"" : "\"int\"")}; std::vector> annotations; annotations.push_back( AidlAnnotation::Parse(AIDL_LOCATION_HERE, "Backing", {{"type", backing_type}}, Comments{})); tag_enum->Annotate(std::move(annotations)); const_cast(decl).AddType(std::move(tag_enum)); } }; const AidlDocument* Parser::Parse(const std::string& filename, const android::aidl::IoDelegate& io_delegate, AidlTypenames& typenames, bool is_preprocessed) { auto clean_path = android::aidl::IoDelegate::CleanPath(filename); // reuse pre-parsed document from typenames for (auto& doc : typenames.AllDocuments()) { if (doc->GetLocation().GetFile() == clean_path) { return doc.get(); } } // Make sure we can read the file first, before trashing previous state. unique_ptr raw_buffer = io_delegate.GetFileContents(clean_path); if (raw_buffer == nullptr) { AIDL_ERROR(clean_path) << "Error while opening file for parsing"; return nullptr; } // We're going to scan this buffer in place, and yacc demands we put two // nulls at the end. raw_buffer->append(2u, '\0'); Parser parser(clean_path, *raw_buffer, is_preprocessed); if (yy::parser(&parser).parse() != 0 || parser.HasError()) { return nullptr; } // Preprocess parsed document before adding to typenames. UnionTagGenerater v; VisitTopDown(v, *parser.document_); // transfer ownership to AidlTypenames and return the raw pointer const AidlDocument* result = parser.document_.get(); if (!typenames.AddDocument(std::move(parser.document_))) { return nullptr; } return result; } void Parser::SetTypeParameters(AidlTypeSpecifier* type, std::vector>* type_args) { if (type->IsArray()) { AIDL_ERROR(type) << "Must specify type parameters (<>) before array ([])."; AddError(); } if (!type->SetTypeParameters(type_args)) { AIDL_ERROR(type) << "Can only specify one set of type parameters."; AddError(); delete type_args; } } void Parser::CheckValidTypeName(const AidlToken& token, const AidlLocation& loc) { if (!is_preprocessed_ && token.GetText().find('.') != std::string::npos) { AIDL_ERROR(loc) << "Type name can't be qualified. Use `package`."; AddError(); } } void Parser::SetPackage(const std::string& package) { if (is_preprocessed_) { AIDL_ERROR(package) << "Preprocessed file can't declare package."; AddError(); } package_ = package; } bool CheckNoRecursiveDefinition(const AidlNode& node) { struct Visitor : AidlVisitor { enum { NOT_STARTED = 0, STARTED = 1, FINISHED = 2, }; std::map visited; std::vector path; bool found_cycle = false; void Visit(const AidlStructuredParcelable& t) override { FindCycle(&t); } void Visit(const AidlUnionDecl& t) override { FindCycle(&t); } void Visit(const AidlParcelable& t) override { FindCycle(&t); } bool FindCycle(const AidlParcelable* p) { // no need to search further if (found_cycle) { return true; } // we just found a cycle if (visited[p] == STARTED) { path.push_back(p->GetName()); AIDL_ERROR(p) << p->GetName() << " is a recursive parcelable: " << android::base::Join(path, "->"); return (found_cycle = true); } // we arrived here with a different route. if (visited[p] == FINISHED) { return false; } // start DFS visited[p] = STARTED; path.push_back(p->GetName()); for (const auto& f : p->GetFields()) { const auto& ref = f->GetType(); if (!ref.IsArray() && !ref.IsHeapNullable()) { const auto& type = ref.GetDefinedType(); if (type && type->AsParcelable()) { if (FindCycle(type->AsParcelable())) { return true; } } } } path.pop_back(); visited[p] = FINISHED; return false; } } v; VisitTopDown(v, node); return !v.found_cycle; } // Each Visit*() method can use Scope() to get its scope(AidlDefinedType) class ScopedVisitor : public AidlVisitor { protected: const AidlDefinedType* Scope() const { AIDL_FATAL_IF(scope_.empty(), AIDL_LOCATION_HERE) << "Scope is empty"; return scope_.back(); } void PushScope(const AidlDefinedType* scope) { scope_.push_back(scope); } void PopScope() { scope_.pop_back(); } // Keep user defined type as a defining scope void VisitScopedTopDown(const AidlNode& node) { std::function top_down = [&](const AidlNode& a) { a.DispatchVisit(*this); auto defined_type = AidlCast(a); if (defined_type) PushScope(defined_type); a.TraverseChildren(top_down); if (defined_type) PopScope(); }; top_down(node); } private: std::vector scope_ = {}; }; class TypeReferenceResolver : public ScopedVisitor { public: TypeReferenceResolver(TypeResolver& resolver) : resolver_(resolver) {} void Visit(const AidlTypeSpecifier& t) override { // We're visiting the same node again. This can happen when two constant references // point to an ancestor of this node. if (t.IsResolved()) { return; } AidlTypeSpecifier& type = const_cast(t); if (!resolver_(Scope(), &type)) { AIDL_ERROR(type) << "Failed to resolve '" << type.GetUnresolvedName() << "'"; success_ = false; return; } // In case a new document is imported for the type reference, enqueue it for type resolution. auto resolved = t.GetDefinedType(); if (resolved) { queue_.push(&resolved->GetDocument()); } } bool Resolve(const AidlDocument& document) { queue_.push(&document); while (!queue_.empty()) { auto doc = queue_.front(); queue_.pop(); // Skip the doc if it's visited already. if (!visited_.insert(doc).second) { continue; } VisitScopedTopDown(*doc); } return success_; } private: TypeResolver& resolver_; bool success_ = true; std::queue queue_ = {}; std::set visited_ = {}; }; class ConstantReferenceResolver : public ScopedVisitor { public: ConstantReferenceResolver() = default; void Visit(const AidlConstantReference& v) override { if (IsCircularReference(&v)) { success_ = false; return; } const AidlConstantValue* resolved = v.Resolve(Scope()); if (!resolved) { AIDL_ERROR(v) << "Unknown reference '" << v.Literal() << "'"; success_ = false; return; } // On error, skip recursive visiting to avoid redundant messages if (!success_) { return; } // resolve recursive references PushConstRef(&v); VisitScopedTopDown(*resolved); PopConstRef(); } bool Resolve(const AidlDocument& document) { VisitScopedTopDown(document); return success_; } private: void PushConstRef(const AidlConstantReference* ref) { stack_.push_back(ref); if (ref->GetRefType()) { PushScope(ref->GetRefType()->GetDefinedType()); } } void PopConstRef() { if (stack_.back()->GetRefType()) { PopScope(); } stack_.pop_back(); } bool IsCircularReference(const AidlConstantReference* ref) { auto it = std::find_if(stack_.begin(), stack_.end(), [&](const auto& elem) { return elem == ref; }); if (it == stack_.end()) { return false; } std::vector path; while (it != stack_.end()) { path.push_back((*it)->Literal()); ++it; } path.push_back(ref->Literal()); AIDL_ERROR(ref) << "Found a circular reference: " << android::base::Join(path, " -> "); return true; } bool success_ = true; std::vector stack_ = {}; }; // Resolve references(types/constants) in the "main" document. bool ResolveReferences(const AidlDocument& document, TypeResolver& type_resolver) { // Types are resolved first before resolving constant references so that every referenced document // gets imported. if (!TypeReferenceResolver(type_resolver).Resolve(document)) { return false; } if (!ConstantReferenceResolver().Resolve(document)) { return false; } if (!CheckNoRecursiveDefinition(document)) { return false; } return true; } Parser::Parser(const std::string& filename, std::string& raw_buffer, bool is_preprocessed) : filename_(filename), is_preprocessed_(is_preprocessed) { yylex_init(&scanner_); buffer_ = yy_scan_buffer(&raw_buffer[0], raw_buffer.length(), scanner_); } Parser::~Parser() { yy_delete_buffer(buffer_, scanner_); yylex_destroy(scanner_); } void Parser::MakeDocument(const AidlLocation& location, const Comments& comments, std::vector imports, std::vector> defined_types) { AIDL_FATAL_IF(document_.get(), location); document_ = std::make_unique(location, comments, std::move(imports), std::move(defined_types), is_preprocessed_); } ./PaxHeaders.X/parser.h0100644 0000000 0000000 00000000034 15172120304 013741 xustar000000000 0000000 28 mtime=1776853188.3590000 parser.h0100644 0000000 0000000 00000007144 15172120304 011253 0ustar000000000 0000000 /* * Copyright (C) 2019, 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. */ #pragma once #include "aidl_language.h" #include "aidl_typenames.h" #include "comments.h" #include "io_delegate.h" #include "logging.h" #include "options.h" #include #include #include struct yy_buffer_state; typedef yy_buffer_state* YY_BUFFER_STATE; class AidlToken { public: AidlToken(const std::string& text, android::aidl::Comments comments) : text_(text), comments_(std::move(comments)) {} ~AidlToken() = default; AidlToken(const AidlToken&) = delete; AidlToken(AidlToken&&) = delete; AidlToken& operator=(const AidlToken&) = delete; AidlToken& operator=(AidlToken&&) = delete; const std::string& GetText() const { return text_; } const android::aidl::Comments& GetComments() const { return comments_; } template void Append(T&& text) { text_ += std::forward(text); } private: std::string text_; android::aidl::Comments comments_; }; using TypeResolver = std::function; bool ResolveReferences(const AidlDocument& document, TypeResolver& resolver); class Parser { public: // non-copyable, non-assignable Parser(const Parser&) = delete; Parser& operator=(const Parser&) = delete; ~Parser(); // Parse contents of file |filename|. Should only be called once. static const AidlDocument* Parse(const std::string& filename, const android::aidl::IoDelegate& io_delegate, AidlTypenames& typenames, bool is_preprocessed = false); void AddError() { error_++; } bool HasError() const { return error_ != 0; } const std::string& FileName() const { return filename_; } void* Scanner() const { return scanner_; } AidlDocument* GetDocument() { return document_.get(); } // This restricts the grammar to something more reasonable. One alternative // would be to support multiple sets of type specifiers in our AST, but then a // lot of later code would have to deal with this more complicated type. So, // in order to keep the AST simpler, restricting the grammar here. // // Takes ownership of type_args, modifies type. void SetTypeParameters(AidlTypeSpecifier* type, std::vector>* type_args); // fully-qualified type names are allowed only in preprocessed files void CheckValidTypeName(const AidlToken& token, const AidlLocation& loc); void SetPackage(const std::string& package); const std::string& Package() const { return package_; } void MakeDocument(const AidlLocation& location, const Comments& comments, std::vector imports, std::vector> defined_types); private: explicit Parser(const std::string& filename, std::string& raw_buffer, bool is_preprocessed); std::string filename_; bool is_preprocessed_; std::string package_; void* scanner_ = nullptr; YY_BUFFER_STATE buffer_; int error_ = 0; std::unique_ptr document_; }; ./PaxHeaders.X/permission.cpp0100644 0000000 0000000 00000000034 15172120304 015170 xustar000000000 0000000 28 mtime=1776853188.3590000 permission.cpp0100644 0000000 0000000 00000002620 15172120304 012474 0ustar000000000 0000000 /* * Copyright (C) 2021, 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 "permission.h" #include #include #include #include #include namespace android { namespace aidl { namespace perm { std::string AsJavaAnnotation(const Expression& expr) { if (const auto& s = std::get_if(&expr); s) { return JavaFullName(*s); } if (const auto& all = std::get_if(&expr); all) { return all->JavaAnnotation(); } if (const auto& any = std::get_if(&expr); any) { return any->JavaAnnotation(); } return ""; } std::string JavaFullName(const std::string& permission) { if (permission.find('.') == std::string::npos) { return "android.Manifest.permission." + permission; } return permission; } } // namespace perm } // namespace aidl } // namespace android ./PaxHeaders.X/permission.h0100644 0000000 0000000 00000000034 15172120304 014635 xustar000000000 0000000 28 mtime=1776853188.3590000 permission.h0100644 0000000 0000000 00000003326 15172120304 012145 0ustar000000000 0000000 /* * Copyright (C) 2021, 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. */ #pragma once #include #include #include #include #include namespace android { namespace aidl { namespace perm { struct AnyOf; struct AllOf; typedef std::variant Expression; std::string AsJavaAnnotation(const Expression& expr); std::string JavaFullName(const std::string& permission); struct AnyOf { std::vector operands; std::string JavaAnnotation() const { std::string ret("anyOf = {"); for (size_t i = 0; i < operands.size(); i++) { ret += android::aidl::perm::JavaFullName(operands[i]); if (i != operands.size() - 1) { ret += ", "; } } return ret + "}"; } }; struct AllOf { std::vector operands; std::string JavaAnnotation() const { std::string ret("allOf = {"); for (size_t i = 0; i < operands.size(); i++) { ret += android::aidl::perm::JavaFullName(operands[i]); if (i != operands.size() - 1) { ret += ", "; } } return ret + "}"; } }; } // namespace perm } // namespace aidl } // namespace android ./PaxHeaders.X/preprocess.cpp0100644 0000000 0000000 00000000034 15172120304 015165 xustar000000000 0000000 28 mtime=1776853188.3590000 preprocess.cpp0100644 0000000 0000000 00000011174 15172120304 012475 0ustar000000000 0000000 /* * Copyright (C) 2021, 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 "preprocess.h" #include #include "aidl.h" using android::base::Join; namespace android { namespace aidl { namespace { // PreprocessVisitor emits // - types including comments(hide/deprecated) and annotations // - constant delcarations for interface/parcelable/unions // - enumerators for enums struct PreprocessVisitor : AidlVisitor { CodeWriter& out; PreprocessVisitor(CodeWriter& out) : out(out) {} void DumpType(const AidlDefinedType& dt, const string& type) { DumpComments(dt); DumpAnnotations(dt); // Top-level definition emits canonical name while nested type emits "name" only. if (dt.GetParentType()) { out << type << " " << dt.GetName(); } else { out << type << " " << dt.GetCanonicalName(); } if (auto generic_type = dt.AsParameterizable(); generic_type && generic_type->IsGeneric()) { out << "<" << Join(generic_type->GetTypeParameters(), ", ") << ">"; } } void DumpMembers(const AidlDefinedType& dt) { out << " {\n"; out.Indent(); for (const auto& constdecl : dt.GetConstantDeclarations()) { constdecl->DispatchVisit(*this); } for (const auto& nested : dt.GetNestedTypes()) { nested->DispatchVisit(*this); } out.Dedent(); out << "}\n"; } void DumpComments(const AidlCommentable& c) { const auto hidden = c.IsHidden(); const auto deprecated = FindDeprecated(c.GetComments()); if (hidden || deprecated) { out << "/**\n"; if (hidden) { out << " * @hide\n"; } if (deprecated) { out << " * @deprecated " << deprecated->note << "\n"; } out << " */\n"; } } void DumpAnnotations(const AidlAnnotatable& a) { auto annotations = a.ToString(); if (!annotations.empty()) { out << annotations << "\n"; } } void DumpConstantValue(const AidlTypeSpecifier& type, const AidlConstantValue& c) { out << c.ValueString(type, AidlConstantValueDecorator); } void Visit(const AidlInterface& t) override { DumpType(t, "interface"); DumpMembers(t); } void Visit(const AidlParcelable& t) override { DumpType(t, "parcelable"); if (const auto& cpp_header = t.GetCppHeader(); !cpp_header.empty()) { out << " cpp_header " << cpp_header; } if (const auto& ndk_header = t.GetNdkHeader(); !ndk_header.empty()) { out << " ndk_header " << ndk_header; } if (const auto& rust_type = t.GetRustType(); !rust_type.empty()) { out << " rust_type " << rust_type; } out << ";\n"; } void Visit(const AidlStructuredParcelable& t) override { DumpType(t, "parcelable"); DumpMembers(t); } void Visit(const AidlUnionDecl& t) override { DumpType(t, "union"); DumpMembers(t); } void Visit(const AidlEnumDeclaration& t) override { DumpType(t, "enum"); out << " {\n"; out.Indent(); for (const auto& e : t.GetEnumerators()) { out << e->GetName() << " = "; DumpConstantValue(t.GetBackingType(), *e->GetValue()); out << ",\n"; } out.Dedent(); out << "}\n"; } void Visit(const AidlConstantDeclaration& c) override { DumpComments(c); out << "const "; Visit(c.GetType()); out << " " << c.GetName() << " = "; DumpConstantValue(c.GetType(), c.GetValue()); out << ";\n"; } void Visit(const AidlTypeSpecifier& t) override { out << t.ToString(); } }; } // namespace bool Preprocess(const Options& options, const IoDelegate& io_delegate) { unique_ptr writer = io_delegate.GetCodeWriter(options.OutputFile()); PreprocessVisitor visitor(*writer); for (const auto& file : options.InputFiles()) { AidlTypenames typenames; auto result = internals::load_and_validate_aidl(file, options, io_delegate, &typenames, nullptr); if (result == AidlError::OK) { const auto& doc = typenames.MainDocument(); for (const auto& t : doc.DefinedTypes()) { t->DispatchVisit(visitor); } } else { return false; } } return writer->Close(); } } // namespace aidl } // namespace android ./PaxHeaders.X/preprocess.h0100644 0000000 0000000 00000000034 15172120304 014632 xustar000000000 0000000 28 mtime=1776853188.3590000 preprocess.h0100644 0000000 0000000 00000001514 15172120304 012137 0ustar000000000 0000000 /* * Copyright (C) 2021, 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. */ #pragma once #include "aidl_language.h" #include "code_writer.h" namespace android { namespace aidl { bool Preprocess(const Options& options, const IoDelegate& io_delegate); } // namespace aidl } // namespace android ./PaxHeaders.X/run_integration_tests.sh0100644 0000000 0000000 00000000034 15172120304 017261 xustar000000000 0000000 28 mtime=1776853188.3590000 run_integration_tests.sh0100755 0000000 0000000 00000004003 15172120304 014565 0ustar000000000 0000000 #!/usr/bin/env bash # 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. set -ex # TODO(b/156942077): when this test was converted to atest, we lost the ability # to see test results on stdout, and we can't print out the gtest results on # stderr because it breaks python test parsing. So, this file is added to help # run integration tests. $ANDROID_BUILD_TOP/build/soong/soong_ui.bash --make-mode \ MODULES-IN-system-tools-aidl adb root adb wait-for-device adb sync data adb push \ ${ANDROID_PRODUCT_OUT}/testcases/aidl_test_java_service/*/aidl_test_java_service.jar \ /data/framework/aidl_test_java_service.jar adb push \ ${ANDROID_PRODUCT_OUT}/testcases/aidl_test_java_client/*/aidl_test_java_client.jar \ /data/framework/aidl_test_java_client.jar adb push \ ${ANDROID_PRODUCT_OUT}/testcases/aidl_test_java_service_sdk29/*/aidl_test_java_service_sdk29.jar \ /data/framework/aidl_test_java_service_sdk29.jar adb push \ ${ANDROID_PRODUCT_OUT}/testcases/aidl_test_java_client_sdk29/*/aidl_test_java_client_sdk29.jar \ /data/framework/aidl_test_java_client_sdk29.jar adb push \ ${ANDROID_PRODUCT_OUT}/testcases/aidl_test_java_service_sdk1/*/aidl_test_java_service_sdk1.jar \ /data/framework/aidl_test_java_service_sdk1.jar adb push \ ${ANDROID_PRODUCT_OUT}/testcases/aidl_test_java_client_sdk1/*/aidl_test_java_client_sdk1.jar \ /data/framework/aidl_test_java_client_sdk1.jar ${ANDROID_BUILD_TOP}/system/tools/aidl/tests/aidl_integration_test.py ./PaxHeaders.X/rustfmt.toml0100644 0000000 0000000 00000000034 15172120304 014675 xustar000000000 0000000 28 mtime=1776853188.3590000 rustfmt.toml0100644 0000000 0000000 00000000000 15172120304 021344 2../../../build/soong/scripts/rustfmt.tomlustar000000000 0000000 ./PaxHeaders.X/scripts_0100644 0000000 0000000 00000000034 15172120304 014045 xustar000000000 0000000 28 mtime=1776853188.3590000 scripts/0040755 0000000 0000000 00000000000 15172120304 011272 5ustar000000000 0000000 ./PaxHeaders.X/scripts_example_dep_build_failure_output.txt0100644 0000000 0000000 00000000034 15172120304 023375 xustar000000000 0000000 28 mtime=1776853188.3600000 scripts/example_dep_build_failure_output.txt0100644 0000000 0000000 00000025146 15172120304 020631 0ustar000000000 0000000 ============================================ PLATFORM_VERSION_CODENAME=UpsideDownCake PLATFORM_VERSION=UpsideDownCake TARGET_PRODUCT=aosp_cf_x86_64_phone TARGET_BUILD_VARIANT=userdebug TARGET_ARCH=x86_64 TARGET_ARCH_VARIANT=silvermont TARGET_2ND_ARCH=x86 TARGET_2ND_ARCH_VARIANT=silvermont HOST_OS=linux HOST_OS_EXTRA=Linux-5.18.16-1rodete1-amd64-x86_64-Debian-GNU/Linux-rodete HOST_CROSS_OS=windows BUILD_ID=AOSP.MASTER OUT_DIR=out ============================================ [100% 1/1] analyzing Android.bp files and generating ninja file at out/soong/build.ninja FAILED: out/soong/build.ninja cd "$(dirname "out/host/linux-x86/bin/soong_build")" && BUILDER="$PWD/$(basename "out/host/linux-x86/bin/soong_build")" && cd / && env -i "$BUILDER" --top "$TOP" --soong_out "out/soong" --out "out" -o out/soong/build.ninja --globListDir build --globFile out/soong/globs-build.ninja -t -l out/.module_paths/Android.bp.list --available_env out/soong/soong.environment.available --used_env out/soong/soong.environment.used.build Android.bp error: hardware/interfaces/automotive/audiocontrol/aidl/Android.bp:12:1: module "android.hardware.automotive.audiocontrol-V2-java" variant "android_common" (created by module "android.hardware.automotive.audiocontrol-V2-java-generator" (created by module "android.hardware.automotive.audiocontrol_interface")): depends on multiple versions of the same aidl_interface: android.media.audio.common.types-V1-java-source, android.media.audio.common.types-V2-java-source error: hardware/interfaces/automotive/audiocontrol/aidl/Android.bp:12:1: module "android.hardware.automotive.audiocontrol-V2-java" variant "android_common" (created by module "android.hardware.automotive.audiocontrol-V2-java-generator" (created by module "android.hardware.automotive.audiocontrol_interface")): Dependency path: via tag java.dependencyTag: { name:staticlib runtimeLinked:false toolchain:false} -> android.hardware.audio.common-V1-java{os:android,arch:common,apex:} via tag java.dependencyTag: { name:staticlib runtimeLinked:false toolchain:false} -> android.media.audio.common.types-V1-java{os:android,arch:common,apex:} via tag android.sourceOrOutputDependencyTag: { moduleName:android.media.audio.common.types-V1-java-source tag:} -> android.media.audio.common.types-V1-java-source{} error: hardware/interfaces/automotive/audiocontrol/aidl/Android.bp:12:1: module "android.hardware.automotive.audiocontrol-V2-java" variant "android_common" (created by module "android.hardware.automotive.audiocontrol-V2-java-generator" (created by module "android.hardware.automotive.audiocontrol_interface")): Dependency path: via tag java.dependencyTag: { name:staticlib runtimeLinked:false toolchain:false} -> android.media.audio.common.types-V2-java{os:android,arch:common,apex:} via tag android.sourceOrOutputDependencyTag: { moduleName:android.media.audio.common.types-V2-java-source tag:} -> android.media.audio.common.types-V2-java-source{} error: hardware/interfaces/automotive/audiocontrol/aidl/Android.bp:12:1: module "android.hardware.automotive.audiocontrol-V1-java" variant "android_common" (created by module "android.hardware.automotive.audiocontrol-V1-java-generator" (created by module "android.hardware.automotive.audiocontrol_interface")): depends on multiple versions of the same aidl_interface: android.media.audio.common.types-V1-java-source, android.media.audio.common.types-V2-java-source error: hardware/interfaces/automotive/audiocontrol/aidl/Android.bp:12:1: module "android.hardware.automotive.audiocontrol-V1-java" variant "android_common" (created by module "android.hardware.automotive.audiocontrol-V1-java-generator" (created by module "android.hardware.automotive.audiocontrol_interface")): Dependency path: via tag java.dependencyTag: { name:staticlib runtimeLinked:false toolchain:false} -> android.hardware.audio.common-V1-java{os:android,arch:common,apex:} via tag java.dependencyTag: { name:staticlib runtimeLinked:false toolchain:false} -> android.media.audio.common.types-V1-java{os:android,arch:common,apex:} via tag android.sourceOrOutputDependencyTag: { moduleName:android.media.audio.common.types-V1-java-source tag:} -> android.media.audio.common.types-V1-java-source{} error: hardware/interfaces/automotive/audiocontrol/aidl/Android.bp:12:1: module "android.hardware.automotive.audiocontrol-V1-java" variant "android_common" (created by module "android.hardware.automotive.audiocontrol-V1-java-generator" (created by module "android.hardware.automotive.audiocontrol_interface")): Dependency path: via tag java.dependencyTag: { name:staticlib runtimeLinked:false toolchain:false} -> android.media.audio.common.types-V2-java{os:android,arch:common,apex:} via tag android.sourceOrOutputDependencyTag: { moduleName:android.media.audio.common.types-V2-java-source tag:} -> android.media.audio.common.types-V2-java-source{} error: hardware/interfaces/audio/aidl/Android.bp:90:1: module "android.hardware.audio.core-V1-java" variant "android_common" (created by module "android.hardware.audio.core-V1-java-generator" (created by module "android.hardware.audio.core_interface")): depends on multiple versions of the same aidl_interface: android.media.audio.common.types-V1-java-source, android.media.audio.common.types-V2-java-source error: hardware/interfaces/audio/aidl/Android.bp:90:1: module "android.hardware.audio.core-V1-java" variant "android_common" (created by module "android.hardware.audio.core-V1-java-generator" (created by module "android.hardware.audio.core_interface")): Dependency path: via tag java.dependencyTag: { name:staticlib runtimeLinked:false toolchain:false} -> android.hardware.audio.common-V1-java{os:android,arch:common,apex:} via tag java.dependencyTag: { name:staticlib runtimeLinked:false toolchain:false} -> android.media.audio.common.types-V1-java{os:android,arch:common,apex:} via tag android.sourceOrOutputDependencyTag: { moduleName:android.media.audio.common.types-V1-java-source tag:} -> android.media.audio.common.types-V1-java-source{} error: hardware/interfaces/audio/aidl/Android.bp:90:1: module "android.hardware.audio.core-V1-java" variant "android_common" (created by module "android.hardware.audio.core-V1-java-generator" (created by module "android.hardware.audio.core_interface")): Dependency path: via tag java.dependencyTag: { name:staticlib runtimeLinked:false toolchain:false} -> android.media.audio.common.types-V2-java{os:android,arch:common,apex:} via tag android.sourceOrOutputDependencyTag: { moduleName:android.media.audio.common.types-V2-java-source tag:} -> android.media.audio.common.types-V2-java-source{} error: hardware/interfaces/automotive/audiocontrol/aidl/Android.bp:12:1: module "android.hardware.automotive.audiocontrol-V3-java" variant "android_common" (created by module "android.hardware.automotive.audiocontrol-V3-java-generator" (created by module "android.hardware.automotive.audiocontrol_interface")): depends on multiple versions of the same aidl_interface: android.media.audio.common.types-V1-java-source, android.media.audio.common.types-V2-java-source error: hardware/interfaces/automotive/audiocontrol/aidl/Android.bp:12:1: module "android.hardware.automotive.audiocontrol-V3-java" variant "android_common" (created by module "android.hardware.automotive.audiocontrol-V3-java-generator" (created by module "android.hardware.automotive.audiocontrol_interface")): Dependency path: via tag java.dependencyTag: { name:staticlib runtimeLinked:false toolchain:false} -> android.hardware.audio.common-V1-java{os:android,arch:common,apex:} via tag java.dependencyTag: { name:staticlib runtimeLinked:false toolchain:false} -> android.media.audio.common.types-V1-java{os:android,arch:common,apex:} via tag android.sourceOrOutputDependencyTag: { moduleName:android.media.audio.common.types-V1-java-source tag:} -> android.media.audio.common.types-V1-java-source{} error: hardware/interfaces/automotive/audiocontrol/aidl/Android.bp:12:1: module "android.hardware.automotive.audiocontrol-V3-java" variant "android_common" (created by module "android.hardware.automotive.audiocontrol-V3-java-generator" (created by module "android.hardware.automotive.audiocontrol_interface")): Dependency path: via tag java.dependencyTag: { name:staticlib runtimeLinked:false toolchain:false} -> android.media.audio.common.types-V2-java{os:android,arch:common,apex:} via tag android.sourceOrOutputDependencyTag: { moduleName:android.media.audio.common.types-V2-java-source tag:} -> android.media.audio.common.types-V2-java-source{} error: hardware/interfaces/audio/aidl/Android.bp:147:1: module "android.hardware.audio.effect-V1-java" variant "android_common" (created by module "android.hardware.audio.effect-V1-java-generator" (created by module "android.hardware.audio.effect_interface")): depends on multiple versions of the same aidl_interface: android.media.audio.common.types-V1-java-source, android.media.audio.common.types-V2-java-source error: hardware/interfaces/audio/aidl/Android.bp:147:1: module "android.hardware.audio.effect-V1-java" variant "android_common" (created by module "android.hardware.audio.effect-V1-java-generator" (created by module "android.hardware.audio.effect_interface")): Dependency path: via tag java.dependencyTag: { name:staticlib runtimeLinked:false toolchain:false} -> android.hardware.audio.common-V1-java{os:android,arch:common,apex:} via tag java.dependencyTag: { name:staticlib runtimeLinked:false toolchain:false} -> android.media.audio.common.types-V1-java{os:android,arch:common,apex:} via tag android.sourceOrOutputDependencyTag: { moduleName:android.media.audio.common.types-V1-java-source tag:} -> android.media.audio.common.types-V1-java-source{} error: hardware/interfaces/audio/aidl/Android.bp:147:1: module "android.hardware.audio.effect-V1-java" variant "android_common" (created by module "android.hardware.audio.effect-V1-java-generator" (created by module "android.hardware.audio.effect_interface")): Dependency path: via tag java.dependencyTag: { name:staticlib runtimeLinked:false toolchain:false} -> android.media.audio.common.types-V2-java{os:android,arch:common,apex:} via tag android.sourceOrOutputDependencyTag: { moduleName:android.media.audio.common.types-V2-java-source tag:} -> android.media.audio.common.types-V2-java-source{} ninja: build stopped: subcommand failed. 21:43:11 soong bootstrap failed with: exit status 1 #### failed to build some targets (46 seconds) #### ./PaxHeaders.X/scripts_redundancy_check_0100644 0000000 0000000 00000000034 15172120304 017416 xustar000000000 0000000 28 mtime=1776853188.3600000 scripts/redundancy_check/0040755 0000000 0000000 00000000000 15172120304 014563 5ustar000000000 0000000 ./PaxHeaders.X/scripts_redundancy_check_Android.bp0100644 0000000 0000000 00000000034 15172120304 021317 xustar000000000 0000000 28 mtime=1776853188.3600000 scripts/redundancy_check/Android.bp0100644 0000000 0000000 00000001455 15172120304 016470 0ustar000000000 0000000 package { default_applicable_licenses: ["system_tools_aidl_license"], } // Example usage: // // m aidl_redundancy_check // aidl_redundancy_check \ // --installed-files-json $OUT/installed-files.json \ // --aidl-metadata-json $ANDROID_BUILD_TOP/out/soong/.intermediates/system/tools/aidl/build/aidl_metadata_json/aidl_metadata.json rust_binary_host { name: "aidl_redundancy_check", srcs: ["srcs/main.rs"], rustlibs: [ "libanyhow", "libregex", "libserde", "libserde_json", "libclap", ], } rust_test_host { name: "aidl_redundancy_check.test", srcs: ["srcs/main.rs"], rustlibs: [ "libanyhow", "libregex", "libserde", "libserde_json", "libclap", ], test_suites: ["general-tests"], } ./PaxHeaders.X/scripts_redundancy_check_srcs_0100644 0000000 0000000 00000000034 15172120304 020450 xustar000000000 0000000 28 mtime=1776853188.3600000 scripts/redundancy_check/srcs/0040755 0000000 0000000 00000000000 15172120304 015535 5ustar000000000 0000000 ./PaxHeaders.X/scripts_redundancy_check_srcs_main.rs0100644 0000000 0000000 00000000034 15172120304 021740 xustar000000000 0000000 28 mtime=1776853188.3600000 scripts/redundancy_check/srcs/main.rs0100644 0000000 0000000 00000013511 15172120304 017025 0ustar000000000 0000000 /* * Copyright (C) 2022, 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. */ //! Reports redundant AIDL libraries included in a partition. use anyhow::{Context, Result}; use clap::Parser; use std::collections::BTreeMap; use std::fs::File; use std::io::BufReader; use std::path::{Path, PathBuf}; #[derive(Parser, Debug)] #[structopt()] struct Opt { /// JSON file with list of files installed in a partition, e.g. "$OUT/installed-files.json". #[clap(long)] installed_files_json: PathBuf, /// JSON file with metadata for AIDL interfaces. Optional, but fewer checks are performed when /// unset. #[clap(long)] aidl_metadata_json: Option, } /// "aidl_metadata.json" entry. #[derive(Debug, serde::Deserialize)] struct AidlInterfaceMetadata { /// Name of module defining package. name: String, } /// "installed-files.json" entry. #[derive(Debug, serde::Deserialize)] struct InstalledFile { /// Full file path. #[serde(rename = "Name")] name: String, /// File size. #[serde(rename = "Size")] size: u64, } #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] enum LibDir { Lib, Lib64, } /// An instance of an AIDL interface lib. #[derive(Debug, PartialEq, Eq, PartialOrd, Ord)] struct AidlInstance { installed_path: String, size: u64, name: String, variant: String, // e.g. "ndk" or "cpp" version: usize, lib_dir: LibDir, } /// Deserializes a JSON file at `path` into an object of type `T`. fn read_json_file(path: &Path) -> Result { let file = File::open(path).with_context(|| format!("failed to open: {}", path.display()))?; serde_json::from_reader(BufReader::new(file)) .with_context(|| format!("failed to read: {}", path.display())) } /// Extracts AIDL lib info an `InstalledFile`, mainly by parsing the file path. Returns `None` if /// it doesn't look like an AIDL lib. fn extract_aidl_instance(installed_file: &InstalledFile) -> Option { // example: android.hardware.security.keymint-V2-ndk.so let lib_regex = regex::Regex::new(r".*/(lib|lib64)/([^-]*)-V(\d+)-([^.]+)\.") .expect("failed to parse regex"); let captures = lib_regex.captures(&installed_file.name)?; let (dir, name, version, variant) = (&captures[1], &captures[2], &captures[3], &captures[4]); Some(AidlInstance { installed_path: installed_file.name.clone(), size: installed_file.size, name: name.to_string(), variant: variant.to_string(), version: version.parse().unwrap(), lib_dir: if dir == "lib64" { LibDir::Lib64 } else { LibDir::Lib }, }) } fn main() -> Result<()> { let args = Opt::parse(); // Read the metadata file if available. let metadata_list: Option> = match &args.aidl_metadata_json { Some(aidl_metadata_json) => read_json_file(aidl_metadata_json)?, None => None, }; let is_valid_aidl_lib = |name: &str| match &metadata_list { Some(x) => x.iter().any(|metadata| metadata.name == name), None => true, }; // Read the "installed-files.json" and create a list of AidlInstance. let installed_files: Vec = read_json_file(&args.installed_files_json)?; let instances: Vec = installed_files .iter() .filter_map(extract_aidl_instance) .filter(|instance| { if !is_valid_aidl_lib(&instance.name) { eprintln!( "WARNING: {} looks like an AIDL lib, but has no metadata", &instance.installed_path ); return false; } true }) .collect(); // Group redundant AIDL lib instances together. let groups: BTreeMap<(String, LibDir), Vec<&AidlInstance>> = instances.iter().fold(BTreeMap::new(), |mut acc, x| { let key = (x.name.clone(), x.lib_dir); acc.entry(key).or_default().push(x); acc }); let mut total_wasted_bytes = 0; for (group_key, mut instances) in groups { if instances.len() > 1 { instances.sort(); // Prefer the highest version, break ties favoring ndk. let preferred_instance = instances .iter() .max_by_key(|x| (x.version, i32::from(x.variant == "ndk"))) .unwrap(); let wasted_bytes: u64 = instances.iter().filter(|x| *x != preferred_instance).map(|x| x.size).sum(); println!("Found redundant AIDL instances for {:?}", group_key); for instance in instances.iter() { println!( "\t{}\t({:.2} KiB){}", instance.installed_path, instance.size as f64 / 1024.0, if instance == preferred_instance { " <- preferred" } else { "" } ); } total_wasted_bytes += wasted_bytes; println!("\t(potential savings: {:.2} KiB)", wasted_bytes as f64 / 1024.0); println!(); } } println!("total potential savings: {:.2} KiB", total_wasted_bytes as f64 / 1024.0); Ok(()) } #[cfg(test)] mod tests { use super::*; use clap::CommandFactory; #[test] fn verify_opt() { Opt::command().debug_assert(); } } ./PaxHeaders.X/scripts_vis_aidl_ver_errors.py0100644 0000000 0000000 00000000034 15172120304 020457 xustar000000000 0000000 28 mtime=1776853188.3600000 scripts/vis_aidl_ver_errors.py0100755 0000000 0000000 00000002537 15172120304 015715 0ustar000000000 0000000 #!/usr/bin/env python3 # note - needs # sudo apt-get install python3-networkx python3-matplotlib import matplotlib.pyplot as plt import networkx as nx import re import fileinput # okay - not actually using this now # groups : 1 -> module name, 2 -> ultimate deps RE_highlevel = re.compile("error: [^ ]* module \"([^\"]*)\" variant \"[^\"]*\" .*? depends on multiple versions of the same aidl_interface: (.*)\n") # groups : 1 -> module name RE_dependencyStart = re.compile("error: [^ ]* module \"([^\"]*)\" variant \"[^\"]*\" .*? Dependency path.*\n") # groups : 1 -> module name RE_dependencyCont = re.compile(" *-> ([^{]*){.*\n") RE_ignore= re.compile(" *via tag.*{.*}.*\n") # [(module, module)] graph = [] last = None for i in fileinput.input(): # could validate consistency of this graph based on this if RE_highlevel.fullmatch(i): continue m = RE_dependencyStart.fullmatch(i) if m: last = m.groups()[0] continue m = RE_dependencyCont.fullmatch(i) if m: curr = m.groups()[0] graph += [(last, curr)] last = curr continue if RE_ignore.fullmatch(i): continue print("UNRECOGNIZED LINE", i.strip()) #for a,b in graph: # print(a,b) G = nx.MultiDiGraph() G.add_edges_from(graph) plt.figure(figsize=(10,10)) nx.draw(G, connectionstyle='arc3,rad=0.01', with_labels=True) plt.show() ./PaxHeaders.X/tests_0100644 0000000 0000000 00000000034 15172120304 013520 xustar000000000 0000000 28 mtime=1776853188.3600000 tests/0040755 0000000 0000000 00000000000 15172120304 010745 5ustar000000000 0000000 ./PaxHeaders.X/tests_aidl_integration_test.py0100644 0000000 0000000 00000000034 15172120304 020443 xustar000000000 0000000 28 mtime=1776853188.3600000 tests/aidl_integration_test.py0100755 0000000 0000000 00000034005 15172120304 015674 0ustar000000000 0000000 #!/usr/bin/env python3 from itertools import product from time import sleep import pipes import re import subprocess import sys import textwrap import unittest BITNESS_32 = ("", "32") BITNESS_64 = ("64", "64") APP_PROCESS_FOR_PRETTY_BITNESS = 'app_process%s' CPP_TEST_SERVICE_FOR_BITNESS = ' /data/nativetest%s/aidl_test_service/aidl_test_service%s' CPP_TEST_CLIENT_FOR_BITNESS = ' /data/nativetest%s/aidl_test_client/aidl_test_client%s' CPP_TEST_V1_CLIENT_FOR_BITNESS = ' /data/nativetest%s/aidl_test_v1_client/aidl_test_v1_client%s' NDK_TEST_SERVICE_FOR_BITNESS = ' /data/nativetest%s/aidl_test_service_ndk/aidl_test_service_ndk%s' NDK_TEST_CLIENT_FOR_BITNESS = ' /data/nativetest%s/aidl_test_client_ndk/aidl_test_client_ndk%s' RUST_TEST_CLIENT_FOR_BITNESS = ' /data/nativetest%s/aidl_test_rust_client/aidl_test_rust_client%s' RUST_TEST_SERVICE_FOR_BITNESS = ' /data/nativetest%s/aidl_test_rust_service/aidl_test_rust_service%s' RUST_TEST_SERVICE_ASYNC_FOR_BITNESS = ' /data/nativetest%s/aidl_test_rust_service_async/aidl_test_rust_service_async%s' # From AidlTestsJava.java INSTRUMENTATION_SUCCESS_PATTERN = r'TEST SUCCESS\n$' class ShellResultFail(Exception): """Raised on test failures.""" def __init__(self, err): stderr = textwrap.indent(err.stderr, " ") stdout = textwrap.indent(err.stdout, " ") super().__init__(f"STDOUT:\n{stdout}\nSTDERR:\n{stderr}\nRESULT:{err.exit_status}") def pretty_bitness(bitness): """Returns a human readable version of bitness, corresponding to BITNESS_* variable""" return bitness[-1] class ShellResult(object): """Represents the result of running a shell command.""" def __init__(self, exit_status, stdout, stderr): """Construct an instance. Args: exit_status: integer exit code of shell command stdout: string stdout of shell command stderr: string stderr of shell command """ self.stdout = stdout self.stderr = stderr self.exit_status = exit_status def printable_string(self): """Get a string we could print to the logs and understand.""" output = [] output.append('stdout:') for line in self.stdout.splitlines(): output.append(' > %s' % line) output.append('stderr:') for line in self.stderr.splitlines(): output.append(' > %s' % line) return '\n'.join(output) class AdbHost(object): """Represents a device connected via ADB.""" def run(self, command, background=False, ignore_status=False): """Run a command on the device via adb shell. Args: command: string containing a shell command to run. background: True iff we should run this command in the background. ignore_status: True iff we should ignore the command's exit code. Returns: instance of ShellResult. Raises: subprocess.CalledProcessError on command exit != 0. """ if background: command = '( %s ) /dev/null 2>&1 &' % command return self.adb('shell %s' % pipes.quote(command), ignore_status=ignore_status) def adb(self, command, ignore_status=False): """Run an ADB command (e.g. `adb sync`). Args: command: string containing command to run ignore_status: True iff we should ignore the command's exit code. Returns: instance of ShellResult. Raises: subprocess.CalledProcessError on command exit != 0. """ command = 'adb %s' % command p = subprocess.Popen(command, shell=True, close_fds=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True) stdout, stderr = p.communicate() if not ignore_status and p.returncode: raise subprocess.CalledProcessError(p.returncode, command) return ShellResult(p.returncode, stdout, stderr) class NativeServer: def cleanup(self): self.host.run('killall %s' % self.binary, ignore_status=True) def run(self): return self.host.run(self.binary, background=True) class NativeClient: def cleanup(self): self.host.run('killall %s' % self.binary, ignore_status=True) def run(self): result = self.host.run(self.binary + ' --gtest_color=yes', ignore_status=True) print(result.printable_string()) if result.exit_status: raise ShellResultFail(result) class CppServer(NativeServer): def __init__(self, host, bitness): self.name = "%s_bit_cpp_server" % pretty_bitness(bitness) self.host = host self.binary = CPP_TEST_SERVICE_FOR_BITNESS % bitness class CppClient(NativeClient): def __init__(self, host, bitness): self.name = "%s_bit_cpp_client" % pretty_bitness(bitness) self.host = host self.binary = CPP_TEST_CLIENT_FOR_BITNESS % bitness class CppV1Client(NativeClient): def __init__(self, host, bitness): self.name = "%s_bit_cpp_v1_client" % pretty_bitness(bitness) self.host = host self.binary = CPP_TEST_V1_CLIENT_FOR_BITNESS % bitness class NdkServer(NativeServer): def __init__(self, host, bitness): self.name = "%s_bit_ndk_server" % pretty_bitness(bitness) self.host = host self.binary = NDK_TEST_SERVICE_FOR_BITNESS % bitness class NdkClient(NativeClient): def __init__(self, host, bitness): self.name = "%s_bit_ndk_client" % pretty_bitness(bitness) self.host = host self.binary = NDK_TEST_CLIENT_FOR_BITNESS % bitness class JavaServer: def __init__(self, host, bitness): self.name = "java_server_%s" % pretty_bitness(bitness) self.host = host self.bitness = bitness def cleanup(self): self.host.run('killall ' + APP_PROCESS_FOR_PRETTY_BITNESS % pretty_bitness(self.bitness), ignore_status=True) def run(self): return self.host.run('CLASSPATH=/data/framework/aidl_test_java_service.jar ' + APP_PROCESS_FOR_PRETTY_BITNESS % pretty_bitness(self.bitness) + ' /data/framework android.aidl.service.TestServiceServer', background=True) class JavaClient: def __init__(self, host, bitness): self.name = "java_client_%s" % pretty_bitness(bitness) self.host = host self.bitness = bitness def cleanup(self): self.host.run('killall ' + APP_PROCESS_FOR_PRETTY_BITNESS % pretty_bitness(self.bitness), ignore_status=True) def run(self): result = self.host.run('CLASSPATH=/data/framework/aidl_test_java_client.jar ' + APP_PROCESS_FOR_PRETTY_BITNESS % pretty_bitness(self.bitness) + ' /data/framework android.aidl.tests.AidlJavaTests') print(result.printable_string()) if re.search(INSTRUMENTATION_SUCCESS_PATTERN, result.stdout) is None: raise ShellResultFail(result) class JavaVersionTestClient: def __init__(self, host, bitness, ver): self.name = "java_client_sdk%d_%s" % (ver, pretty_bitness(bitness)) self.host = host self.bitness = bitness self.ver = ver def cleanup(self): self.host.run('killall ' + APP_PROCESS_FOR_PRETTY_BITNESS % pretty_bitness(self.bitness), ignore_status=True) def run(self): result = self.host.run('CLASSPATH=/data/framework/aidl_test_java_client_sdk%d.jar ' % self.ver + APP_PROCESS_FOR_PRETTY_BITNESS % pretty_bitness(self.bitness) + ' /data/framework android.aidl.sdkversion.tests.AidlJavaVersionTests') print(result.printable_string()) if re.search(INSTRUMENTATION_SUCCESS_PATTERN, result.stdout) is None: raise ShellResultFail(result) class JavaVersionTestServer: def __init__(self, host, bitness, ver): self.name = "java_server_sdk%s_%s" % (ver, pretty_bitness(bitness)) self.host = host self.bitness = bitness self.ver = ver def cleanup(self): self.host.run('killall ' + APP_PROCESS_FOR_PRETTY_BITNESS % pretty_bitness(self.bitness), ignore_status=True) def run(self): return self.host.run('CLASSPATH=/data/framework/aidl_test_java_service_sdk%d.jar ' % self.ver + APP_PROCESS_FOR_PRETTY_BITNESS % pretty_bitness(self.bitness) + ' /data/framework android.aidl.sdkversion.service.AidlJavaVersionTestService', background=True) class JavaPermissionClient: def __init__(self, host, bitness): self.name = "java_client_permission_%s" % pretty_bitness(bitness) self.host = host self.bitness = bitness def cleanup(self): self.host.run('killall ' + APP_PROCESS_FOR_PRETTY_BITNESS % pretty_bitness(self.bitness), ignore_status=True) def run(self): result = self.host.run('CLASSPATH=/data/framework/aidl_test_java_client_permission.jar ' + APP_PROCESS_FOR_PRETTY_BITNESS % pretty_bitness(self.bitness) + ' /data/framework android.aidl.permission.tests.PermissionTests') print(result.printable_string()) if re.search(INSTRUMENTATION_SUCCESS_PATTERN, result.stdout) is None: raise ShellResultFail(result) class JavaPermissionServer: def __init__(self, host, bitness): self.name = "java_server_permission_%s" % pretty_bitness(bitness) self.host = host self.bitness = bitness def cleanup(self): self.host.run('killall ' + APP_PROCESS_FOR_PRETTY_BITNESS % pretty_bitness(self.bitness), ignore_status=True) def run(self): return self.host.run('CLASSPATH=/data/framework/aidl_test_java_service_permission.jar ' + APP_PROCESS_FOR_PRETTY_BITNESS % pretty_bitness(self.bitness) + ' /data/framework android.aidl.permission.service.PermissionTestService', background=True) def getprop(host, prop): return host.run('getprop "%s"' % prop).stdout.strip() class RustClient: def __init__(self, host, bitness): self.name = "%s_bit_rust_client" % pretty_bitness(bitness) self.host = host self.binary = RUST_TEST_CLIENT_FOR_BITNESS % bitness def cleanup(self): self.host.run('killall %s' % self.binary, ignore_status=True) def run(self): result = self.host.run(self.binary, ignore_status=True) print(result.printable_string()) if result.exit_status: raise ShellResultFail(result) class RustServer: def __init__(self, host, bitness): self.name = "%s_bit_rust_server" % pretty_bitness(bitness) self.host = host self.binary = RUST_TEST_SERVICE_FOR_BITNESS % bitness def cleanup(self): self.host.run('killall %s' % self.binary, ignore_status=True) def run(self): return self.host.run(self.binary, background=True) class RustAsyncServer: def __init__(self, host, bitness): self.name = "%s_bit_rust_server_async" % pretty_bitness(bitness) self.host = host self.binary = RUST_TEST_SERVICE_ASYNC_FOR_BITNESS % bitness def cleanup(self): self.host.run('killall %s' % self.binary, ignore_status=True) def run(self): return self.host.run(self.binary, background=True) def supported_bitnesses(host): bitnesses = [] if getprop(host, "ro.product.cpu.abilist32") != "": bitnesses += [BITNESS_32] if getprop(host, "ro.product.cpu.abilist64") != "": bitnesses += [BITNESS_64] return bitnesses # tests added dynamically below class TestAidl(unittest.TestCase): pass def make_test(client, server): def test(self): try: # Server is unregistered first so that we give more time # for servicemanager to clear the old notification. # Otherwise, it may race that the client gets ahold # of the service. server.cleanup() client.cleanup() sleep(0.2) server.run() client.run() finally: client.cleanup() server.cleanup() return test def add_test(client, server): test_name = 'test_%s_to_%s' % (client.name, server.name) test = make_test(client, server) setattr(TestAidl, test_name, test) if __name__ == '__main__': host = AdbHost() bitnesses = supported_bitnesses(host) if len(bitnesses) == 0: print("No clients installed") exit(1) clients = [] servers = [] for bitness in bitnesses: clients += [NdkClient(host, bitness)] servers += [NdkServer(host, bitness)] clients += [CppClient(host, bitness)] clients += [CppV1Client(host, bitness)] servers += [CppServer(host, bitness)] clients += [JavaClient(host, bitness)] servers += [JavaServer(host, bitness)] clients += [RustClient(host, bitness)] servers += [RustServer(host, bitness)] servers += [RustAsyncServer(host, bitness)] for client in clients: for server in servers: add_test(client, server) # boolean: >= 29 # typed: >= 23 versions = [1, 29] for c_version, c_bitness, s_version, s_bitness in product(versions, bitnesses, repeat=2): client = JavaVersionTestClient(host, c_bitness, c_version) server = JavaVersionTestServer(host, s_bitness, s_version) add_test(client, server) # TODO(b/218914259): Interfaces with permission are only supported for the # Java backend. Once C++ and/or Rust are supported, move the test back into # JavaClient and JavaServer. for bitness in bitnesses: add_test(JavaPermissionClient(host, bitness), JavaPermissionServer(host, bitness)) suite = unittest.TestLoader().loadTestsFromTestCase(TestAidl) sys.exit(not unittest.TextTestRunner(verbosity=2).run(suite).wasSuccessful()) ./PaxHeaders.X/tests_aidl_integration_test.xml0100644 0000000 0000000 00000000034 15172120304 020613 xustar000000000 0000000 28 mtime=1776853188.3610000 tests/aidl_integration_test.xml0100644 0000000 0000000 00000010537 15172120304 016045 0ustar000000000 0000000 ./PaxHeaders.X/tests_aidl_parser_fuzzer.cpp0100644 0000000 0000000 00000000034 15172120304 020114 xustar000000000 0000000 28 mtime=1776853188.3610000 tests/aidl_parser_fuzzer.cpp0100644 0000000 0000000 00000004620 15172120304 015342 0ustar000000000 0000000 /* * Copyright (C) 2019 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 "fake_io_delegate.h" #include "options.h" #include #include #ifdef FUZZ_LOG constexpr bool kFuzzLog = true; #else constexpr bool kFuzzLog = false; #endif using android::aidl::test::FakeIoDelegate; extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { if (size <= 1) return 0; // no use // b/145447540, large nested expressions sometimes hit the stack depth limit. // Fuzzing things of this size don't provide any additional meaningful // coverage. This is an approximate value which should allow us to explore all // of the language w/o hitting a stack overflow. if (size > 2000) return 0; FuzzedDataProvider provider = FuzzedDataProvider(data, size); FakeIoDelegate io; std::vector args; size_t numArgs = provider.ConsumeIntegralInRange(0, 20); for (size_t i = 0; i < numArgs; i++) { args.emplace_back(provider.ConsumeRandomLengthString()); } while (provider.remaining_bytes() > 0) { const std::string name = provider.ConsumeRandomLengthString(); const std::string contents = provider.ConsumeRandomLengthString(); io.SetFileContents(name, contents); } if (kFuzzLog) { std::cout << "cmd: "; for (const std::string& arg : args) { std::cout << arg << " "; } std::cout << std::endl; for (const auto& [f, input] : io.InputFiles()) { std::cout << "INPUT " << f << ": " << input << std::endl; } } int ret = android::aidl::aidl_entry(Options::From(args), io); if (kFuzzLog) { std::cout << "RET: " << ret << std::endl; if (ret != 0) { for (const auto& [f, output] : io.OutputFiles()) { std::cout << "OUTPUT " << f << ": " << std::endl; std::cout << output << std::endl; } } } return 0; } ./PaxHeaders.X/tests_aidl_parser_fuzzer.dict0100644 0000000 0000000 00000000034 15172120304 020255 xustar000000000 0000000 28 mtime=1776853188.3610000 tests/aidl_parser_fuzzer.dict0100644 0000000 0000000 00000003452 15172120304 015505 0ustar000000000 0000000 # keywords " parcelable " " import " " package " " in " " out " " inout " " cpp_header " " ndk_header " " rust_type " " const " " true " " false " " interface " " oneway " " enum " " union " # types " void " " boolean " " byte " " char " " int " " long " " float " " double " " String " " List " " List< " " Map " " Map< " " IBinder " " FileDescriptor " " CharSequence " " ParcelFileDescriptor " " java.util.List " " java.util.List< " " java.util.Map " " java.util.Map< " " android.os.ParcelFileDescriptor " " ParcelableHolder " " > " # annotations " @nullable " " @utf8InCpp " " @VintfStability " " @SensitiveData " " @UnsupportedAppUsage " " @SystemApi " " @JavaPassthrough " " @JavaOnlyStableParcelable " " @NdkOnlyStableParcelable " " @RustOnlyStableParcelable " " @Backing " " @FixedSize " " @Descriptor " " @JavaDervie " " @RustDerive " " /** @hide */ " " /** @deprecated reason */ " # annotation arguments " value " " toString " " expectedSignature " " implicitMember " " maxTargetSdk " " publicAlternatives " " trackingBug " " type " " Copy " " Clone " " PartialOrd " " Ord " " PartialEq " " Eq " " Clone " " Hash " # ignorable imports " android.os.IInterface " " android.os.IBinder " " android.os.Parcelable " " android.os.Parcel " " android.content.Context " " java.lang.String " # specific to fuzzer " a.path " " b.path " " Foo " " a/path/Foo.aidl " " b/path/Foo.aidl " " path/Foo.aidl " #arguments " aidl " " --apimapping " " --checkapi=compatible " " --checkapi=equal " " --hash " " --help " " --lang=java " " --lang=ndk " " --lang=ndk " " --lang=rust " " --log " " --ninja " " --preprocess " " --stability " " --stability=vintf " " --structured " " --trace " " --transaction_names " " -I " " -W " " -Werror " " -Weverything " " -Wno- " " -Wno-error " " -a " " -b " " -d " " -h " " -o " " -p " " -t " " -v " " -w " ./PaxHeaders.X/tests_aidl_test_client.cpp0100644 0000000 0000000 00000000034 15172120304 017530 xustar000000000 0000000 28 mtime=1776853188.3610000 tests/aidl_test_client.cpp0100644 0000000 0000000 00000001360 15172120304 014754 0ustar000000000 0000000 /* * Copyright (C) 2015 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 "gtest/gtest.h" int main(int argc, char* argv[]) { ::testing::InitGoogleTest(&argc, argv); return RUN_ALL_TESTS(); } ./PaxHeaders.X/tests_aidl_test_client.h0100644 0000000 0000000 00000000034 15172120304 017175 xustar000000000 0000000 28 mtime=1776853188.3610000 tests/aidl_test_client.h0100644 0000000 0000000 00000003527 15172120304 014430 0ustar000000000 0000000 /* * 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. */ #pragma once #include #include #include #include #include #include using android::sp; using android::aidl::tests::BackendType; using android::aidl::tests::ICppJavaTests; using android::aidl::tests::ITestService; class AidlTest : public testing::Test { public: void SetUp() override { using android::OK; using android::String16; using android::waitForService; android::ProcessState::self()->setThreadPoolMaxThreadCount(1); android::ProcessState::self()->startThreadPool(); service = waitForService(ITestService::descriptor); ASSERT_NE(nullptr, service); sp ibinder; auto status = service->GetCppJavaTests(&ibinder); ASSERT_TRUE(status.isOk()); cpp_java_tests = android::interface_cast(ibinder); status = service->getBackendType(&backend); ASSERT_TRUE(status.isOk()) << status; if (backend != BackendType::RUST && backend != BackendType::NDK) { ASSERT_NE(cpp_java_tests, nullptr); } } BackendType backend; sp service; sp cpp_java_tests; }; ./PaxHeaders.X/tests_aidl_test_client_builtin_transactions.cpp0100644 0000000 0000000 00000000034 15172120304 024046 xustar000000000 0000000 28 mtime=1776853188.3610000 tests/aidl_test_client_builtin_transactions.cpp0100644 0000000 0000000 00000001772 15172120304 021301 0ustar000000000 0000000 /* * Copyright (C) 2021 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_test_client.h" #include using android::IInterface; using android::OK; using android::String16; TEST_F(AidlTest, Ping) { EXPECT_EQ(OK, IInterface::asBinder(service)->pingBinder()); } TEST_F(AidlTest, GetInterfaceDescriptor) { EXPECT_EQ(String16("android.aidl.tests.ITestService"), IInterface::asBinder(service)->getInterfaceDescriptor()); } ./PaxHeaders.X/tests_aidl_test_client_defaultimpl.cpp0100644 0000000 0000000 00000000034 15172120304 022116 xustar000000000 0000000 28 mtime=1776853188.3610000 tests/aidl_test_client_defaultimpl.cpp0100644 0000000 0000000 00000004147 15172120304 017350 0ustar000000000 0000000 /* * Copyright (C) 2018 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "aidl_test_client.h" #include "gmock/gmock.h" using android::binder::Status; using android::aidl::tests::ITestService; using android::aidl::tests::ITestServiceDefault; using testing::Eq; static constexpr int32_t kExpectedArgValue = 100; static constexpr int32_t kExpectedReturnValue = 200; static int numCalled = 0; static int32_t gotArgument = 0; struct Def : public ITestServiceDefault { Status UnimplementedMethod(int32_t arg, int32_t* _aidl_return) override { numCalled++; gotArgument = arg; *_aidl_return = kExpectedReturnValue; return android::binder::Status::ok(); } }; /* Make sure the unimplementedMethod behaves as expected before testing the * default impl */ TEST_F(AidlTest, unimplementedMethodImpl) { int32_t returned_value; auto status = service->UnimplementedMethod(kExpectedArgValue, &returned_value); ASSERT_FALSE(status.isOk()) << status; ASSERT_EQ(status.exceptionCode(), android::binder::Status::EX_TRANSACTION_FAILED); EXPECT_EQ(status.transactionError(), android::UNKNOWN_TRANSACTION); } TEST_F(AidlTest, defaultImpl) { android::sp defImpl = android::sp::make(); auto ret = ITestService::setDefaultImpl(std::move(defImpl)); ASSERT_TRUE(ret); int32_t returned_value; auto status = service->UnimplementedMethod(kExpectedArgValue, &returned_value); ASSERT_TRUE(status.isOk()) << status; ASSERT_THAT(numCalled, Eq(1)); ASSERT_THAT(gotArgument, Eq(kExpectedArgValue)); ASSERT_THAT(returned_value, Eq(kExpectedReturnValue)); } ./PaxHeaders.X/tests_aidl_test_client_delegate.cpp0100644 0000000 0000000 00000000034 15172120304 021362 xustar000000000 0000000 28 mtime=1776853188.3610000 tests/aidl_test_client_delegate.cpp0100644 0000000 0000000 00000012570 15172120304 016613 0ustar000000000 0000000 /* * Copyright (C) 2021 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_test_client.h" #include "gmock/gmock.h" #include "android/aidl/tests/BnNamedCallback.h" #include "android/aidl/tests/BnTestService.h" using android::binder::Status; using android::String16; using android::aidl::tests::INamedCallback; using android::aidl::tests::ITestService; using android::aidl::tests::ITestServiceDelegator; static constexpr int8_t kCustomByte = 8; static_assert(std::is_same::value); struct CustomDelegator : public ITestServiceDelegator { public: CustomDelegator(sp& impl) : ITestServiceDelegator(impl) {} // Change RepeatByte to always return the same byte. Status RepeatByte(int8_t /* token */, int8_t* _aidl_return) override { *_aidl_return = kCustomByte; return Status::ok(); } }; TEST_F(AidlTest, Delegator) { auto delegator = sp::make(service); int8_t returned_value; auto status = delegator->RepeatByte(12, &returned_value); ASSERT_TRUE(status.isOk()) << status; EXPECT_EQ(12, returned_value); } TEST_F(AidlTest, CustomDelegator) { auto delegator = sp::make(service); int8_t returned_value; auto status = delegator->RepeatByte(12, &returned_value); ASSERT_TRUE(status.isOk()) << status; EXPECT_EQ(kCustomByte, returned_value); } TEST_F(AidlTest, DelegatorWithBinders) { auto delegator = sp::make(service); sp callback; auto status = delegator->GetOtherTestService(String16("callback1"), &callback); ASSERT_TRUE(status.isOk()) << status; bool verified = false; status = delegator->VerifyName(callback, String16("callback1"), &verified); ASSERT_TRUE(status.isOk()) << status; EXPECT_TRUE(verified); } TEST_F(AidlTest, DelegatorSimpl) { auto delegator = sp::make(service); sp impl = delegator->getImpl(); } TEST_F(AidlTest, DelegateWrapAndGet) { auto delegator = delegate(service); auto delegator2 = delegate(service); EXPECT_EQ(delegator, delegator2); } TEST_F(AidlTest, DelegateWrapAndUnwrap) { sp delegator = sp::cast(delegate(service)); EXPECT_NE(service, delegator); sp service2 = delegator->getImpl(); EXPECT_EQ(service, service2); auto delegator2 = delegate(sp::cast(delegator)); EXPECT_EQ(service, delegator2); } TEST_F(AidlTest, DelegatorSetAndGetBinder) { auto delegator = sp::make(service); sp callback; auto status = delegator->GetCallback(false, &callback); ASSERT_TRUE(status.isOk()) << status; // callback will be wrapped for first time and the delegator will be sent bool already_existing; status = delegator->SetOtherTestService(String16("same_one"), callback, &already_existing); ASSERT_TRUE(status.isOk()) << status; ASSERT_FALSE(already_existing); // unwrap the delegator here and get the original binder sp callback2; status = delegator->GetOtherTestService(String16("same_one"), &callback2); ASSERT_TRUE(status.isOk()) << status; EXPECT_EQ(callback, callback2); } TEST_F(AidlTest, DelegatorSettingSameBinders) { auto delegator = sp::make(service); sp callback; auto status = delegator->GetCallback(false, &callback); ASSERT_TRUE(status.isOk()) << status; bool already_existing = false; status = delegator->SetOtherTestService(String16("same_two"), callback, &already_existing); ASSERT_TRUE(status.isOk()) << status; ASSERT_FALSE(already_existing); status = delegator->SetOtherTestService(String16("same_two"), callback, &already_existing); ASSERT_TRUE(status.isOk()) << status; EXPECT_TRUE(already_existing); } TEST_F(AidlTest, DelegatorSameBinders) { auto delegator = sp::make(service); sp callback1; auto status = delegator->GetOtherTestService(String16("callback1"), &callback1); ASSERT_TRUE(status.isOk()) << status; sp callback1Copy; status = delegator->GetOtherTestService(String16("callback1"), &callback1Copy); ASSERT_TRUE(status.isOk()) << status; EXPECT_EQ(callback1, callback1Copy); } TEST_F(AidlTest, DelegatorWithCallback) { auto delegator = sp::make(service); sp callback; auto status = delegator->GetCallback(false, &callback); ASSERT_TRUE(status.isOk()) << status; String16 name; status = callback->GetName(&name); ASSERT_TRUE(status.isOk()) << status; EXPECT_TRUE(name.size() != 0); } TEST_F(AidlTest, DelegatorWithNullCallback) { auto delegator = sp::make(service); sp callback; auto status = delegator->GetCallback(true, &callback); ASSERT_TRUE(status.isOk()) << status; EXPECT_TRUE(callback == nullptr); } ./PaxHeaders.X/tests_aidl_test_client_file_descriptors.cpp0100644 0000000 0000000 00000000034 15172120304 023150 xustar000000000 0000000 28 mtime=1776853188.3620000 tests/aidl_test_client_file_descriptors.cpp0100644 0000000 0000000 00000011423 15172120304 020375 0ustar000000000 0000000 /* * Copyright (C) 2015 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 #include #include #include #include #include "aidl_test_client.h" #include "gmock/gmock.h" using android::sp; using android::base::unique_fd; using android::binder::Status; using android::os::ParcelFileDescriptor; using testing::Eq; struct FdTest : public AidlTest { void DoPipe(unique_fd* read_side, unique_fd* write_side) { int fds[2]; int ret = pipe(fds); ASSERT_THAT(ret, Eq(0)); read_side->reset(fds[0]); write_side->reset(fds[1]); } void WriteStringToFd(const std::string& str, const unique_fd& fd) { int wrote; while ((wrote = write(fd.get(), str.data(), str.size())) < 0 && errno == EINTR) ; ASSERT_THAT(wrote, Eq((signed)str.size())); } void ReadFdToStringAndCompare(const unique_fd& fd, const std::string& str) { size_t length = str.size(); int got; std::string buf; buf.resize(length); while ((got = read(fd.get(), &buf[0], length)) < 0 && errno == EINTR) ; ASSERT_THAT(buf, Eq(str)); } }; TEST_F(FdTest, fileDescriptor) { if (!cpp_java_tests) GTEST_SKIP() << "Service does not support the CPP/Java-only tests."; unique_fd read_fd; unique_fd write_fd; DoPipe(&read_fd, &write_fd); unique_fd return_fd; auto status = cpp_java_tests->RepeatFileDescriptor(std::move(write_fd), &return_fd); ASSERT_TRUE(status.isOk()); /* A note on some of the spookier stuff going on here: IIUC writes to pipes * should be atomic and non-blocking so long as the total size doesn't exceed * PIPE_BUF. We thus play a bit fast and loose with failure modes here. */ WriteStringToFd("ReturnString", return_fd); ReadFdToStringAndCompare(read_fd, "ReturnString"); } TEST_F(FdTest, fileDescriptorArray) { if (!cpp_java_tests) GTEST_SKIP() << "Service does not support the CPP/Java-only tests."; std::vector array; array.resize(2); DoPipe(&array[0], &array[1]); std::vector repeated; if (backend == BackendType::JAVA) { // other backends might require these to be valid FDs (not -1), since this // isn't @nullable, but they don't require this to already be the correct // size repeated = std::vector(array.size()); } std::vector reversed; auto status = cpp_java_tests->ReverseFileDescriptorArray(array, &repeated, &reversed); ASSERT_TRUE(status.isOk()) << status; WriteStringToFd("First", array[1]); WriteStringToFd("Second", repeated[1]); WriteStringToFd("Third", reversed[0]); ReadFdToStringAndCompare(reversed[1], "FirstSecondThird"); } TEST_F(FdTest, parcelFileDescriptor) { unique_fd read_fd; unique_fd write_fd; DoPipe(&read_fd, &write_fd); ParcelFileDescriptor return_fd; auto status = service->RepeatParcelFileDescriptor(ParcelFileDescriptor(std::move(write_fd)), &return_fd); ASSERT_TRUE(status.isOk()); /* A note on some of the spookier stuff going on here: IIUC writes to pipes * should be atomic and non-blocking so long as the total size doesn't exceed * PIPE_BUF. We thus play a bit fast and loose with failure modes here. */ WriteStringToFd("ReturnString", return_fd.release()); ReadFdToStringAndCompare(read_fd, "ReturnString"); } TEST_F(FdTest, parcelFileDescriptorArray) { std::vector array; array.resize(2); DoPipe(&array[0], &array[1]); std::vector input; for (auto& fd : array) { input.push_back(ParcelFileDescriptor(std::move(fd))); } std::vector repeated; if (backend == BackendType::JAVA) { // other backends might require these to be valid FDs (not -1), since this // isn't @nullable, but they don't require this to already be the correct // size repeated = std::vector(array.size()); } std::vector reversed; auto status = service->ReverseParcelFileDescriptorArray(input, &repeated, &reversed); ASSERT_TRUE(status.isOk()) << status; WriteStringToFd("First", input[1].release()); WriteStringToFd("Second", repeated[1].release()); WriteStringToFd("Third", reversed[0].release()); ReadFdToStringAndCompare(input[0].release(), "FirstSecondThird"); } ./PaxHeaders.X/tests_aidl_test_client_loggable_interface.cpp0100644 0000000 0000000 00000000034 15172120304 023404 xustar000000000 0000000 28 mtime=1776853188.3620000 tests/aidl_test_client_loggable_interface.cpp0100644 0000000 0000000 00000012443 15172120304 020634 0ustar000000000 0000000 /* * 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 #include "aidl_test_client.h" #include #include #include #include #include #include #include using android::IBinder; using android::sp; using android::String16; using android::aidl::loggable::BpLoggableInterface; using android::aidl::loggable::Data; using android::aidl::loggable::Enum; using android::aidl::loggable::ILoggableInterface; using android::aidl::loggable::Union; using android::aidl::tests::BackendType; using android::os::ParcelFileDescriptor; using std::optional; using std::pair; using std::string; using std::vector; using testing::Eq; TEST_F(AidlTest, LoggableInterface) { BackendType backendType; auto status = service->getBackendType(&backendType); EXPECT_TRUE(status.isOk()); if (backendType != BackendType::CPP) GTEST_SKIP(); sp loggable = android::waitForService(ILoggableInterface::descriptor); ASSERT_NE(nullptr, loggable); BpLoggableInterface::TransactionLog log; BpLoggableInterface::logFunc = [&](const BpLoggableInterface::TransactionLog& tx) { log = tx; }; bool boolValue = true; vector boolArray{false, true}; int8_t byteValue = 41; vector byteArray{42, 43}; char16_t charValue = 'x'; vector charArray{'a', 'b', 'c'}; int32_t intValue{44}; vector intArray{45, 46}; int64_t longValue = 47; vector longArray{48, 49}; float floatValue{50}; vector floatArray{51, 52}; double doubleValue{52}; vector doubleArray{53, 54}; String16 stringValue("def"); vector stringArray{String16("ghi"), String16("jkl")}; vector listValue{String16("mno")}; Data dataValue; dataValue.num = 42; dataValue.str = "abc"; dataValue.nestedUnion = "def"; dataValue.nestedEnum = Enum::FOO; sp binderValue; optional pfdValue; vector pfdArray; vector _aidl_return; status = loggable->LogThis(boolValue, &boolArray, byteValue, &byteArray, charValue, &charArray, intValue, &intArray, longValue, &longArray, floatValue, &floatArray, doubleValue, &doubleArray, stringValue, &stringArray, &listValue, dataValue, binderValue, &pfdValue, &pfdArray, &_aidl_return); EXPECT_TRUE(status.isOk()); EXPECT_EQ(vector{String16("loggable")}, _aidl_return); // check the captured log EXPECT_EQ("[loggable]", log.result); EXPECT_EQ("android.aidl.loggable.ILoggableInterface", log.interface_name); EXPECT_EQ("LogThis", log.method_name); EXPECT_EQ(0, log.exception_code); EXPECT_EQ("", log.exception_message); EXPECT_EQ(0, log.transaction_error); EXPECT_EQ(0, log.service_specific_error_code); EXPECT_THAT( log.input_args, Eq(vector>{ {"boolValue", "true"}, {"boolArray", "[false, true]"}, {"byteValue", "41"}, {"byteArray", "[42, 43]"}, {"charValue", "x"}, {"charArray", "[a, b, c]"}, {"intValue", "44"}, {"intArray", "[45, 46]"}, {"longValue", "47"}, {"longArray", "[48, 49]"}, {"floatValue", "50.000000"}, {"floatArray", "[51.000000, 52.000000]"}, {"doubleValue", "52.000000"}, {"doubleArray", "[53.000000, 54.000000]"}, {"stringValue", "def"}, {"stringArray", "[ghi, jkl]"}, {"listValue", "[mno]"}, {"dataValue", "Data{num: 42, str: abc, nestedUnion: Union{str: def}, nestedEnum: FOO}"}, {"binderValue", "(null)"}, {"pfdValue", "(null)"}, {"pfdArray", "[]"}, })); EXPECT_THAT(log.output_args, Eq(vector>{{"boolArray", "[false, true]"}, {"byteArray", "[42, 43]"}, {"charArray", "[a, b, c]"}, {"intArray", "[45, 46]"}, {"longArray", "[48, 49]"}, {"floatArray", "[51.000000, 52.000000]"}, {"doubleArray", "[53.000000, 54.000000]"}, {"stringArray", "[ghi, jkl]"}, {"listValue", "[mno]"}, {"pfdValue", "(null)"}, {"pfdArray", "[]"}})); } ./PaxHeaders.X/tests_aidl_test_client_ndk_delegate.cpp0100644 0000000 0000000 00000000034 15172120304 022216 xustar000000000 0000000 28 mtime=1776853188.3620000 tests/aidl_test_client_ndk_delegate.cpp0100644 0000000 0000000 00000005745 15172120304 017455 0ustar000000000 0000000 /* * Copyright (C) 2022 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 #include #include #include #include #include #include using aidl::android::aidl::tests::BackendType; using aidl::android::aidl::tests::ITestService; using aidl::android::aidl::tests::ITestServiceDelegator; static constexpr int8_t kCustomByte = 8; static_assert(std::is_same::value); struct CustomDelegator : public ITestServiceDelegator { public: CustomDelegator(std::shared_ptr& impl) : ITestServiceDelegator(impl) {} // Change RepeatByte to always return the same byte. ndk::ScopedAStatus RepeatByte(int8_t /* token */, int8_t* _aidl_return) override { *_aidl_return = kCustomByte; return ndk::ScopedAStatus::ok(); } }; struct AidlDelegatorTest : testing::Test { template std::shared_ptr getService() { android::ProcessState::self()->setThreadPoolMaxThreadCount(1); android::ProcessState::self()->startThreadPool(); ndk::SpAIBinder binder = ndk::SpAIBinder(AServiceManager_waitForService(T::descriptor)); return T::fromBinder(binder); } void SetUp() override { service = getService(); } std::shared_ptr service; }; TEST_F(AidlDelegatorTest, SimpleDelegator) { auto delegator = ndk::SharedRefBase::make(service); int8_t returned_value; auto status = delegator->RepeatByte(12, &returned_value); ASSERT_TRUE(status.isOk()) << status.getMessage(); EXPECT_EQ(12, returned_value); } TEST_F(AidlDelegatorTest, CustomDelegator) { auto delegator = ndk::SharedRefBase::make(service); int8_t returned_value; auto status = delegator->RepeatByte(12, &returned_value); ASSERT_TRUE(status.isOk()) << status.getMessage(); EXPECT_EQ(kCustomByte, returned_value); } TEST_F(AidlDelegatorTest, SendDelegator) { auto delegator = ndk::SharedRefBase::make(service); auto fromAsBinder = ITestServiceDelegator::fromBinder(delegator->asBinder()); // Make sure the delegator works after asBinder -> fromBinder conversions int8_t returned_value = 0; auto status = fromAsBinder->RepeatByte(12, &returned_value); ASSERT_TRUE(status.isOk()) << status.getDescription(); EXPECT_EQ(12, returned_value); } ./PaxHeaders.X/tests_aidl_test_client_ndk_loggable_interface.cpp0100644 0000000 0000000 00000000034 15172120304 024240 xustar000000000 0000000 28 mtime=1776853188.3620000 tests/aidl_test_client_ndk_loggable_interface.cpp0100644 0000000 0000000 00000014002 15172120304 021461 0ustar000000000 0000000 /* * Copyright (C) 2021 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 #include #include #include #include #include #include #include #include using aidl::android::aidl::loggable::BpLoggableInterface; using aidl::android::aidl::loggable::Data; using aidl::android::aidl::loggable::Enum; using aidl::android::aidl::loggable::ILoggableInterface; using aidl::android::aidl::tests::BackendType; using aidl::android::aidl::tests::ITestService; using std::optional; using std::pair; using std::shared_ptr; using std::string; using std::vector; using testing::Eq; struct AidlTest : testing::Test { template std::shared_ptr getService() { android::ProcessState::self()->setThreadPoolMaxThreadCount(1); android::ProcessState::self()->startThreadPool(); ndk::SpAIBinder binder = ndk::SpAIBinder(AServiceManager_waitForService(T::descriptor)); return T::fromBinder(binder); } }; TEST_F(AidlTest, LoggableInterface) { std::shared_ptr service = getService(); ASSERT_NE(nullptr, service.get()); BackendType backendType; ndk::ScopedAStatus status = service->getBackendType(&backendType); EXPECT_TRUE(status.isOk()) << status.getDescription(); if (backendType != BackendType::CPP) GTEST_SKIP(); shared_ptr loggable = getService(); ASSERT_NE(nullptr, loggable.get()); BpLoggableInterface::TransactionLog log; BpLoggableInterface::logFunc = [&](const BpLoggableInterface::TransactionLog& tx) { log = tx; }; bool boolValue = true; vector boolArray{false, true}; int8_t byteValue = 41; vector byteArray{42, 43}; char16_t charValue = 'x'; vector charArray{'a', 'b', 'c'}; int32_t intValue{44}; vector intArray{45, 46}; int64_t longValue = 47; vector longArray{48, 49}; float floatValue{50}; vector floatArray{51, 52}; double doubleValue{52}; vector doubleArray{53, 54}; string stringValue("def"); vector stringArray{string("ghi"), string("jkl")}; vector listValue{string("mno")}; Data dataValue; dataValue.num = 42; dataValue.str = "abc"; dataValue.nestedUnion = "def"; dataValue.nestedEnum = Enum::FOO; ndk::SpAIBinder binderValue; ndk::ScopedFileDescriptor pfdValue; vector pfdArray; vector _aidl_return; status = loggable->LogThis(boolValue, &boolArray, byteValue, &byteArray, charValue, &charArray, intValue, &intArray, longValue, &longArray, floatValue, &floatArray, doubleValue, &doubleArray, stringValue, &stringArray, &listValue, dataValue, binderValue, &pfdValue, &pfdArray, &_aidl_return); EXPECT_TRUE(status.isOk()); EXPECT_EQ(vector{string("loggable")}, _aidl_return); // check the captured log EXPECT_EQ("[loggable]", log.result); EXPECT_EQ("android.aidl.loggable.ILoggableInterface", log.interface_name); EXPECT_EQ("LogThis", log.method_name); EXPECT_EQ(0, log.exception_code); EXPECT_EQ("", log.exception_message); EXPECT_EQ(0, log.transaction_error); EXPECT_EQ(0, log.service_specific_error_code); EXPECT_THAT(log.input_args, Eq(vector>{ {"in_boolValue", "true"}, {"in_boolArray", "[false, true]"}, {"in_byteValue", "41"}, {"in_byteArray", "[42, 43]"}, {"in_charValue", "x"}, {"in_charArray", "[a, b, c]"}, {"in_intValue", "44"}, {"in_intArray", "[45, 46]"}, {"in_longValue", "47"}, {"in_longArray", "[48, 49]"}, {"in_floatValue", "50.000000"}, {"in_floatArray", "[51.000000, 52.000000]"}, {"in_doubleValue", "52.000000"}, {"in_doubleArray", "[53.000000, 54.000000]"}, {"in_stringValue", "def"}, {"in_stringArray", "[ghi, jkl]"}, {"in_listValue", "[mno]"}, {"in_dataValue", "Data{num: 42, str: abc, nestedUnion: Union{str: def}, nestedEnum: FOO}"}, {"in_binderValue", "binder:0x0"}, {"in_pfdValue", "fd:-1"}, {"in_pfdArray", "[]"}, })); EXPECT_THAT(log.output_args, Eq(vector>{{"in_boolArray", "[false, true]"}, {"in_byteArray", "[42, 43]"}, {"in_charArray", "[a, b, c]"}, {"in_intArray", "[45, 46]"}, {"in_longArray", "[48, 49]"}, {"in_floatArray", "[51.000000, 52.000000]"}, {"in_doubleArray", "[53.000000, 54.000000]"}, {"in_stringArray", "[ghi, jkl]"}, {"in_listValue", "[mno]"}, {"in_pfdValue", "fd:-1"}, {"in_pfdArray", "[]"}})); } ./PaxHeaders.X/tests_aidl_test_client_ndk_nested.cpp0100644 0000000 0000000 00000000034 15172120304 021726 xustar000000000 0000000 28 mtime=1776853188.3620000 tests/aidl_test_client_ndk_nested.cpp0100644 0000000 0000000 00000005526 15172120304 017162 0ustar000000000 0000000 /* * Copyright (C) 2021 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 #include #include #include #include #include #include #include #include #include using aidl::android::aidl::tests::nested::INestedService; using aidl::android::aidl::tests::nested::ParcelableWithNested; using NestedResult = aidl::android::aidl::tests::nested::INestedService::Result; using NestedStatus = aidl::android::aidl::tests::nested::ParcelableWithNested::Status; using std::optional; using std::shared_ptr; using std::vector; using testing::Eq; using testing::Optional; struct AidlTest : testing::Test { template std::shared_ptr getService() { android::ProcessState::self()->setThreadPoolMaxThreadCount(1); android::ProcessState::self()->startThreadPool(); ndk::SpAIBinder binder = ndk::SpAIBinder(AServiceManager_waitForService(T::descriptor)); return T::fromBinder(binder); } }; TEST_F(AidlTest, NestedService) { auto nestedService = getService(); ASSERT_NE(nullptr, nestedService); ParcelableWithNested p; p.status = NestedStatus::OK; NestedResult r; // OK -> NOT_OK auto status = nestedService->flipStatus(p, &r); EXPECT_TRUE(status.isOk()); EXPECT_EQ(r.status, NestedStatus::NOT_OK); // NOT_OK -> OK with callback (nested interface) struct Callback : INestedService::BnCallback { optional result; ndk::ScopedAStatus done(ParcelableWithNested::Status st) override { result = st; return ndk::ScopedAStatus::ok(); } }; auto cb = ndk::SharedRefBase::make(); status = nestedService->flipStatusWithCallback(r.status, cb); EXPECT_TRUE(status.isOk()); EXPECT_THAT(cb->result, Optional(NestedStatus::OK)); // android::enum_ranges<> vector values{ndk::enum_range().begin(), ndk::enum_range().end()}; EXPECT_EQ(values, vector({NestedStatus::OK, NestedStatus::NOT_OK})); // toString() EXPECT_EQ(toString(NestedStatus::NOT_OK), "NOT_OK"); } ./PaxHeaders.X/tests_aidl_test_client_ndk_nullables.cpp0100644 0000000 0000000 00000000034 15172120304 022425 xustar000000000 0000000 28 mtime=1776853188.3620000 tests/aidl_test_client_ndk_nullables.cpp0100644 0000000 0000000 00000012347 15172120304 017660 0ustar000000000 0000000 /* * Copyright (C) 2021 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 #include #include #include #include #include using aidl::android::aidl::tests::BackendType; using aidl::android::aidl::tests::INamedCallback; using aidl::android::aidl::tests::ITestService; using testing::Eq; struct AidlTest : testing::Test { template std::shared_ptr getService() { android::ProcessState::self()->setThreadPoolMaxThreadCount(1); android::ProcessState::self()->startThreadPool(); ndk::SpAIBinder binder = ndk::SpAIBinder(AServiceManager_waitForService(T::descriptor)); return T::fromBinder(binder); } void SetUp() override { service = getService(); auto status = service->getBackendType(&backend); ASSERT_TRUE(status.isOk()) << status.getDescription(); } std::shared_ptr service; BackendType backend; template void DoTest(ndk::ScopedAStatus (ITestService::*func)(const std::optional&, std::optional*), std::optional input) { std::optional output; auto status = (*service.*func)(input, &output); ASSERT_TRUE(status.isOk()); ASSERT_TRUE(output.has_value()); ASSERT_THAT(*output, Eq(*input)); input.reset(); status = (*service.*func)(input, &output); ASSERT_TRUE(status.isOk()); ASSERT_FALSE(output.has_value()); } }; TEST_F(AidlTest, parcelableArray) { std::vector> input; input.push_back(ITestService::Empty()); input.push_back(std::nullopt); DoTest(&ITestService::RepeatNullableParcelableArray, std::make_optional(input)); } TEST_F(AidlTest, parcelableList) { std::vector> input; input.push_back(ITestService::Empty()); input.push_back(std::nullopt); DoTest(&ITestService::RepeatNullableParcelableList, std::make_optional(input)); } TEST_F(AidlTest, nullBinder) { auto status = service->TakesAnIBinder(nullptr); ASSERT_THAT(status.getStatus(), Eq(STATUS_UNEXPECTED_NULL)) << status.getDescription(); // Note that NDK backend checks null before transaction while C++ backends doesn't. } TEST_F(AidlTest, binderListWithNull) { std::vector input{service->asBinder(), nullptr}; auto status = service->TakesAnIBinderList(input); ASSERT_THAT(status.getStatus(), Eq(STATUS_UNEXPECTED_NULL)); // Note that NDK backend checks null before transaction while C++ backends doesn't. } TEST_F(AidlTest, nonNullBinder) { auto status = service->TakesAnIBinder(service->asBinder()); ASSERT_TRUE(status.isOk()); } TEST_F(AidlTest, binderListWithoutNull) { std::vector input{service->asBinder()}; auto status = service->TakesAnIBinderList(input); ASSERT_TRUE(status.isOk()); } TEST_F(AidlTest, nullBinderToAnnotatedMethod) { auto status = service->TakesANullableIBinder(nullptr); ASSERT_TRUE(status.isOk()); } TEST_F(AidlTest, binderListWithNullToAnnotatedMethod) { std::vector input{service->asBinder(), nullptr}; auto status = service->TakesANullableIBinderList(input); ASSERT_TRUE(status.isOk()); } TEST_F(AidlTest, binderArray) { std::vector repeated; if (backend == BackendType::JAVA) { // Java can only modify out-argument arrays in-place repeated.resize(2); } // get INamedCallback for "SpAIBinder" object std::shared_ptr callback; auto status = service->GetCallback(false, &callback); ASSERT_TRUE(status.isOk()) << status.getDescription(); std::vector reversed; std::vector input{service->asBinder(), callback->asBinder()}; status = service->ReverseIBinderArray(input, &repeated, &reversed); ASSERT_TRUE(status.isOk()) << status.getDescription(); EXPECT_THAT(input, Eq(repeated)); std::reverse(std::begin(reversed), std::end(reversed)); EXPECT_THAT(input, Eq(reversed)); } TEST_F(AidlTest, nullableBinderArray) { std::optional> repeated; if (backend == BackendType::JAVA) { // Java can only modify out-argument arrays in-place repeated = std::vector(2); } std::optional> reversed; std::optional> input = std::vector{service->asBinder(), service->asBinder()}; auto status = service->ReverseNullableIBinderArray(input, &repeated, &reversed); ASSERT_TRUE(status.isOk()) << status.getDescription(); EXPECT_THAT(input, Eq(repeated)); ASSERT_TRUE(reversed); std::reverse(std::begin(*reversed), std::end(*reversed)); EXPECT_THAT(input, Eq(reversed)); } ./PaxHeaders.X/tests_aidl_test_client_ndk_parcelables.cpp0100644 0000000 0000000 00000000034 15172120304 022721 xustar000000000 0000000 28 mtime=1776853188.3620000 tests/aidl_test_client_ndk_parcelables.cpp0100644 0000000 0000000 00000021116 15172120304 020146 0ustar000000000 0000000 /* * Copyright (C) 2021 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 #include #include #include #include #include #include #include #include #include using aidl::android::aidl::fixedsizearray::FixedSizeArrayExample; using BnRepeatFixedSizeArray = aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::BnRepeatFixedSizeArray; using BpRepeatFixedSizeArray = aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::BpRepeatFixedSizeArray; using IntParcelable = aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable; using IRepeatFixedSizeArray = aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IRepeatFixedSizeArray; using BnEmptyInterface = aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::BnEmptyInterface; using aidl::android::aidl::tests::BackendType; using aidl::android::aidl::tests::ITestService; using aidl::android::aidl::tests::RecursiveList; using aidl::android::aidl::tests::SimpleParcelable; using aidl::android::aidl::tests::Union; using android::OK; using ndk::AParcel_readData; using ndk::AParcel_writeData; using ndk::ScopedAStatus; using ndk::SharedRefBase; using ndk::SpAIBinder; struct AidlTest : testing::Test { template std::shared_ptr getService() { android::ProcessState::self()->setThreadPoolMaxThreadCount(1); android::ProcessState::self()->startThreadPool(); ndk::SpAIBinder binder = ndk::SpAIBinder(AServiceManager_waitForService(T::descriptor)); return T::fromBinder(binder); } }; // TODO(b/196454897): copy more tests from aidl_test_client TEST_F(AidlTest, RepeatSimpleParcelable) { SimpleParcelable input("foo", 42); SimpleParcelable out_param, returned; auto status = getService()->RepeatSimpleParcelable(input, &out_param, &returned); ASSERT_TRUE(status.isOk()); EXPECT_EQ(input, out_param) << input.toString() << " " << out_param.toString(); EXPECT_EQ(input, returned) << input.toString() << " " << returned.toString(); } TEST_F(AidlTest, ReverseSimpleParcelable) { BackendType backend; auto status = getService()->getBackendType(&backend); ASSERT_TRUE(status.isOk()); const std::vector original{SimpleParcelable("a", 1), SimpleParcelable("b", 2), SimpleParcelable("c", 3)}; std::vector repeated; if (backend == BackendType::JAVA) { repeated = std::vector(original.size()); } std::vector reversed; status = getService()->ReverseSimpleParcelables(original, &repeated, &reversed); ASSERT_TRUE(status.isOk()); EXPECT_EQ(repeated, original); std::reverse(reversed.begin(), reversed.end()); EXPECT_EQ(reversed, original); } TEST_F(AidlTest, ReverseRecursiveList) { std::unique_ptr head; for (int i = 0; i < 10; i++) { auto node = std::make_unique(); node->value = i; node->next = std::move(head); head = std::move(node); } // head: [9, 8, ... 0] RecursiveList reversed; auto status = getService()->ReverseList(*head, &reversed); ASSERT_TRUE(status.isOk()); // reversed should be [0, 1, .. 9] RecursiveList* cur = &reversed; for (int i = 0; i < 10; i++) { EXPECT_EQ(i, cur->value); cur = cur->next.get(); } EXPECT_EQ(nullptr, cur); } TEST_F(AidlTest, GetUnionTags) { std::vector unions; std::vector tags; // test empty auto status = getService()->GetUnionTags(unions, &tags); ASSERT_TRUE(status.isOk()); EXPECT_EQ(tags, (std::vector{})); // test non-empty unions.push_back(Union::make()); unions.push_back(Union::make()); status = getService()->GetUnionTags(unions, &tags); ASSERT_TRUE(status.isOk()); EXPECT_EQ(tags, (std::vector{Union::n, Union::ns})); } TEST_F(AidlTest, FixedSizeArray) { auto parcel = AParcel_create(); FixedSizeArrayExample p; p.byteMatrix[0][0] = 0; p.byteMatrix[0][1] = 1; p.byteMatrix[1][0] = 2; p.byteMatrix[1][1] = 3; p.floatMatrix[0][0] = 0.f; p.floatMatrix[0][1] = 1.f; p.floatMatrix[1][0] = 2.f; p.floatMatrix[1][1] = 3.f; EXPECT_EQ(OK, p.writeToParcel(parcel)); AParcel_setDataPosition(parcel, 0); FixedSizeArrayExample q; EXPECT_EQ(OK, q.readFromParcel(parcel)); EXPECT_EQ(p, q); AParcel_delete(parcel); } TEST_F(AidlTest, FixedSizeArrayWithValuesAtNullableFields) { auto parcel = AParcel_create(); FixedSizeArrayExample p; p.boolNullableArray = std::array{true, false}; p.byteNullableArray = std::array{42, 0}; p.stringNullableArray = std::array, 2>{"hello", "world"}; p.boolNullableMatrix.emplace(); p.boolNullableMatrix->at(0) = std::array{true, false}; p.byteNullableMatrix.emplace(); p.byteNullableMatrix->at(0) = std::array{42, 0}; p.stringNullableMatrix.emplace(); p.stringNullableMatrix->at(0) = std::array, 2>{"hello", "world"}; EXPECT_EQ(OK, p.writeToParcel(parcel)); AParcel_setDataPosition(parcel, 0); FixedSizeArrayExample q; EXPECT_EQ(OK, q.readFromParcel(parcel)); EXPECT_EQ(p, q); AParcel_delete(parcel); } TEST_F(AidlTest, FixedSizeArrayOfBytesShouldBePacked) { auto parcel = AParcel_create(); std::array, 2> byte_array; byte_array[0] = {1, 2, 3}; byte_array[1] = {4, 5, 6}; EXPECT_EQ(OK, AParcel_writeData(parcel, byte_array)); AParcel_setDataPosition(parcel, 0); int32_t len; EXPECT_EQ(OK, AParcel_readData(parcel, &len)); EXPECT_EQ(2, len); std::vector byte_vector; EXPECT_EQ(OK, AParcel_readData(parcel, &byte_vector)); EXPECT_EQ(byte_vector, (std::vector{1, 2, 3})); EXPECT_EQ(OK, AParcel_readData(parcel, &byte_vector)); EXPECT_EQ(byte_vector, (std::vector{4, 5, 6})); AParcel_delete(parcel); } template void CheckRepeat(Service service, MemFn fn, Input input) { Input out1, out2; EXPECT_TRUE(std::invoke(fn, service, input, &out1, &out2).isOk()); EXPECT_EQ(input, out1); EXPECT_EQ(input, out2); } template std::array, 2> Make2dArray(std::initializer_list values) { std::array, 2> arr = {}; auto it = std::begin(values); for (auto& row : arr) { for (auto& el : row) { if (it == std::end(values)) break; el = *it++; } } return arr; } TEST_F(AidlTest, FixedSizeArrayOverBinder) { auto service = getService(); CheckRepeat(service, &IRepeatFixedSizeArray::RepeatBytes, (std::array{1, 2, 3})); CheckRepeat(service, &IRepeatFixedSizeArray::RepeatInts, (std::array{1, 2, 3})); auto binder1 = SharedRefBase::make()->asBinder(); auto binder2 = SharedRefBase::make()->asBinder(); auto binder3 = SharedRefBase::make()->asBinder(); CheckRepeat(service, &IRepeatFixedSizeArray::RepeatBinders, (std::array{binder1, binder2, binder3})); IntParcelable p1, p2, p3; p1.value = 1; p2.value = 2; p3.value = 3; CheckRepeat(service, &IRepeatFixedSizeArray::RepeatParcelables, (std::array{p1, p2, p3})); CheckRepeat(service, &IRepeatFixedSizeArray::Repeat2dBytes, Make2dArray({1, 2, 3})); CheckRepeat(service, &IRepeatFixedSizeArray::Repeat2dInts, Make2dArray({1, 2, 3})); // Not-nullable CheckRepeat(service, &IRepeatFixedSizeArray::Repeat2dBinders, Make2dArray({binder1, binder2, binder3, binder1, binder2, binder3})); CheckRepeat(service, &IRepeatFixedSizeArray::Repeat2dParcelables, Make2dArray({p1, p2, p3})); } ./PaxHeaders.X/tests_aidl_test_client_ndk_primitives_test.cpp0100644 0000000 0000000 00000000034 15172120304 023676 xustar000000000 0000000 28 mtime=1776853188.3630000 tests/aidl_test_client_ndk_primitives_test.cpp0100644 0000000 0000000 00000007061 15172120304 021126 0ustar000000000 0000000 /* * Copyright (C) 2021 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 #include #include #include #include #include using aidl::android::aidl::tests::INamedCallback; using aidl::android::aidl::tests::ITestService; using testing::Eq; struct AidlTest : testing::Test { template std::shared_ptr getService() { android::ProcessState::self()->setThreadPoolMaxThreadCount(1); android::ProcessState::self()->startThreadPool(); ndk::SpAIBinder binder = ndk::SpAIBinder(AServiceManager_waitForService(T::descriptor)); return T::fromBinder(binder); } }; TEST_F(AidlTest, InterfaceExchange) { auto service = getService(); std::vector names = {"Larry", "Curly", "Moe"}; for (size_t i = 0; i < names.size(); i++) { std::shared_ptr got; ASSERT_TRUE(service->GetOtherTestService(names[i], &got).isOk()); std::string name; ASSERT_TRUE(got->GetName(&name).isOk()); ASSERT_THAT(name, Eq(names[i])); } { std::vector> got; ASSERT_TRUE(service->GetInterfaceArray(names, &got).isOk()); bool verified = false; ASSERT_TRUE(service->VerifyNamesWithInterfaceArray(got, names, &verified).isOk()); ASSERT_TRUE(verified); for (size_t i = 0; i < names.size(); i++) { std::string name; ASSERT_TRUE(got[i]->GetName(&name).isOk()); ASSERT_THAT(name, Eq(names[i])); } } { std::vector> names = {"Larry", std::nullopt, "Moe"}; std::optional>> got; ASSERT_TRUE(service->GetNullableInterfaceArray(names, &got).isOk()); bool verified = false; ASSERT_TRUE(service->VerifyNamesWithNullableInterfaceArray(got, names, &verified).isOk()); ASSERT_TRUE(verified); ASSERT_TRUE(got.has_value()); for (size_t i = 0; i < names.size(); i++) { if (names[i].has_value()) { ASSERT_NE(got->at(i).get(), nullptr); std::string name; ASSERT_TRUE(got->at(i)->GetName(&name).isOk()); ASSERT_THAT(name, Eq(names[i].value())); } else { ASSERT_EQ(got->at(i).get(), nullptr); } } } { std::vector> names = {"Larry", std::nullopt, "Moe"}; std::optional>> got; ASSERT_TRUE(service->GetInterfaceList(names, &got).isOk()); bool verified = false; ASSERT_TRUE(service->VerifyNamesWithInterfaceList(got, names, &verified).isOk()); ASSERT_TRUE(verified); ASSERT_TRUE(got.has_value()); for (size_t i = 0; i < names.size(); i++) { if (names[i].has_value()) { ASSERT_NE(got->at(i).get(), nullptr); std::string name; ASSERT_TRUE(got->at(i)->GetName(&name).isOk()); ASSERT_THAT(name, Eq(names[i].value())); } else { ASSERT_EQ(got->at(i).get(), nullptr); } } } } ./PaxHeaders.X/tests_aidl_test_client_ndk_strings_test.cpp0100644 0000000 0000000 00000000034 15172120304 023174 xustar000000000 0000000 28 mtime=1776853188.3630000 tests/aidl_test_client_ndk_strings_test.cpp0100644 0000000 0000000 00000012502 15172120304 020420 0ustar000000000 0000000 /* * Copyright (C) 2021 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 #include #include #include #include #include using aidl::android::aidl::tests::BackendType; using aidl::android::aidl::tests::ITestService; using testing::Eq; struct AidlTest : testing::Test { template std::shared_ptr getService() { android::ProcessState::self()->setThreadPoolMaxThreadCount(1); android::ProcessState::self()->startThreadPool(); ndk::SpAIBinder binder = ndk::SpAIBinder(AServiceManager_waitForService(T::descriptor)); return T::fromBinder(binder); } void SetUp() override { service = getService(); auto status = service->getBackendType(&backend); ASSERT_TRUE(status.isOk()) << status.getDescription(); } std::shared_ptr service; BackendType backend; }; TEST_F(AidlTest, repeatUtf8String) { const std::vector utf8_inputs = { std::string("Deliver us from evil."), std::string(), std::string("\0\0", 2), // Similarly, the utf8 encodings of the small letter yee and euro sign. std::string("\xF0\x90\x90\xB7\xE2\x82\xAC"), ITestService::STRING_CONSTANT_UTF8, }; for (const auto& input : utf8_inputs) { std::string reply; auto status = service->RepeatUtf8CppString(input, &reply); ASSERT_TRUE(status.isOk()); ASSERT_THAT(reply, Eq(input)); } std::optional reply; auto status = service->RepeatNullableUtf8CppString(std::nullopt, &reply); ASSERT_TRUE(status.isOk()); ASSERT_FALSE(reply.has_value()); for (const auto& input : utf8_inputs) { std::optional reply; auto status = service->RepeatNullableUtf8CppString(input, &reply); ASSERT_TRUE(status.isOk()); ASSERT_TRUE(reply.has_value()); ASSERT_THAT(*reply, Eq(input)); } } TEST_F(AidlTest, reverseUtf8StringArray) { std::vector input = {"a", "", "\xc3\xb8"}; decltype(input) repeated; if (backend == BackendType::JAVA) { repeated = decltype(input)(input.size()); } decltype(input) reversed; auto status = service->ReverseUtf8CppString(input, &repeated, &reversed); ASSERT_TRUE(status.isOk()) << status.getDescription(); ASSERT_THAT(repeated, Eq(input)); decltype(input) reversed_input(input); std::reverse(reversed_input.begin(), reversed_input.end()); ASSERT_THAT(reversed, Eq(reversed_input)); } struct AidlStringArrayTest : public AidlTest { void DoTest(::ndk::ScopedAStatus (ITestService::*func)( const std::optional>>&, std::optional>>*, std::optional>>*)) { std::optional>> input; decltype(input) repeated; decltype(input) reversed; auto status = (*service.*func)(input, &repeated, &reversed); ASSERT_TRUE(status.isOk()) << status.getDescription(); if (func == &ITestService::ReverseUtf8CppStringList && backend == BackendType::JAVA) { // Java cannot clear the input variable to return a null value. It can // only ever fill out a list. ASSERT_TRUE(repeated.has_value()); } else { ASSERT_FALSE(repeated.has_value()); } ASSERT_FALSE(reversed.has_value()); input = std::vector>(); input->push_back("Deliver us from evil."); input->push_back(std::nullopt); input->push_back("\xF0\x90\x90\xB7\xE2\x82\xAC"); // usable size needs to be initialized for Java repeated = std::vector>(input->size()); status = (*service.*func)(input, &repeated, &reversed); ASSERT_TRUE(status.isOk()) << status.getDescription(); ASSERT_TRUE(reversed.has_value()); ASSERT_TRUE(repeated.has_value()); ASSERT_THAT(reversed->size(), Eq(input->size())); ASSERT_THAT(repeated->size(), Eq(input->size())); for (size_t i = 0; i < input->size(); i++) { auto input_str = (*input)[i]; auto repeated_str = (*repeated)[i]; auto reversed_str = (*reversed)[(reversed->size() - 1) - i]; if (!input_str) { ASSERT_FALSE(repeated_str.has_value()); ASSERT_FALSE(reversed_str.has_value()); // 3 nullptrs to strings. No need to compare values. continue; } ASSERT_TRUE(repeated_str.has_value()); ASSERT_TRUE(reversed_str.has_value()); ASSERT_THAT(*repeated_str, Eq(*input_str)); ASSERT_THAT(*reversed_str, Eq(*input_str)); } } }; TEST_F(AidlStringArrayTest, nullableList) { DoTest(&ITestService::ReverseUtf8CppStringList); } TEST_F(AidlStringArrayTest, nullableArray) { DoTest(&ITestService::ReverseNullableUtf8CppString); } ./PaxHeaders.X/tests_aidl_test_client_ndk_trunk_stable.cpp0100644 0000000 0000000 00000000034 15172120304 023141 xustar000000000 0000000 28 mtime=1776853188.3630000 tests/aidl_test_client_ndk_trunk_stable.cpp0100644 0000000 0000000 00000014600 15172120304 020366 0ustar000000000 0000000 /* * Copyright (C) 2023 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 #include #include #include #include #include #ifdef AIDL_USE_UNFROZEN constexpr bool kUseUnfrozen = true; #else constexpr bool kUseUnfrozen = false; #endif using aidl::android::aidl::test::trunk::ITrunkStableTest; using ndk::ScopedAStatus; using MyParcelable = aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable; using MyOtherParcelable = aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable; using MyEnum = aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum; using MyUnion = aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion; class TrunkInterfaceTest : public testing::Test { public: void SetUp() override { android::ProcessState::self()->setThreadPoolMaxThreadCount(1); android::ProcessState::self()->startThreadPool(); ndk::SpAIBinder binder = ndk::SpAIBinder(AServiceManager_waitForService(ITrunkStableTest::descriptor)); service = ITrunkStableTest::fromBinder(binder); ASSERT_NE(nullptr, service); } std::shared_ptr service; }; TEST_F(TrunkInterfaceTest, getInterfaceVersion) { // TODO(b/292539129) this should be done with an annotation instead of ifdefs // We have to match on a single char with #if, even though it is // really "enabled"/"disabled" int32_t ver = 0; auto status = service->getInterfaceVersion(&ver); ASSERT_TRUE(status.isOk()); if (kUseUnfrozen) { EXPECT_EQ(2, ver); // Check the local version as well EXPECT_EQ(2, ITrunkStableTest::version); } else { EXPECT_EQ(1, ver); // Check the local version as well EXPECT_EQ(1, ITrunkStableTest::version); } } TEST_F(TrunkInterfaceTest, getInterfaceHash) { std::string hash; std::string localHash; auto status = service->getInterfaceHash(&hash); ASSERT_TRUE(status.isOk()); if (kUseUnfrozen) { EXPECT_EQ("notfrozen", hash); // Check the local hash as well EXPECT_EQ("notfrozen", ITrunkStableTest::hash); } else { EXPECT_EQ("88311b9118fb6fe9eff4a2ca19121de0587f6d5f", hash); // Check the local hash as well EXPECT_EQ("88311b9118fb6fe9eff4a2ca19121de0587f6d5f", ITrunkStableTest::hash); } } // `c` is a new field that isn't read from the reply parcel TEST_F(TrunkInterfaceTest, repeatParcelable) { MyParcelable in, out; in.a = 14; in.b = 15; in.c = 16; auto status = service->repeatParcelable(in, &out); ASSERT_TRUE(status.isOk()) << status; if (kUseUnfrozen) { EXPECT_EQ(in.a, out.a); EXPECT_EQ(in.b, out.b); EXPECT_EQ(in.c, out.c); } else { EXPECT_EQ(in.a, out.a); EXPECT_EQ(in.b, out.b); EXPECT_NE(in.c, out.c); EXPECT_EQ(0, out.c); } } // repeatOtherParcelable is a new API that isn't implemented TEST_F(TrunkInterfaceTest, repeatOtherParcelable) { MyOtherParcelable in, out; in.a = 14; in.b = 15; auto status = service->repeatOtherParcelable(in, &out); if (kUseUnfrozen) { ASSERT_TRUE(status.isOk()) << status; EXPECT_EQ(in.a, out.a); EXPECT_EQ(in.b, out.b); } else { EXPECT_FALSE(status.isOk()) << status; EXPECT_EQ(STATUS_UNKNOWN_TRANSACTION, status.getStatus()) << status; } } // enums aren't handled differently. TEST_F(TrunkInterfaceTest, repeatEnum) { MyEnum in = MyEnum::THREE; MyEnum out = MyEnum::ZERO; auto status = service->repeatEnum(in, &out); ASSERT_TRUE(status.isOk()) << status; EXPECT_EQ(in, out); } // `c` is a new field that causes a failure if used // `b` is from V1 and will cause no failure TEST_F(TrunkInterfaceTest, repeatUnion) { MyUnion in_ok = MyUnion::make(13); MyUnion in_test = MyUnion::make(12); MyUnion out; auto status = service->repeatUnion(in_ok, &out); ASSERT_TRUE(status.isOk()) << status; EXPECT_EQ(in_ok, out); status = service->repeatUnion(in_test, &out); if (kUseUnfrozen) { ASSERT_TRUE(status.isOk()) << status; EXPECT_EQ(in_test, out); } else { ASSERT_FALSE(status.isOk()) << status; EXPECT_NE(in_test, out); } } class MyCallback : public ITrunkStableTest::BnMyCallback { public: MyCallback() {} virtual ~MyCallback() = default; ScopedAStatus repeatParcelable(const MyParcelable& input, MyParcelable* _aidl_return) override { *_aidl_return = input; repeatParcelableCalled = true; return ScopedAStatus::ok(); } ScopedAStatus repeatEnum(MyEnum input, MyEnum* _aidl_return) override { *_aidl_return = input; repeatEnumCalled = true; return ScopedAStatus::ok(); } ScopedAStatus repeatUnion(const MyUnion& input, MyUnion* _aidl_return) override { *_aidl_return = input; repeatUnionCalled = true; return ScopedAStatus::ok(); } ScopedAStatus repeatOtherParcelable(const MyOtherParcelable& input, MyOtherParcelable* _aidl_return) override { *_aidl_return = input; repeatOtherParcelableCalled = true; return ScopedAStatus::ok(); } bool repeatParcelableCalled = false; bool repeatEnumCalled = false; bool repeatUnionCalled = false; bool repeatOtherParcelableCalled = false; }; // repeatOtherParcelable is new in V2, so it won't be called TEST_F(TrunkInterfaceTest, callMyCallback) { std::shared_ptr cb = ndk::SharedRefBase::make(); auto status = service->callMyCallback(cb); ASSERT_TRUE(status.isOk()) << status; if (kUseUnfrozen) { EXPECT_TRUE(cb->repeatParcelableCalled); EXPECT_TRUE(cb->repeatEnumCalled); EXPECT_TRUE(cb->repeatUnionCalled); EXPECT_TRUE(cb->repeatOtherParcelableCalled); } else { EXPECT_TRUE(cb->repeatParcelableCalled); EXPECT_TRUE(cb->repeatEnumCalled); EXPECT_TRUE(cb->repeatUnionCalled); EXPECT_FALSE(cb->repeatOtherParcelableCalled); } } ./PaxHeaders.X/tests_aidl_test_client_ndk_versioned_interface.cpp0100644 0000000 0000000 00000000034 15172120304 024462 xustar000000000 0000000 28 mtime=1776853188.3630000 tests/aidl_test_client_ndk_versioned_interface.cpp0100644 0000000 0000000 00000010016 15172120304 021704 0ustar000000000 0000000 /* * Copyright (C) 2021 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 #include #include #include #include #include #include #include using aidl::android::aidl::tests::BackendType; using aidl::android::aidl::tests::ITestService; using aidl::android::aidl::versioned::tests::BazUnion; using aidl::android::aidl::versioned::tests::Foo; using aidl::android::aidl::versioned::tests::IFooInterface; using std::optional; using std::pair; using std::shared_ptr; using std::string; using std::vector; using testing::Eq; struct VersionedInterfaceTest : ::testing::Test { void SetUp() override { android::ProcessState::self()->setThreadPoolMaxThreadCount(1); android::ProcessState::self()->startThreadPool(); ndk::SpAIBinder binder = ndk::SpAIBinder(AServiceManager_waitForService(IFooInterface::descriptor)); versioned = IFooInterface::fromBinder(binder); ASSERT_NE(nullptr, versioned); ndk::SpAIBinder testServiceBinder = ndk::SpAIBinder(AServiceManager_waitForService(ITestService::descriptor)); auto service = ITestService::fromBinder(testServiceBinder); auto status = service->getBackendType(&backend); EXPECT_TRUE(status.isOk()) << status.getDescription(); } shared_ptr versioned; BackendType backend; }; TEST_F(VersionedInterfaceTest, getInterfaceVersion) { int32_t version; auto status = versioned->getInterfaceVersion(&version); EXPECT_TRUE(status.isOk()) << status.getDescription(); EXPECT_EQ(1, version); } TEST_F(VersionedInterfaceTest, getInterfaceHash) { string hash; auto status = versioned->getInterfaceHash(&hash); EXPECT_TRUE(status.isOk()) << status.getDescription(); EXPECT_EQ("9e7be1859820c59d9d55dd133e71a3687b5d2e5b", hash); } TEST_F(VersionedInterfaceTest, noProblemWhenPassingAUnionWithOldField) { std::string result; auto status = versioned->acceptUnionAndReturnString(BazUnion::make(42), &result); EXPECT_TRUE(status.isOk()) << status.getDescription(); EXPECT_EQ("42", result); } TEST_F(VersionedInterfaceTest, errorWhenPassingAUnionWithNewField) { std::string result; auto status = versioned->acceptUnionAndReturnString(BazUnion::make(42L), &result); // b/173458620 - Java and C++ return different errors if (backend == BackendType::JAVA) { EXPECT_EQ(EX_ILLEGAL_ARGUMENT, status.getExceptionCode()); } else { EXPECT_EQ(STATUS_BAD_VALUE, status.getStatus()); } } TEST_F(VersionedInterfaceTest, arrayOfParcelableWithNewField) { vector foos(42); int32_t length; auto status = versioned->returnsLengthOfFooArray(foos, &length); EXPECT_TRUE(status.isOk()) << status.getDescription(); EXPECT_EQ(42, length); } TEST_F(VersionedInterfaceTest, readDataCorrectlyAfterParcelableWithNewField) { Foo inFoo, inoutFoo, outFoo; inoutFoo.intDefault42 = 0; outFoo.intDefault42 = 0; int32_t ret; auto status = versioned->ignoreParcelablesAndRepeatInt(inFoo, &inoutFoo, &outFoo, 43, &ret); EXPECT_TRUE(status.isOk()) << status.getDescription(); EXPECT_EQ(43, ret); EXPECT_EQ(0, inoutFoo.intDefault42); EXPECT_EQ(0, outFoo.intDefault42); } TEST_F(VersionedInterfaceTest, errorWhenCallingV2Api) { auto status = versioned->newApi(); EXPECT_EQ(STATUS_UNKNOWN_TRANSACTION, status.getStatus()); } ./PaxHeaders.X/tests_aidl_test_client_nested.cpp0100644 0000000 0000000 00000000034 15172120304 021072 xustar000000000 0000000 28 mtime=1776853188.3640000 tests/aidl_test_client_nested.cpp0100644 0000000 0000000 00000004565 15172120304 016330 0ustar000000000 0000000 /* * Copyright (C) 2021 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_test_client.h" #include #include #include #include #include using android::IBinder; using android::sp; using android::String16; using android::aidl::tests::nested::INestedService; using android::aidl::tests::nested::ParcelableWithNested; using android::binder::Status; using NestedResult = android::aidl::tests::nested::INestedService::Result; using NestedStatus = android::aidl::tests::nested::ParcelableWithNested::Status; using std::optional; using std::pair; using std::string; using std::vector; using testing::Eq; using testing::Optional; TEST_F(AidlTest, NestedService) { sp nestedService = android::waitForService(INestedService::descriptor); ASSERT_NE(nullptr, nestedService); ParcelableWithNested p; p.status = NestedStatus::OK; NestedResult r; // OK -> NOT_OK EXPECT_TRUE(nestedService->flipStatus(p, &r).isOk()); EXPECT_EQ(r.status, NestedStatus::NOT_OK); // NOT_OK -> OK with callback nested interface struct Callback : INestedService::BnCallback { optional result; Status done(NestedStatus st) override { result = st; return Status::ok(); } }; sp cb = new Callback; EXPECT_TRUE(nestedService->flipStatusWithCallback(r.status, cb).isOk()); EXPECT_THAT(cb->result, Optional(NestedStatus::OK)); // android::enum_ranges<> vector values{android::enum_range().begin(), android::enum_range().end()}; EXPECT_EQ(values, vector({NestedStatus::OK, NestedStatus::NOT_OK})); // toString() EXPECT_EQ(toString(NestedStatus::NOT_OK), "NOT_OK"); } ./PaxHeaders.X/tests_aidl_test_client_nullables.cpp0100644 0000000 0000000 00000000034 15172120304 021571 xustar000000000 0000000 28 mtime=1776853188.3640000 tests/aidl_test_client_nullables.cpp0100644 0000000 0000000 00000016656 15172120304 017033 0ustar000000000 0000000 /* * Copyright (C) 2015 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 #include #include #include #include "aidl_test_client.h" #include "gmock/gmock.h" using android::BBinder; using android::IBinder; using android::sp; using android::String16; using android::String8; using android::binder::Status; using android::aidl::tests::BackendType; using android::aidl::tests::ByteEnum; using android::aidl::tests::INamedCallback; using android::aidl::tests::IntEnum; using android::aidl::tests::ITestService; using android::aidl::tests::LongEnum; using android::aidl::tests::SimpleParcelable; using android::aidl::tests::StructuredParcelable; using testing::Eq; using testing::Ne; struct RepeatNullableTest : public AidlTest { template void DoTest(Status (ITestService::*func)(const std::optional&, std::optional*), std::optional input) { std::optional output; auto status = (*service.*func)(input, &output); ASSERT_TRUE(status.isOk()); ASSERT_TRUE(output.has_value()); ASSERT_THAT(*output, Eq(*input)); input.reset(); status = (*service.*func)(input, &output); ASSERT_TRUE(status.isOk()); ASSERT_FALSE(output.has_value()); } }; TEST_F(RepeatNullableTest, intArray) { DoTest(&ITestService::RepeatNullableIntArray, std::make_optional(std::vector{1, 2, 3})); } TEST_F(RepeatNullableTest, byteEnumArray) { DoTest(&ITestService::RepeatNullableByteEnumArray, std::make_optional(std::vector{ByteEnum::FOO, ByteEnum::BAR})); } TEST_F(RepeatNullableTest, intEnumArray) { DoTest(&ITestService::RepeatNullableIntEnumArray, std::make_optional(std::vector{IntEnum::FOO, IntEnum::BAR})); } TEST_F(RepeatNullableTest, longEnumArray) { DoTest(&ITestService::RepeatNullableLongEnumArray, std::make_optional(std::vector{LongEnum::FOO, LongEnum::BAR})); } TEST_F(RepeatNullableTest, string) { DoTest(&ITestService::RepeatNullableString, std::optional("Blooob")); } TEST_F(RepeatNullableTest, stringArray) { std::vector> input; input.push_back(String16("Wat")); input.push_back(String16("Blooob")); input.push_back(String16("Wat")); input.push_back(std::nullopt); input.push_back(String16("YEAH")); input.push_back(String16("OKAAAAY")); DoTest(&ITestService::RepeatNullableStringList, std::make_optional(input)); } TEST_F(RepeatNullableTest, parcelable) { auto input = std::make_optional(); std::optional output; auto status = service->RepeatNullableParcelable(input, &output); ASSERT_TRUE(status.isOk()); ASSERT_TRUE(output.has_value()); ASSERT_THAT(*output, Eq(*input)); input.reset(); status = service->RepeatNullableParcelable(input, &output); ASSERT_TRUE(status.isOk()); ASSERT_FALSE(output.has_value()); } TEST_F(RepeatNullableTest, parcelableArray) { std::vector> input; input.push_back(ITestService::Empty()); input.push_back(std::nullopt); DoTest(&ITestService::RepeatNullableParcelableArray, std::make_optional(input)); } TEST_F(RepeatNullableTest, parcelableList) { std::vector> input; input.push_back(ITestService::Empty()); input.push_back(std::nullopt); DoTest(&ITestService::RepeatNullableParcelableList, std::make_optional(input)); } TEST_F(AidlTest, nullBinder) { auto status = service->TakesAnIBinder(nullptr); if (backend == BackendType::JAVA) { ASSERT_TRUE(status.isOk()) << status; } else if (backend == BackendType::NDK) { ASSERT_THAT(status.transactionError(), Eq(android::UNEXPECTED_NULL)) << status; } else { ASSERT_THAT(status.exceptionCode(), Eq(android::binder::Status::EX_NULL_POINTER)) << status; } } TEST_F(AidlTest, binderListWithNull) { std::vector> input{new BBinder(), nullptr}; auto status = service->TakesAnIBinderList(input); if (backend == BackendType::JAVA) { ASSERT_TRUE(status.isOk()) << status; } else if (backend == BackendType::NDK) { ASSERT_THAT(status.transactionError(), Eq(android::UNEXPECTED_NULL)) << status; } else { ASSERT_THAT(status.exceptionCode(), Eq(android::binder::Status::EX_NULL_POINTER)) << status; } } TEST_F(AidlTest, nonNullBinder) { sp input = new BBinder(); auto status = service->TakesAnIBinder(input); ASSERT_TRUE(status.isOk()); } TEST_F(AidlTest, binderListWithoutNull) { std::vector> input{new BBinder(), new BBinder()}; auto status = service->TakesAnIBinderList(input); ASSERT_TRUE(status.isOk()); } TEST_F(AidlTest, nullBinderToAnnotatedMethod) { auto status = service->TakesANullableIBinder(nullptr); ASSERT_TRUE(status.isOk()); } TEST_F(AidlTest, binderListWithNullToAnnotatedMethod) { std::vector> input{new BBinder(), nullptr}; auto status = service->TakesANullableIBinderList(input); ASSERT_TRUE(status.isOk()); } TEST_F(AidlTest, binderArray) { std::vector> repeated; if (backend == BackendType::JAVA) { // Java can only modify out-argument arrays in-place repeated.resize(2); } std::vector> reversed; std::vector> input{new BBinder(), new BBinder()}; auto status = service->ReverseIBinderArray(input, &repeated, &reversed); ASSERT_TRUE(status.isOk()) << status; EXPECT_THAT(input, Eq(repeated)); std::reverse(std::begin(reversed), std::end(reversed)); EXPECT_THAT(input, Eq(reversed)); } TEST_F(AidlTest, nullableBinderArray) { std::optional>> repeated; if (backend == BackendType::JAVA) { // Java can only modify out-argument arrays in-place repeated = std::vector>(); repeated->resize(2); } std::optional>> reversed; std::optional>> input = std::vector>{new BBinder(), nullptr}; auto status = service->ReverseNullableIBinderArray(input, &repeated, &reversed); ASSERT_TRUE(status.isOk()) << status; EXPECT_THAT(input, Eq(repeated)); ASSERT_TRUE(reversed); std::reverse(std::begin(*reversed), std::end(*reversed)); EXPECT_THAT(input, Eq(reversed)); } TEST_F(AidlTest, nonNullBinderToAnnotatedMethod) { sp input = new BBinder(); auto status = service->TakesANullableIBinder(input); ASSERT_TRUE(status.isOk()); } TEST_F(AidlTest, binderListWithoutNullToAnnotatedMethod) { std::vector> input{new BBinder(), new BBinder()}; auto status = service->TakesANullableIBinderList(input); ASSERT_TRUE(status.isOk()); } TEST_F(AidlTest, interface) { sp callback; auto status = service->GetCallback(false, &callback); ASSERT_TRUE(status.isOk()); ASSERT_THAT(callback.get(), Ne(nullptr)); } TEST_F(AidlTest, nullInterface) { sp callback; auto status = service->GetCallback(true, &callback); ASSERT_TRUE(status.isOk()); ASSERT_THAT(callback.get(), Eq(nullptr)); } ./PaxHeaders.X/tests_aidl_test_client_parcelables.cpp0100644 0000000 0000000 00000000034 15172120304 022065 xustar000000000 0000000 28 mtime=1776853188.3640000 tests/aidl_test_client_parcelables.cpp0100644 0000000 0000000 00000057720 15172120304 017324 0ustar000000000 0000000 /* * Copyright (C) 2015 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 #include #include #include #include #include #include #include "aidl_test_client.h" #include #include using android::IInterface; using android::sp; using android::String16; using android::String8; using android::aidl::fixedsizearray::FixedSizeArrayExample; using android::aidl::tests::BadParcelable; using android::aidl::tests::ConstantExpressionEnum; using android::aidl::tests::GenericStructuredParcelable; using android::aidl::tests::INamedCallback; using android::aidl::tests::IntEnum; using android::aidl::tests::ITestService; using android::aidl::tests::OtherParcelableForToString; using android::aidl::tests::ParcelableForToString; using android::aidl::tests::RecursiveList; using android::aidl::tests::SimpleParcelable; using android::aidl::tests::StructuredParcelable; using android::aidl::tests::Union; using android::aidl::tests::extension::ExtendableParcelable; using android::aidl::tests::extension::MyExt; using android::aidl::tests::extension::MyExt2; using android::aidl::tests::extension::MyExtLike; using android::aidl::tests::unions::EnumUnion; using IntParcelable = android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable; using IRepeatFixedSizeArray = android::aidl::fixedsizearray::FixedSizeArrayExample::IRepeatFixedSizeArray; using android::BBinder; using android::IBinder; using android::OK; using android::binder::Status; using android::os::PersistableBundle; using std::string; using std::vector; TEST_F(AidlTest, BadParcelable) { if (!cpp_java_tests) GTEST_SKIP() << "Service does not support the CPP/Java-only tests."; BadParcelable output; { BadParcelable bad(/*bad=*/true, "Booya", 42); Status status = cpp_java_tests->RepeatBadParcelable(bad, &output); ASSERT_FALSE(status.isOk()); EXPECT_EQ(status.exceptionCode(), Status::Exception::EX_BAD_PARCELABLE); } { BadParcelable not_bad(/*bad=*/false, "Booya", 42); Status status = cpp_java_tests->RepeatBadParcelable(not_bad, &output); ASSERT_TRUE(status.isOk()); EXPECT_EQ(not_bad, output); } } TEST_F(AidlTest, RepeatSimpleParcelable) { SimpleParcelable input("Booya", 42); SimpleParcelable out_param, returned; Status status = service->RepeatSimpleParcelable(input, &out_param, &returned); ASSERT_TRUE(status.isOk()) << status.toString8(); EXPECT_EQ(input, out_param) << input.toString() << " " << out_param.toString(); EXPECT_EQ(input, returned) << input.toString() << " " << returned.toString(); } TEST_F(AidlTest, RepeatGenericStructureParcelable) { if (!cpp_java_tests) GTEST_SKIP() << "Service does not support the CPP/Java-only tests."; GenericStructuredParcelable input, out_param, returned; input.a = 41; input.b = 42; Status status = cpp_java_tests->RepeatGenericParcelable(input, &out_param, &returned); ASSERT_TRUE(status.isOk()) << status.toString8(); EXPECT_EQ(input, out_param); EXPECT_EQ(input, returned); } TEST_F(AidlTest, ReverseSimpleParcelable) { const vector original{SimpleParcelable("first", 0), SimpleParcelable("second", 1), SimpleParcelable("third", 2)}; vector repeated; if (backend == BackendType::JAVA) { repeated = vector(original.size()); } vector reversed; Status status = service->ReverseSimpleParcelables(original, &repeated, &reversed); ASSERT_TRUE(status.isOk()) << status.toString8(); EXPECT_EQ(repeated, original); std::reverse(reversed.begin(), reversed.end()); EXPECT_EQ(reversed, original); } TEST_F(AidlTest, ConfirmPersistableBundles) { if (!cpp_java_tests) GTEST_SKIP() << "Service does not support the CPP/Java-only tests."; PersistableBundle empty_bundle, returned; Status status = cpp_java_tests->RepeatPersistableBundle(empty_bundle, &returned); ASSERT_TRUE(status.isOk()) << status.toString8(); EXPECT_EQ(empty_bundle, returned); } TEST_F(AidlTest, ConfirmPersistableBundlesNonEmpty) { if (!cpp_java_tests) GTEST_SKIP() << "Service does not support the CPP/Java-only tests."; PersistableBundle non_empty_bundle, returned; non_empty_bundle.putBoolean(String16("test_bool"), false); non_empty_bundle.putInt(String16("test_int"), 33); non_empty_bundle.putLong(String16("test_long"), 34359738368L); non_empty_bundle.putDouble(String16("test_double"), 1.1); non_empty_bundle.putString(String16("test_string"), String16("Woot!")); non_empty_bundle.putBooleanVector(String16("test_bool_vector"), {true, false, true}); non_empty_bundle.putIntVector(String16("test_int_vector"), {33, 44, 55, 142}); non_empty_bundle.putLongVector(String16("test_long_vector"), {34L, 8371L, 34359738375L}); non_empty_bundle.putDoubleVector(String16("test_double_vector"), {2.2, 5.4}); non_empty_bundle.putStringVector(String16("test_string_vector"), {String16("hello"), String16("world!")}); PersistableBundle nested_bundle; nested_bundle.putInt(String16("test_nested_int"), 345); non_empty_bundle.putPersistableBundle(String16("test_persistable_bundle"), nested_bundle); Status status = cpp_java_tests->RepeatPersistableBundle(non_empty_bundle, &returned); ASSERT_TRUE(status.isOk()) << status.toString8(); EXPECT_EQ(non_empty_bundle, returned); } TEST_F(AidlTest, ReversePersistableBundles) { if (!cpp_java_tests) GTEST_SKIP() << "Service does not support the CPP/Java-only tests."; PersistableBundle first; PersistableBundle second; PersistableBundle third; first.putInt(String16("test_int"), 1231); second.putLong(String16("test_long"), 222222L); third.putDouble(String16("test_double"), 10.8); const vector original{first, second, third}; vector repeated; if (backend == BackendType::JAVA) { repeated = vector(original.size()); } vector reversed; Status status = cpp_java_tests->ReversePersistableBundles(original, &repeated, &reversed); ASSERT_TRUE(status.isOk()) << status.toString8(); EXPECT_EQ(repeated, original); std::reverse(reversed.begin(), reversed.end()); EXPECT_EQ(reversed, original); } TEST_F(AidlTest, ReverseUnion) { if (!cpp_java_tests) GTEST_SKIP() << "Service does not support the CPP/Java-only tests."; Union original = Union::make({1, 2, 3}); Union repeated, reversed; Status status = cpp_java_tests->ReverseUnion(original, &repeated, &reversed); ASSERT_TRUE(status.isOk()) << status.toString8(); EXPECT_EQ(repeated, original); std::reverse(reversed.get().begin(), reversed.get().end()); EXPECT_EQ(reversed, original); } TEST_F(AidlTest, UnionUsage) { // default ctor inits with first member's default value EXPECT_EQ(Union::make(), Union()); // make(...) to create a value for a tag. Union one_two_three = Union::make({1, 2, 3}); // getTag() queries the tag of the content EXPECT_EQ(Union::ns, one_two_three.getTag()); // Ctor(...) works if a target tag has a unique type among fields. EXPECT_EQ(one_two_three, Union(std::vector{1, 2, 3})); EXPECT_EQ(one_two_three, std::vector({1, 2, 3})); // Use std::in_place_index to avoid "move" // Note that make(...) involves "move" of the content value EXPECT_EQ(Union::make(3, 0), Union(std::in_place_index(Union::ns)>, 3, 0)); Union one_two = one_two_three; // get can be used to modify the content one_two.get().pop_back(); EXPECT_EQ(one_two, std::vector({1, 2})); // get can be lvalue one_two.get() = std::vector{1, 2}; EXPECT_EQ(one_two, std::vector({1, 2})); // abort with a bad access EXPECT_DEATH(one_two.get(), "bad access"); // set(...) overwrites the content with a new tag one_two_three.set("123"); EXPECT_EQ(one_two_three, std::string("123")); // Or, you can simply assign a new value. // note that this works only if the target type is unique one_two_three = std::vector{"1", "2", "3"}; EXPECT_EQ(Union::ss, one_two_three.getTag()); } TEST_F(AidlTest, UnionDefaultConstructorInitializeWithFirstMember) { EXPECT_EQ(Union::make(), Union()); // int[] ns EXPECT_EQ(EnumUnion::make(IntEnum::FOO), EnumUnion()); // IntEnum intEnum = IntEnum.FOO } TEST_F(AidlTest, StructuredParcelableEquality) { // TODO: break up equality tests, these are hard to read, because you need to // keep the state of the parcelables in mind StructuredParcelable parcelable1; StructuredParcelable parcelable2; parcelable1.f = 11; parcelable2.f = 11; service->FillOutStructuredParcelable(&parcelable1); service->FillOutStructuredParcelable(&parcelable2); sp callback1; sp callback2; service->GetOtherTestService(String16("callback1"), &callback1); service->GetOtherTestService(String16("callback2"), &callback2); parcelable1.ibinder = IInterface::asBinder(callback1); parcelable2.ibinder = IInterface::asBinder(callback1); EXPECT_EQ(parcelable1, parcelable2); parcelable1.f = 0; EXPECT_LT(parcelable1, parcelable2); parcelable1.f = 11; parcelable1.shouldBeJerry = "Jarry"; EXPECT_LT(parcelable1, parcelable2); parcelable1.shouldBeJerry = "Jerry"; parcelable2.shouldContainThreeFs = {}; EXPECT_GT(parcelable1, parcelable2); parcelable2.shouldContainThreeFs = {parcelable2.f, parcelable2.f, parcelable2.f}; parcelable2.shouldBeIntBar = IntEnum::FOO; EXPECT_GT(parcelable1, parcelable2); parcelable2.shouldBeIntBar = IntEnum::BAR; parcelable2.ibinder = IInterface::asBinder(callback2); EXPECT_NE(parcelable1, parcelable2); } TEST_F(AidlTest, ConfirmStructuredParcelables) { constexpr int kDesiredValue = 23; StructuredParcelable parcelable; parcelable.f = kDesiredValue; EXPECT_EQ(parcelable.stringDefaultsToFoo, String16("foo")); EXPECT_EQ(parcelable.byteDefaultsToFour, 4); EXPECT_EQ(parcelable.intDefaultsToFive, 5); EXPECT_EQ(parcelable.longDefaultsToNegativeSeven, -7); EXPECT_EQ(parcelable.booleanDefaultsToTrue, true); EXPECT_EQ(parcelable.charDefaultsToC, 'C'); EXPECT_TRUE(parcelable.floatDefaultsToPi == 3.14f) << parcelable.floatDefaultsToPi; EXPECT_TRUE(parcelable.doubleWithDefault == -3.14e17) << parcelable.doubleWithDefault; EXPECT_EQ(parcelable.boolDefault, false); EXPECT_EQ(parcelable.byteDefault, 0); EXPECT_EQ(parcelable.intDefault, 0); EXPECT_EQ(parcelable.longDefault, 0); EXPECT_EQ(parcelable.floatDefault, 0.0f); EXPECT_EQ(parcelable.doubleDefault, 0.0); ASSERT_EQ(parcelable.arrayDefaultsTo123.size(), 3u); EXPECT_EQ(parcelable.arrayDefaultsTo123[0], 1); EXPECT_EQ(parcelable.arrayDefaultsTo123[1], 2); EXPECT_EQ(parcelable.arrayDefaultsTo123[2], 3); EXPECT_TRUE(parcelable.arrayDefaultsToEmpty.empty()); EXPECT_EQ(parcelable.defaultWithFoo, IntEnum::FOO); service->FillOutStructuredParcelable(&parcelable); ASSERT_EQ(parcelable.shouldContainThreeFs.size(), 3u); EXPECT_EQ(parcelable.shouldContainThreeFs[0], kDesiredValue); EXPECT_EQ(parcelable.shouldContainThreeFs[1], kDesiredValue); EXPECT_EQ(parcelable.shouldContainThreeFs[2], kDesiredValue); EXPECT_EQ(parcelable.shouldBeJerry, "Jerry"); EXPECT_EQ(parcelable.int32_min, INT32_MIN); EXPECT_EQ(parcelable.int32_max, INT32_MAX); EXPECT_EQ(parcelable.int64_max, INT64_MAX); EXPECT_EQ(parcelable.hexInt32_neg_1, -1); for (size_t ndx = 0; ndx < parcelable.int8_1.size(); ndx++) { EXPECT_EQ(parcelable.int8_1[ndx], 1) << ndx; } for (size_t ndx = 0; ndx < parcelable.int32_1.size(); ndx++) { EXPECT_EQ(parcelable.int32_1[ndx], 1) << ndx; } for (size_t ndx = 0; ndx < parcelable.int64_1.size(); ndx++) { EXPECT_EQ(parcelable.int64_1[ndx], 1) << ndx; } EXPECT_EQ(parcelable.hexInt32_pos_1, 1); EXPECT_EQ(parcelable.hexInt64_pos_1, 1); EXPECT_EQ(static_cast(parcelable.const_exprs_1), 1); EXPECT_EQ(static_cast(parcelable.const_exprs_2), 1); EXPECT_EQ(static_cast(parcelable.const_exprs_3), 1); EXPECT_EQ(static_cast(parcelable.const_exprs_4), 1); EXPECT_EQ(static_cast(parcelable.const_exprs_5), 1); EXPECT_EQ(static_cast(parcelable.const_exprs_6), 1); EXPECT_EQ(static_cast(parcelable.const_exprs_7), 1); EXPECT_EQ(static_cast(parcelable.const_exprs_8), 1); EXPECT_EQ(static_cast(parcelable.const_exprs_9), 1); EXPECT_EQ(static_cast(parcelable.const_exprs_10), 1); EXPECT_EQ(parcelable.addString1, "hello world!"); EXPECT_EQ(parcelable.addString2, "The quick brown fox jumps over the lazy dog."); EXPECT_EQ(StructuredParcelable::BIT0 | StructuredParcelable::BIT2, parcelable.shouldSetBit0AndBit2); EXPECT_EQ(parcelable.u->get(), vector({1, 2, 3})); EXPECT_EQ(parcelable.shouldBeConstS1->get(), Union::S1()); } TEST_F(AidlTest, EmptyParcelableHolder) { using namespace android::aidl::tests::extension; android::Parcel parcel; { ExtendableParcelable ep; ep.writeToParcel(&parcel); std::shared_ptr emptyExt; ep.ext.getParcelable(&emptyExt); EXPECT_FALSE(emptyExt); } { parcel.setDataPosition(0); ExtendableParcelable ep; ep.readFromParcel(&parcel); std::shared_ptr emptyExt; ep.ext.getParcelable(&emptyExt); EXPECT_FALSE(emptyExt); } } TEST_F(AidlTest, ParcelableHolderEqualityOperator) { auto ph1 = android::os::ParcelableHolder(android::Parcelable::Stability::STABILITY_LOCAL); auto ph2 = android::os::ParcelableHolder(android::Parcelable::Stability::STABILITY_LOCAL); auto ph3 = android::os::ParcelableHolder(android::Parcelable::Stability::STABILITY_LOCAL); auto ptr1 = std::make_shared(); auto ptr2 = std::make_shared(); ptr1->a = 1; ptr1->b = "a"; ptr2->a = 1; ptr2->b = "a"; ph1.setParcelable(ptr1); ph2.setParcelable(ptr1); ph3.setParcelable(ptr2); // ParcelableHolder always uses its address as a comparison criterion. EXPECT_TRUE(ph1 != ph2); EXPECT_TRUE(ph2 != ph3); EXPECT_TRUE(ph1 == ph1); EXPECT_TRUE(ph2 == ph2); EXPECT_TRUE(ph3 == ph3); android::Parcel parcel; ph1.writeToParcel(&parcel); ph2.writeToParcel(&parcel); ph3.writeToParcel(&parcel); parcel.setDataPosition(0); ph1.readFromParcel(&parcel); ph2.readFromParcel(&parcel); ph3.readFromParcel(&parcel); // ParcelableHolder always uses its address as a comparison criterion. EXPECT_TRUE(ph1 != ph2); EXPECT_TRUE(ph2 != ph3); EXPECT_TRUE(ph1 == ph1); EXPECT_TRUE(ph2 == ph2); EXPECT_TRUE(ph3 == ph3); } TEST_F(AidlTest, NativeExtednableParcelable) { using namespace android::aidl::tests::extension; MyExt ext; ext.a = 42; ext.b = "EXT"; MyExt2 ext2; ext2.a = 42; ext2.b.a = 24; ext2.b.b = "INEXT"; ext2.c = "EXT2"; android::Parcel parcel; { ExtendableParcelable ep; ep.a = 1; ep.b = "a"; ep.c = 42L; EXPECT_TRUE(ep.ext.setParcelable(ext) == android::OK); EXPECT_TRUE(ep.ext2.setParcelable(ext2) == android::OK); std::shared_ptr extLike; ep.ext.getParcelable(&extLike); EXPECT_FALSE(extLike) << "The extension type must be MyExt, so it has to fail even though " "MyExtLike has the same structure as MyExt."; std::shared_ptr actualExt; ep.ext.getParcelable(&actualExt); std::shared_ptr actualExt2; ep.ext2.getParcelable(&actualExt2); EXPECT_TRUE(actualExt); EXPECT_TRUE(actualExt2); EXPECT_EQ(ext, *actualExt); EXPECT_EQ(ext2, *actualExt2); ep.writeToParcel(&parcel); } parcel.setDataPosition(0); { ExtendableParcelable ep; ep.readFromParcel(&parcel); std::shared_ptr extLike; ep.ext.getParcelable(&extLike); EXPECT_FALSE(extLike) << "The extension type must be MyExt, so it has to fail even though " "MyExtLike has the same structure as MyExt."; std::shared_ptr actualExt; ep.ext.getParcelable(&actualExt); std::shared_ptr actualExt2; ep.ext2.getParcelable(&actualExt2); std::shared_ptr emptyExt; ep.ext2.getParcelable(&emptyExt); EXPECT_FALSE(emptyExt); EXPECT_TRUE(actualExt); EXPECT_TRUE(actualExt2); EXPECT_EQ(ext, *actualExt); EXPECT_EQ(ext2, *actualExt2); } } TEST_F(AidlTest, ParcelableToString) { ParcelableForToString p; p.intValue = 10; p.intArray = {20, 30}; p.longValue = 100L; p.longArray = {200L, 300L}; p.doubleValue = 3.14; p.doubleArray = {1.1, 1.2}; p.floatValue = 3.14f; p.floatArray = {1.1f, 1.2f}; p.byteValue = 3; p.byteArray = {5, 6}; p.booleanValue = true; p.booleanArray = {true, false}; p.stringValue = String16("this is a string"); p.stringArray = {String16("hello"), String16("world")}; p.stringList = {String16("alice"), String16("bob")}; OtherParcelableForToString op; op.field = String16("other"); p.parcelableValue = op; p.parcelableArray = {op, op}; p.enumValue = IntEnum::FOO; p.enumArray = {IntEnum::FOO, IntEnum::BAR}; // p.nullArray = null; // p.nullList = null; GenericStructuredParcelable gen; gen.a = 1; gen.b = 2; p.parcelableGeneric = gen; p.unionValue = Union(std::vector{"union", "value"}); const string expected = "ParcelableForToString{" "intValue: 10, " "intArray: [20, 30], " "longValue: 100, " "longArray: [200, 300], " "doubleValue: 3.140000, " "doubleArray: [1.100000, 1.200000], " "floatValue: 3.140000, " "floatArray: [1.100000, 1.200000], " "byteValue: 3, " "byteArray: [5, 6], " "booleanValue: true, " "booleanArray: [true, false], " "stringValue: this is a string, " "stringArray: [hello, world], " "stringList: [alice, bob], " "parcelableValue: OtherParcelableForToString{field: other}, " "parcelableArray: [" "OtherParcelableForToString{field: other}, " "OtherParcelableForToString{field: other}], " "enumValue: FOO, " "enumArray: [FOO, BAR], " "nullArray: [], " "nullList: [], " "parcelableGeneric: GenericStructuredParcelable{a: 1, b: 2}, " "unionValue: Union{ss: [union, value]}" "}"; EXPECT_EQ(expected, p.toString()); } TEST_F(AidlTest, ReverseRecursiveList) { std::unique_ptr head; for (int i = 0; i < 10; i++) { auto node = std::make_unique(); node->value = i; node->next = std::move(head); head = std::move(node); } // head: [9, 8, ... 0] RecursiveList reversed; auto status = service->ReverseList(*head, &reversed); ASSERT_TRUE(status.isOk()) << status.toString8(); // reversed should be [0, 1, .. 9] RecursiveList* cur = &reversed; for (int i = 0; i < 10; i++) { EXPECT_EQ(i, cur->value); cur = cur->next.get(); } EXPECT_EQ(nullptr, cur); } TEST_F(AidlTest, GetUnionTags) { std::vector unions; std::vector tags; // test empty auto status = service->GetUnionTags(unions, &tags); ASSERT_TRUE(status.isOk()) << status.toString8(); EXPECT_EQ(tags, (std::vector{})); // test non-empty unions.push_back(Union::make()); unions.push_back(Union::make()); status = service->GetUnionTags(unions, &tags); ASSERT_TRUE(status.isOk()) << status.toString8(); EXPECT_EQ(tags, (std::vector{Union::n, Union::ns})); } TEST_F(AidlTest, FixedSizeArray) { android::Parcel parcel; FixedSizeArrayExample p; p.byteMatrix[0][0] = 0; p.byteMatrix[0][1] = 1; p.byteMatrix[1][0] = 2; p.byteMatrix[1][1] = 3; p.floatMatrix[0][0] = 0.f; p.floatMatrix[0][1] = 1.f; p.floatMatrix[1][0] = 2.f; p.floatMatrix[1][1] = 3.f; EXPECT_EQ(OK, p.writeToParcel(&parcel)); parcel.setDataPosition(0); FixedSizeArrayExample q; EXPECT_EQ(OK, q.readFromParcel(&parcel)); EXPECT_EQ(p, q); } TEST_F(AidlTest, FixedSizeArrayWithValuesAtNullableFields) { android::Parcel parcel; FixedSizeArrayExample p; p.boolNullableArray = std::array{true, false}; p.byteNullableArray = std::array{42, 0}; p.stringNullableArray = std::array, 2>{"hello", "world"}; p.boolNullableMatrix.emplace(); p.boolNullableMatrix->at(0) = std::array{true, false}; p.byteNullableMatrix.emplace(); p.byteNullableMatrix->at(0) = std::array{42, 0}; p.stringNullableMatrix.emplace(); p.stringNullableMatrix->at(0) = std::array, 2>{"hello", "world"}; EXPECT_EQ(OK, p.writeToParcel(&parcel)); parcel.setDataPosition(0); FixedSizeArrayExample q; EXPECT_EQ(OK, q.readFromParcel(&parcel)); EXPECT_EQ(p, q); } TEST_F(AidlTest, FixedSizeArrayOfBytesShouldBePacked) { android::Parcel parcel; std::array, 2> byte_array; byte_array[0] = {1, 2, 3}; byte_array[1] = {4, 5, 6}; EXPECT_EQ(OK, parcel.writeFixedArray(byte_array)); parcel.setDataPosition(0); int32_t len; EXPECT_EQ(OK, parcel.readInt32(&len)); EXPECT_EQ(2, len); std::vector byte_vector; EXPECT_EQ(OK, parcel.readByteVector(&byte_vector)); EXPECT_EQ(byte_vector, (std::vector{1, 2, 3})); EXPECT_EQ(OK, parcel.readByteVector(&byte_vector)); EXPECT_EQ(byte_vector, (std::vector{4, 5, 6})); } template void CheckRepeat(Service service, MemFn fn, Input input) { Input out1, out2; EXPECT_TRUE(std::invoke(fn, service, input, &out1, &out2).isOk()); EXPECT_EQ(input, out1); EXPECT_EQ(input, out2); } template std::array, 2> Make2dArray(std::initializer_list values) { std::array, 2> arr = {}; auto it = std::begin(values); for (auto& row : arr) { for (auto& el : row) { if (it == std::end(values)) break; el = *it++; } } return arr; } TEST_F(AidlTest, FixedSizeArrayOverBinder) { sp service = android::waitForService(IRepeatFixedSizeArray::descriptor); ASSERT_NE(service, nullptr); CheckRepeat(service, &IRepeatFixedSizeArray::RepeatBytes, (std::array{1, 2, 3})); CheckRepeat(service, &IRepeatFixedSizeArray::RepeatInts, (std::array{1, 2, 3})); sp binder1 = new BBinder(); sp binder2 = new BBinder(); sp binder3 = new BBinder(); CheckRepeat(service, &IRepeatFixedSizeArray::RepeatBinders, (std::array, 3>{binder1, binder2, binder3})); IntParcelable p1, p2, p3; p1.value = 1; p2.value = 2; p3.value = 3; CheckRepeat(service, &IRepeatFixedSizeArray::RepeatParcelables, (std::array{p1, p2, p3})); CheckRepeat(service, &IRepeatFixedSizeArray::Repeat2dBytes, Make2dArray({1, 2, 3})); CheckRepeat(service, &IRepeatFixedSizeArray::Repeat2dInts, Make2dArray({1, 2, 3})); // Not-nullable CheckRepeat(service, &IRepeatFixedSizeArray::Repeat2dBinders, Make2dArray>({binder1, binder2, binder3, binder1, binder2, binder3})); CheckRepeat(service, &IRepeatFixedSizeArray::Repeat2dParcelables, Make2dArray({p1, p2, p3})); } ./PaxHeaders.X/tests_aidl_test_client_primitives.cpp0100644 0000000 0000000 00000000034 15172120304 022003 xustar000000000 0000000 28 mtime=1776853188.3680000 tests/aidl_test_client_primitives.cpp0100644 0000000 0000000 00000030474 15172120304 017237 0ustar000000000 0000000 /* * Copyright (C) 2015 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 #include #include #include "android/aidl/tests/ByteEnum.h" #include "android/aidl/tests/INamedCallback.h" #include "android/aidl/tests/IntEnum.h" #include "android/aidl/tests/LongEnum.h" #include "aidl_test_client.h" #include "gmock/gmock.h" using android::IBinder; using android::sp; using android::String16; using android::String8; using android::binder::Status; // generated using android::aidl::tests::ByteEnum; using android::aidl::tests::INamedCallback; using android::aidl::tests::IntEnum; using android::aidl::tests::ITestService; using android::aidl::tests::LongEnum; using testing::Eq; struct AidlPrimitiveTest : public AidlTest { template void DoTest(Status (ITestService::*func)(T, U*), V input) { U repeated; auto status = (*service.*func)(input, &repeated); ASSERT_TRUE(status.isOk()) << status; ASSERT_THAT(repeated, Eq(input)); } template void DoTest(Status (ITestService::*func)(const std::vector&, std::vector*, std::vector*), const std::vector& input) { // must be preallocated for Java servers std::vector repeated(input.size()); std::vector reversed; auto status = (*service.*func)(input, &repeated, &reversed); ASSERT_TRUE(status.isOk()) << status; ASSERT_THAT(repeated, Eq(input)); std::vector reversed_input(input); std::reverse(reversed_input.begin(), reversed_input.end()); ASSERT_THAT(reversed, Eq(reversed_input)); } }; TEST_F(AidlPrimitiveTest, aBoolean) { DoTest(&ITestService::RepeatBoolean, true); } TEST_F(AidlPrimitiveTest, aByte) { DoTest(&ITestService::RepeatByte, int8_t{-128}); } TEST_F(AidlPrimitiveTest, aChar) { DoTest(&ITestService::RepeatChar, char16_t{'A'}); } TEST_F(AidlPrimitiveTest, aInt) { DoTest(&ITestService::RepeatInt, int32_t{1 << 30}); } TEST_F(AidlPrimitiveTest, aLong) { DoTest(&ITestService::RepeatLong, int64_t{1LL << 60}); } TEST_F(AidlPrimitiveTest, aFloat) { DoTest(&ITestService::RepeatFloat, float{1.0f / 3.0f}); } TEST_F(AidlPrimitiveTest, aDouble) { DoTest(&ITestService::RepeatDouble, double{1.0 / 3.0}); } TEST_F(AidlPrimitiveTest, byteConstants) { constexpr int8_t consts[] = {ITestService::BYTE_CONSTANT}; for (auto sent : consts) { DoTest(&ITestService::RepeatByte, sent); } } TEST_F(AidlPrimitiveTest, intConstants) { constexpr int32_t consts[] = { ITestService::CONSTANT, ITestService::CONSTANT2, ITestService::CONSTANT3, ITestService::CONSTANT4, ITestService::CONSTANT5, ITestService::CONSTANT6, ITestService::CONSTANT7, ITestService::CONSTANT8, ITestService::CONSTANT9, ITestService::CONSTANT10, ITestService::CONSTANT11, ITestService::CONSTANT12}; for (auto sent : consts) { DoTest(&ITestService::RepeatInt, sent); } } TEST_F(AidlPrimitiveTest, longConstants) { constexpr int64_t consts[] = {ITestService::LONG_CONSTANT}; for (auto sent : consts) { DoTest(&ITestService::RepeatLong, sent); } } TEST_F(AidlPrimitiveTest, floatConstants) { constexpr float consts[] = { ITestService::FLOAT_CONSTANT, ITestService::FLOAT_CONSTANT2, ITestService::FLOAT_CONSTANT3, ITestService::FLOAT_CONSTANT4, ITestService::FLOAT_CONSTANT5, ITestService::FLOAT_CONSTANT6, ITestService::FLOAT_CONSTANT7, }; for (auto sent : consts) { DoTest(&ITestService::RepeatFloat, sent); } } TEST_F(AidlPrimitiveTest, doubleConstants) { constexpr double consts[] = { ITestService::DOUBLE_CONSTANT, ITestService::DOUBLE_CONSTANT2, ITestService::DOUBLE_CONSTANT3, ITestService::DOUBLE_CONSTANT4, ITestService::DOUBLE_CONSTANT5, ITestService::DOUBLE_CONSTANT6, ITestService::DOUBLE_CONSTANT7, ITestService::DOUBLE_CONSTANT8, ITestService::DOUBLE_CONSTANT9, }; for (auto sent : consts) { DoTest(&ITestService::RepeatDouble, sent); } } TEST_F(AidlPrimitiveTest, strings) { std::vector strings = { String16("Deliver us from evil."), String16(), String16("\0\0", 2), // This is actually two unicode code points: // U+10437: The 'small letter yee' character in the deseret alphabet // U+20AC: A euro sign String16("\xD8\x01\xDC\x37\x20\xAC"), ITestService::STRING_CONSTANT(), ITestService::STRING_CONSTANT2()}; for (auto sent : strings) { DoTest(&ITestService::RepeatString, sent); } } TEST_F(AidlPrimitiveTest, booleanArray) { DoTest(&ITestService::ReverseBoolean, {true, false, false}); } TEST_F(AidlPrimitiveTest, byteArrvay) { DoTest(&ITestService::ReverseByte, {uint8_t{255}, uint8_t{0}, uint8_t{127}}); } TEST_F(AidlPrimitiveTest, charArray) { DoTest(&ITestService::ReverseChar, {char16_t{'A'}, char16_t{'B'}, char16_t{'C'}}); } TEST_F(AidlPrimitiveTest, intArray) { DoTest(&ITestService::ReverseInt, {1, 2, 3}); } TEST_F(AidlPrimitiveTest, longArrayr) { DoTest(&ITestService::ReverseLong, {-1LL, 0LL, int64_t{1LL << 60}}); } TEST_F(AidlPrimitiveTest, floatArrays) { DoTest(&ITestService::ReverseFloat, {-0.3f, -0.7f, 8.0f}); } TEST_F(AidlPrimitiveTest, doubleArray) { DoTest(&ITestService::ReverseDouble, {1.0 / 3.0, 1.0 / 7.0, 42.0}); } TEST_F(AidlPrimitiveTest, stringArray) { DoTest(&ITestService::ReverseString, {String16{"f"}, String16{"a"}, String16{"b"}}); } TEST_F(AidlPrimitiveTest, byteEnumArray) { DoTest(&ITestService::ReverseByteEnum, {ByteEnum::FOO, ByteEnum::BAR, ByteEnum::BAR}); } TEST_F(AidlPrimitiveTest, byteEnumArray2) { DoTest(&ITestService::ReverseByteEnum, {std::begin(::android::enum_range()), std::end(::android::enum_range())}); } TEST_F(AidlPrimitiveTest, intEnumArray) { DoTest(&ITestService::ReverseIntEnum, {IntEnum::FOO, IntEnum::BAR, IntEnum::BAR}); } TEST_F(AidlPrimitiveTest, longEnumArray) { DoTest(&ITestService::ReverseLongEnum, {LongEnum::FOO, LongEnum::BAR, LongEnum::BAR}); } TEST_F(AidlPrimitiveTest, stringList) { DoTest(&ITestService::ReverseStringList, {String16{"f"}, String16{"a"}, String16{"b"}}); } TEST_F(AidlPrimitiveTest, binderArray) { std::vector names = {String16{"Larry"}, String16{"Curly"}, String16{"Moe"}}; std::vector> input; for (int i = 0; i < 3; i++) { sp got; auto status = service->GetOtherTestService(names[i], &got); ASSERT_TRUE(status.isOk()); input.push_back(INamedCallback::asBinder(got)); } { std::vector> got; auto status = service->GetInterfaceArray(names, &got); ASSERT_TRUE(status.isOk()); bool verified = false; status = service->VerifyNamesWithInterfaceArray(got, names, &verified); ASSERT_TRUE(status.isOk()); ASSERT_TRUE(verified); for (int i = 0; i < 3; i++) { String16 name; ASSERT_TRUE(got[i]->GetName(&name).isOk()); ASSERT_THAT(name, Eq(names[i])); } } { std::vector> names = {String16{"Larry"}, std::nullopt, String16{"Moe"}}; std::optional>> got; auto status = service->GetNullableInterfaceArray(names, &got); ASSERT_TRUE(status.isOk()); bool verified = false; status = service->VerifyNamesWithNullableInterfaceArray(got, names, &verified); ASSERT_TRUE(status.isOk()); ASSERT_TRUE(verified); ASSERT_TRUE(got.has_value()); for (int i = 0; i < 3; i++) { if (names[i].has_value()) { ASSERT_NE(got->at(i).get(), nullptr); String16 name; ASSERT_TRUE(got->at(i)->GetName(&name).isOk()); ASSERT_THAT(name, Eq(names[i].value())); } else { ASSERT_EQ(got->at(i).get(), nullptr); } } } { std::vector> names = {String16{"Larry"}, std::nullopt, String16{"Moe"}}; std::optional>> got; auto status = service->GetInterfaceList(names, &got); ASSERT_TRUE(status.isOk()); bool verified = false; status = service->VerifyNamesWithInterfaceList(got, names, &verified); ASSERT_TRUE(status.isOk()); ASSERT_TRUE(verified); ASSERT_TRUE(got.has_value()); for (int i = 0; i < 3; i++) { if (names[i].has_value()) { ASSERT_NE(got->at(i).get(), nullptr); String16 name; ASSERT_TRUE(got->at(i)->GetName(&name).isOk()); ASSERT_THAT(name, Eq(names[i].value())); } else { ASSERT_EQ(got->at(i).get(), nullptr); } } } if (cpp_java_tests) { std::vector> output; std::vector> reversed; auto status = cpp_java_tests->ReverseNamedCallbackList(input, &output, &reversed); ASSERT_TRUE(status.isOk()); ASSERT_THAT(output.size(), Eq(3u)); ASSERT_THAT(reversed.size(), Eq(3u)); for (int i = 0; i < 3; i++) { String16 ret; sp named_callback = android::interface_cast(output[i]); auto status = named_callback->GetName(&ret); ASSERT_TRUE(status.isOk()); ASSERT_THAT(ret, Eq(names[i])); } for (int i = 0; i < 3; i++) { String16 ret; sp named_callback = android::interface_cast(reversed[i]); auto status = named_callback->GetName(&ret); ASSERT_TRUE(status.isOk()); ASSERT_THAT(ret, Eq(names[2 - i])); } } } TEST_F(AidlPrimitiveTest, constantExpressions) { EXPECT_THAT(ITestService::A1, Eq(1)); EXPECT_THAT(ITestService::A2, Eq(1)); EXPECT_THAT(ITestService::A3, Eq(1)); EXPECT_THAT(ITestService::A4, Eq(1)); EXPECT_THAT(ITestService::A5, Eq(1)); EXPECT_THAT(ITestService::A6, Eq(1)); EXPECT_THAT(ITestService::A7, Eq(1)); EXPECT_THAT(ITestService::A8, Eq(1)); EXPECT_THAT(ITestService::A9, Eq(1)); EXPECT_THAT(ITestService::A10, Eq(1)); EXPECT_THAT(ITestService::A11, Eq(1)); EXPECT_THAT(ITestService::A12, Eq(1)); EXPECT_THAT(ITestService::A13, Eq(1)); EXPECT_THAT(ITestService::A14, Eq(1)); EXPECT_THAT(ITestService::A15, Eq(1)); EXPECT_THAT(ITestService::A16, Eq(1)); EXPECT_THAT(ITestService::A17, Eq(1)); EXPECT_THAT(ITestService::A18, Eq(1)); EXPECT_THAT(ITestService::A19, Eq(1)); EXPECT_THAT(ITestService::A20, Eq(1)); EXPECT_THAT(ITestService::A21, Eq(1)); EXPECT_THAT(ITestService::A22, Eq(1)); EXPECT_THAT(ITestService::A23, Eq(1)); EXPECT_THAT(ITestService::A24, Eq(1)); EXPECT_THAT(ITestService::A25, Eq(1)); EXPECT_THAT(ITestService::A26, Eq(1)); EXPECT_THAT(ITestService::A27, Eq(1)); EXPECT_THAT(ITestService::A28, Eq(1)); EXPECT_THAT(ITestService::A29, Eq(1)); EXPECT_THAT(ITestService::A30, Eq(1)); EXPECT_THAT(ITestService::A31, Eq(1)); EXPECT_THAT(ITestService::A32, Eq(1)); EXPECT_THAT(ITestService::A33, Eq(1)); EXPECT_THAT(ITestService::A34, Eq(1)); EXPECT_THAT(ITestService::A35, Eq(1)); EXPECT_THAT(ITestService::A36, Eq(1)); EXPECT_THAT(ITestService::A37, Eq(1)); EXPECT_THAT(ITestService::A38, Eq(1)); EXPECT_THAT(ITestService::A39, Eq(1)); EXPECT_THAT(ITestService::A40, Eq(1)); EXPECT_THAT(ITestService::A41, Eq(1)); EXPECT_THAT(ITestService::A42, Eq(1)); EXPECT_THAT(ITestService::A43, Eq(1)); EXPECT_THAT(ITestService::A44, Eq(1)); EXPECT_THAT(ITestService::A45, Eq(1)); EXPECT_THAT(ITestService::A46, Eq(1)); EXPECT_THAT(ITestService::A47, Eq(1)); EXPECT_THAT(ITestService::A48, Eq(1)); EXPECT_THAT(ITestService::A49, Eq(1)); EXPECT_THAT(ITestService::A50, Eq(1)); EXPECT_THAT(ITestService::A51, Eq(1)); EXPECT_THAT(ITestService::A52, Eq(1)); EXPECT_THAT(ITestService::A53, Eq(1)); EXPECT_THAT(ITestService::A54, Eq(1)); EXPECT_THAT(ITestService::A55, Eq(1)); EXPECT_THAT(ITestService::A56, Eq(1)); EXPECT_THAT(ITestService::A57, Eq(1)); EXPECT_THAT(ITestService::FLOAT_CONSTANT4, Eq(2.2f)); EXPECT_THAT(ITestService::FLOAT_CONSTANT5, Eq(-2.2f)); EXPECT_THAT(ITestService::DOUBLE_CONSTANT4, Eq(2.2)); EXPECT_THAT(ITestService::DOUBLE_CONSTANT5, Eq(-2.2)); } ./PaxHeaders.X/tests_aidl_test_client_renamed_interface.cpp0100644 0000000 0000000 00000000034 15172120304 023243 xustar000000000 0000000 28 mtime=1776853188.3680000 tests/aidl_test_client_renamed_interface.cpp0100644 0000000 0000000 00000004512 15172120304 020471 0ustar000000000 0000000 /* * 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 "aidl_test_client.h" #include "gmock/gmock.h" #include #include using android::IInterface; using android::String16; using android::aidl::tests::INewName; using android::aidl::tests::IOldName; using testing::Eq; class RenamedInterfaceTest : public AidlTest { public: void SetUp() override { AidlTest::SetUp(); ASSERT_TRUE(service->GetOldNameInterface(&oldName).isOk()); ASSERT_TRUE(service->GetNewNameInterface(&newName).isOk()); } sp oldName; sp newName; }; TEST_F(RenamedInterfaceTest, oldAsOld) { ASSERT_THAT(String16("android.aidl.tests.IOldName"), oldName->getInterfaceDescriptor()); String16 realName; ASSERT_TRUE(oldName->RealName(&realName).isOk()); ASSERT_THAT(String16("OldName"), realName); } TEST_F(RenamedInterfaceTest, newAsNew) { ASSERT_THAT(String16("android.aidl.tests.IOldName"), newName->getInterfaceDescriptor()); String16 realName; ASSERT_TRUE(newName->RealName(&realName).isOk()); ASSERT_THAT(String16("NewName"), realName); } TEST_F(RenamedInterfaceTest, oldAsNew) { sp oldAsNew = INewName::asInterface(IInterface::asBinder(oldName)); ASSERT_THAT(String16("android.aidl.tests.IOldName"), oldAsNew->getInterfaceDescriptor()); String16 realName; ASSERT_TRUE(oldAsNew->RealName(&realName).isOk()); ASSERT_THAT(String16("OldName"), realName); } TEST_F(RenamedInterfaceTest, newAsOld) { sp newAsOld = IOldName::asInterface(IInterface::asBinder(newName)); ASSERT_THAT(String16("android.aidl.tests.IOldName"), newAsOld->getInterfaceDescriptor()); String16 realName; ASSERT_TRUE(newAsOld->RealName(&realName).isOk()); ASSERT_THAT(String16("NewName"), realName); } ./PaxHeaders.X/tests_aidl_test_client_service_exceptions.cpp0100644 0000000 0000000 00000000034 15172120304 023511 xustar000000000 0000000 28 mtime=1776853188.3700000 tests/aidl_test_client_service_exceptions.cpp0100644 0000000 0000000 00000002271 15172120304 020737 0ustar000000000 0000000 /* * Copyright (C) 2015 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_test_client.h" #include "gmock/gmock.h" TEST_F(AidlTest, onewayNoError) { // oneway servers try to return an error auto status = service->TestOneway(); EXPECT_TRUE(status.isOk()) << status; } TEST_F(AidlTest, serviceSpecificException) { using testing::Eq; for (int32_t i = -1; i < 2; ++i) { auto status = service->ThrowServiceException(i); EXPECT_THAT(status.exceptionCode(), Eq(android::binder::Status::EX_SERVICE_SPECIFIC)) << status << " for " << i; EXPECT_THAT(status.serviceSpecificErrorCode(), Eq(i)) << status << " for " << i; } } ./PaxHeaders.X/tests_aidl_test_client_trunk_stable.cpp0100644 0000000 0000000 00000000034 15172120304 022305 xustar000000000 0000000 28 mtime=1776853188.3700000 tests/aidl_test_client_trunk_stable.cpp0100644 0000000 0000000 00000016137 15172120304 017541 0ustar000000000 0000000 /* * Copyright (C) 2023 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 #include #include #include #include #include #include "aidl_test_client.h" #ifdef AIDL_USE_UNFROZEN constexpr bool kUseUnfrozen = true; #else constexpr bool kUseUnfrozen = false; #endif using android::OK; using android::sp; using android::String16; using android::aidl::test::trunk::ITrunkStableTest; using android::binder::Status; using MyParcelable = android::aidl::test::trunk::ITrunkStableTest::MyParcelable; #ifdef AIDL_USE_V2_INTERFACE using MyOtherParcelable = android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable; #endif // AIDL_USE_V2_INTERFACE using MyEnum = android::aidl::test::trunk::ITrunkStableTest::MyEnum; using MyUnion = android::aidl::test::trunk::ITrunkStableTest::MyUnion; class TrunkInterfaceTest : public AidlTest { public: void SetUp() override { android::ProcessState::self()->setThreadPoolMaxThreadCount(1); android::ProcessState::self()->startThreadPool(); service = android::waitForService(ITrunkStableTest::descriptor); ASSERT_NE(nullptr, service); AidlTest::SetUp(); } sp service; }; TEST_F(TrunkInterfaceTest, getInterfaceVersion) { // TODO(b/292539129) this should be done with an annotation instead of ifdefs // We have to match on a single char with #if, even though it is // really "enabled"/"disabled" if (kUseUnfrozen) { EXPECT_EQ(2, service->getInterfaceVersion()); // Check the local version as well #ifdef AIDL_USE_V2_INTERFACE EXPECT_EQ(2, ITrunkStableTest::VERSION); #else // linked against V1 explicitly EXPECT_EQ(1, ITrunkStableTest::VERSION); #endif } else { EXPECT_EQ(1, service->getInterfaceVersion()); // Check the local version as well EXPECT_EQ(1, ITrunkStableTest::VERSION); } } TEST_F(TrunkInterfaceTest, getInterfaceHash) { if (kUseUnfrozen) { EXPECT_EQ("notfrozen", service->getInterfaceHash()); // Check the local hash as well #ifdef AIDL_USE_V2_INTERFACE EXPECT_EQ("notfrozen", ITrunkStableTest::HASH); #else // linked against V1 explicitly EXPECT_EQ("88311b9118fb6fe9eff4a2ca19121de0587f6d5f", ITrunkStableTest::HASH); #endif } else { EXPECT_EQ("88311b9118fb6fe9eff4a2ca19121de0587f6d5f", service->getInterfaceHash()); // Check the local hash as well EXPECT_EQ("88311b9118fb6fe9eff4a2ca19121de0587f6d5f", ITrunkStableTest::HASH); } } // `c` is a new field that isn't read from the reply parcel TEST_F(TrunkInterfaceTest, repeatParcelable) { MyParcelable in, out; in.a = 14; in.b = 15; #ifdef AIDL_USE_V2_INTERFACE in.c = 16; #endif // AIDL_USE_V2_INTERFACE auto status = service->repeatParcelable(in, &out); ASSERT_TRUE(status.isOk()) << status; if (kUseUnfrozen) { EXPECT_EQ(in.a, out.a); EXPECT_EQ(in.b, out.b); #ifdef AIDL_USE_V2_INTERFACE EXPECT_EQ(in.c, out.c); #endif // AIDL_USE_V2_INTERFACE } else { EXPECT_EQ(in.a, out.a); EXPECT_EQ(in.b, out.b); #ifdef AIDL_USE_V2_INTERFACE EXPECT_NE(in.c, out.c); EXPECT_EQ(0, out.c); #endif // AIDL_USE_V2_INTERFACE } } #ifdef AIDL_USE_V2_INTERFACE // repeatOtherParcelable is a new API that isn't implemented TEST_F(TrunkInterfaceTest, repeatOtherParcelable) { MyOtherParcelable in, out; in.a = 14; in.b = 15; auto status = service->repeatOtherParcelable(in, &out); if (kUseUnfrozen) { ASSERT_TRUE(status.isOk()) << status; EXPECT_EQ(in.a, out.a); EXPECT_EQ(in.b, out.b); } else { EXPECT_FALSE(status.isOk()) << status; EXPECT_EQ(::android::UNKNOWN_TRANSACTION, status.transactionError()) << status; } } #endif // AIDL_USE_V2_INTERFACE // enums aren't handled differently. TEST_F(TrunkInterfaceTest, repeatEnum) { MyEnum in = MyEnum::TWO; MyEnum out = MyEnum::ZERO; auto status = service->repeatEnum(in, &out); ASSERT_TRUE(status.isOk()) << status; EXPECT_EQ(in, out); } // `c` is a new field that causes a failure if used // `b` is from V1 and will cause no failure TEST_F(TrunkInterfaceTest, repeatUnion) { MyUnion in_ok = MyUnion::make(13); ; #ifdef AIDL_USE_V2_INTERFACE MyUnion in_test = MyUnion::make(12); ; #endif // AIDL_USE_V2_INTERFACE MyUnion out; auto status = service->repeatUnion(in_ok, &out); ASSERT_TRUE(status.isOk()) << status; EXPECT_EQ(in_ok, out); #ifdef AIDL_USE_V2_INTERFACE status = service->repeatUnion(in_test, &out); if (kUseUnfrozen) { ASSERT_TRUE(status.isOk()) << status; EXPECT_EQ(in_test, out); } else { ASSERT_FALSE(status.isOk()) << status; EXPECT_NE(in_test, out); } #endif // AIDL_USE_V2_INTERFACE } class MyCallback : public ITrunkStableTest::BnMyCallback { public: MyCallback() {} virtual ~MyCallback() = default; Status repeatParcelable(const MyParcelable& input, MyParcelable* _aidl_return) override { *_aidl_return = input; repeatParcelableCalled = true; return Status::ok(); } Status repeatEnum(MyEnum input, MyEnum* _aidl_return) override { *_aidl_return = input; repeatEnumCalled = true; return Status::ok(); } Status repeatUnion(const MyUnion& input, MyUnion* _aidl_return) override { *_aidl_return = input; repeatUnionCalled = true; return Status::ok(); } #ifdef AIDL_USE_V2_INTERFACE Status repeatOtherParcelable(const MyOtherParcelable& input, MyOtherParcelable* _aidl_return) override { *_aidl_return = input; repeatOtherParcelableCalled = true; return Status::ok(); } #endif // AIDL_USE_V2_INTERFACE bool repeatParcelableCalled = false; bool repeatEnumCalled = false; bool repeatUnionCalled = false; #ifdef AIDL_USE_V2_INTERFACE bool repeatOtherParcelableCalled = false; #endif // AIDL_USE_V2_INTERFACE }; // repeatOtherParcelable is new in V2, so it won't be called TEST_F(TrunkInterfaceTest, callMyCallback) { sp cb = sp::make(); auto status = service->callMyCallback(cb); ASSERT_TRUE(status.isOk()) << status; if (kUseUnfrozen) { EXPECT_TRUE(cb->repeatParcelableCalled); EXPECT_TRUE(cb->repeatEnumCalled); EXPECT_TRUE(cb->repeatUnionCalled); #ifdef AIDL_USE_V2_INTERFACE EXPECT_TRUE(cb->repeatOtherParcelableCalled); #endif // AIDL_USE_V2_INTERFACE } else { EXPECT_TRUE(cb->repeatParcelableCalled); EXPECT_TRUE(cb->repeatEnumCalled); EXPECT_TRUE(cb->repeatUnionCalled); #ifdef AIDL_USE_V2_INTERFACE EXPECT_FALSE(cb->repeatOtherParcelableCalled); #endif // AIDL_USE_V2_INTERFACE } } ./PaxHeaders.X/tests_aidl_test_client_utf8_strings.cpp0100644 0000000 0000000 00000000034 15172120304 022247 xustar000000000 0000000 28 mtime=1776853188.3710000 tests/aidl_test_client_utf8_strings.cpp0100644 0000000 0000000 00000011457 15172120304 017503 0ustar000000000 0000000 /* * 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 #include #include #include #include #include "aidl_test_client.h" #include "gmock/gmock.h" using android::IBinder; using android::sp; using android::String16; using android::String8; using android::binder::Status; using android::aidl::tests::BackendType; using android::aidl::tests::ITestService; using testing::Eq; TEST_F(AidlTest, repeatUtf8String) { const std::vector utf8_inputs = { std::string("Deliver us from evil."), std::string(), std::string("\0\0", 2), // Similarly, the utf8 encodings of the small letter yee and euro sign. std::string("\xF0\x90\x90\xB7\xE2\x82\xAC"), ITestService::STRING_CONSTANT_UTF8(), }; for (const auto& input : utf8_inputs) { std::string reply; auto status = service->RepeatUtf8CppString(input, &reply); ASSERT_TRUE(status.isOk()); ASSERT_THAT(reply, Eq(input)); } std::optional reply; auto status = service->RepeatNullableUtf8CppString(std::nullopt, &reply); ASSERT_TRUE(status.isOk()); ASSERT_FALSE(reply.has_value()); for (const auto& input : utf8_inputs) { std::optional reply; auto status = service->RepeatNullableUtf8CppString(input, &reply); ASSERT_TRUE(status.isOk()); ASSERT_TRUE(reply.has_value()); ASSERT_THAT(*reply, Eq(input)); } } TEST_F(AidlTest, reverseUtf8StringArray) { std::vector input = {"a", "", "\xc3\xb8"}; decltype(input) repeated; if (backend == BackendType::JAVA) { repeated = decltype(input)(input.size()); } decltype(input) reversed; auto status = service->ReverseUtf8CppString(input, &repeated, &reversed); ASSERT_TRUE(status.isOk()) << status; ASSERT_THAT(repeated, Eq(input)); decltype(input) reversed_input(input); std::reverse(reversed_input.begin(), reversed_input.end()); ASSERT_THAT(reversed, Eq(reversed_input)); } struct AidlStringArrayTest : public AidlTest { void DoTest( Status (ITestService::*func)(const std::optional>>&, std::optional>>*, std::optional>>*)) { std::optional>> input; decltype(input) repeated; decltype(input) reversed; auto status = (*service.*func)(input, &repeated, &reversed); ASSERT_TRUE(status.isOk()) << status; if (func == &ITestService::ReverseUtf8CppStringList && backend == BackendType::JAVA) { // Java cannot clear the input variable to return a null value. It can // only ever fill out a list. ASSERT_TRUE(repeated.has_value()); } else { ASSERT_FALSE(repeated.has_value()); } ASSERT_FALSE(reversed.has_value()); input = std::vector>(); input->push_back("Deliver us from evil."); input->push_back(std::nullopt); input->push_back("\xF0\x90\x90\xB7\xE2\x82\xAC"); // usable size needs to be initialized for Java repeated = std::vector>(input->size()); status = (*service.*func)(input, &repeated, &reversed); ASSERT_TRUE(status.isOk()) << status; ASSERT_TRUE(reversed.has_value()); ASSERT_TRUE(repeated.has_value()); ASSERT_THAT(reversed->size(), Eq(input->size())); ASSERT_THAT(repeated->size(), Eq(input->size())); for (size_t i = 0; i < input->size(); i++) { auto input_str = (*input)[i]; auto repeated_str = (*repeated)[i]; auto reversed_str = (*reversed)[(reversed->size() - 1) - i]; if (!input_str) { ASSERT_FALSE(repeated_str.has_value()); ASSERT_FALSE(reversed_str.has_value()); // 3 nullptrs to strings. No need to compare values. continue; } ASSERT_TRUE(repeated_str.has_value()); ASSERT_TRUE(reversed_str.has_value()); ASSERT_THAT(*repeated_str, Eq(*input_str)); ASSERT_THAT(*reversed_str, Eq(*input_str)); } } }; TEST_F(AidlStringArrayTest, nullableList) { DoTest(&ITestService::ReverseUtf8CppStringList); } TEST_F(AidlStringArrayTest, nullableArray) { DoTest(&ITestService::ReverseNullableUtf8CppString); } ./PaxHeaders.X/tests_aidl_test_client_versioned_interface.cpp0100644 0000000 0000000 00000000034 15172120304 023626 xustar000000000 0000000 28 mtime=1776853188.3710000 tests/aidl_test_client_versioned_interface.cpp0100644 0000000 0000000 00000007270 15172120304 021060 0ustar000000000 0000000 /* * 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 #include #include #include #include #include #include "aidl_test_client.h" using android::OK; using android::sp; using android::String16; using android::aidl::versioned::tests::BazUnion; using android::aidl::versioned::tests::Foo; using android::aidl::versioned::tests::IFooInterface; using android::aidl::versioned::tests::IFooInterfaceDelegator; class VersionedInterfaceTest : public AidlTest { public: void SetUp() override { android::ProcessState::self()->setThreadPoolMaxThreadCount(1); android::ProcessState::self()->startThreadPool(); versioned = android::waitForService(IFooInterface::descriptor); ASSERT_NE(nullptr, versioned); AidlTest::SetUp(); } sp versioned; }; TEST_F(VersionedInterfaceTest, getInterfaceVersion) { EXPECT_EQ(1, versioned->getInterfaceVersion()); } TEST_F(VersionedInterfaceTest, getInterfaceHash) { EXPECT_EQ("9e7be1859820c59d9d55dd133e71a3687b5d2e5b", versioned->getInterfaceHash()); } TEST_F(VersionedInterfaceTest, noProblemWhenPassingAUnionWithOldField) { std::string result; auto status = versioned->acceptUnionAndReturnString(BazUnion::make(42), &result); EXPECT_TRUE(status.isOk()); EXPECT_EQ("42", result); } TEST_F(VersionedInterfaceTest, errorWhenPassingAUnionWithNewField) { std::string result; auto status = versioned->acceptUnionAndReturnString(BazUnion::make(42L), &result); // b/173458620 - Java and C++ return different errors if (backend == BackendType::JAVA) { EXPECT_EQ(::android::binder::Status::EX_ILLEGAL_ARGUMENT, status.exceptionCode()) << status; } else { EXPECT_EQ(::android::BAD_VALUE, status.transactionError()) << status; } } TEST_F(VersionedInterfaceTest, arrayOfParcelableWithNewParam) { std::vector foos(42); int32_t length; auto status = versioned->returnsLengthOfFooArray(foos, &length); EXPECT_TRUE(status.isOk()); EXPECT_EQ(42, length); } TEST_F(VersionedInterfaceTest, readDataCorrectlyAfterParcelableWithNewField) { Foo inFoo, inoutFoo, outFoo; inoutFoo.intDefault42 = 0; outFoo.intDefault42 = 0; int32_t ret; auto status = versioned->ignoreParcelablesAndRepeatInt(inFoo, &inoutFoo, &outFoo, 43, &ret); EXPECT_TRUE(status.isOk()); EXPECT_EQ(43, ret); EXPECT_EQ(0, inoutFoo.intDefault42); EXPECT_EQ(0, outFoo.intDefault42); } TEST_F(VersionedInterfaceTest, newerDelegatorReturnsImplVersion) { auto delegator = sp::make(versioned); EXPECT_EQ(1, delegator->getInterfaceVersion()); } TEST_F(VersionedInterfaceTest, newerDelegatorReturnsImplHash) { auto delegator = sp::make(versioned); EXPECT_EQ("9e7be1859820c59d9d55dd133e71a3687b5d2e5b", delegator->getInterfaceHash()); } TEST_F(VersionedInterfaceTest, errorWhenCallingV2Api) { auto status = versioned->newApi(); EXPECT_EQ(::android::UNKNOWN_TRANSACTION, status.transactionError()) << status; } ./PaxHeaders.X/tests_aidl_test_service.cpp0100644 0000000 0000000 00000000034 15172120304 017712 xustar000000000 0000000 28 mtime=1776853188.3710000 tests/aidl_test_service.cpp0100644 0000000 0000000 00000110045 15172120304 015137 0ustar000000000 0000000 /* * Copyright (C) 2015 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. */ #define LOG_TAG "aidl_native_service" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "android/aidl/tests/BackendType.h" #include "android/aidl/tests/BnTestService.h" #include "android/aidl/tests/ITestService.h" #include "android/aidl/tests/BnNamedCallback.h" #include "android/aidl/tests/INamedCallback.h" #include "android/aidl/versioned/tests/BnFooInterface.h" #include "android/aidl/versioned/tests/IFooInterface.h" #include #include #include "android/aidl/tests/BnNewName.h" #include "android/aidl/tests/BnOldName.h" #include "android/aidl/tests/BnCppJavaTests.h" #include "android/aidl/tests/ICppJavaTests.h" #include "android/aidl/tests/Union.h" #include "android/aidl/tests/extension/MyExt.h" #include "android/aidl/tests/extension/MyExt2.h" #include "android/aidl/tests/nested/BnNestedService.h" #include "android/aidl/tests/BnCircular.h" #include "android/aidl/tests/ICircular.h" #include "android/aidl/loggable/BnLoggableInterface.h" #include "android/aidl/loggable/Data.h" #include "android/aidl/fixedsizearray/FixedSizeArrayExample.h" // libbase using android::base::unique_fd; // libutils: using android::Looper; using android::LooperCallback; using android::OK; using android::sp; using android::status_t; using android::String16; using android::String8; // libbinder: using android::BnInterface; using android::defaultServiceManager; using android::IBinder; using android::IInterface; using android::IPCThreadState; using android::Parcel; using android::ProcessState; using android::binder::Status; // Generated code: using android::aidl::tests::BackendType; using android::aidl::tests::BadParcelable; using android::aidl::tests::BnCircular; using android::aidl::tests::BnCppJavaTests; using android::aidl::tests::BnNamedCallback; using android::aidl::tests::BnNewName; using android::aidl::tests::BnOldName; using android::aidl::tests::BnTestService; using android::aidl::tests::ByteEnum; using android::aidl::tests::CircularParcelable; using android::aidl::tests::ConstantExpressionEnum; using android::aidl::tests::GenericStructuredParcelable; using android::aidl::tests::ICircular; using android::aidl::tests::ICppJavaTests; using android::aidl::tests::INamedCallback; using android::aidl::tests::INewName; using android::aidl::tests::IntEnum; using android::aidl::tests::IOldName; using android::aidl::tests::ITestService; using android::aidl::tests::LongEnum; using android::aidl::tests::RecursiveList; using android::aidl::tests::SimpleParcelable; using android::aidl::tests::StructuredParcelable; using android::aidl::tests::Union; using android::os::ParcelFileDescriptor; using android::os::PersistableBundle; // Standard library using std::map; using std::optional; using std::string; using std::vector; namespace { class NamedCallback : public BnNamedCallback { public: explicit NamedCallback(String16 name) : name_(name) {} Status GetName(String16* ret) { *ret = name_; return Status::ok(); } private: String16 name_; }; class OldName : public BnOldName { public: OldName() = default; ~OldName() = default; Status RealName(String16* output) override { *output = String16("OldName"); return Status::ok(); } }; class NewName : public BnNewName { public: NewName() = default; ~NewName() = default; Status RealName(String16* output) override { *output = String16("NewName"); return Status::ok(); } }; class Circular : public BnCircular { public: Circular(sp srv) : mSrv(srv) {} ~Circular() = default; Status GetTestService(sp* _aidl_return) override { *_aidl_return = mSrv; return Status::ok(); } private: sp mSrv; }; template Status ReverseArray(const vector& input, vector* repeated, vector* _aidl_return) { ALOGI("Reversing array of length %zu", input.size()); *repeated = input; *_aidl_return = input; std::reverse(_aidl_return->begin(), _aidl_return->end()); return Status::ok(); } template Status RepeatNullable(const optional& input, optional* _aidl_return) { ALOGI("Repeating nullable value"); *_aidl_return = input; return Status::ok(); } class CppJavaTests : public BnCppJavaTests { public: CppJavaTests() = default; ~CppJavaTests() = default; Status RepeatBadParcelable(const BadParcelable& input, BadParcelable* _aidl_return) override { *_aidl_return = input; return Status::ok(); } Status RepeatGenericParcelable( const GenericStructuredParcelable& input, GenericStructuredParcelable* repeat, GenericStructuredParcelable* _aidl_return) { ALOGI("Repeating Generic Parcelable"); *repeat = input; *_aidl_return = input; return Status::ok(); } Status RepeatPersistableBundle(const PersistableBundle& input, PersistableBundle* _aidl_return) override { ALOGI("Repeated a PersistableBundle"); *_aidl_return = input; return Status::ok(); } Status ReversePersistableBundles(const vector& input, vector* repeated, vector* _aidl_return) override { return ReverseArray(input, repeated, _aidl_return); } Status ReverseUnion(const Union& input, Union* repeated, Union* _aidl_return) override { ALOGI("Repeated a Union"); *repeated = input; *_aidl_return = input; auto reverse = [](auto& reversible) { std::reverse(std::begin(reversible), std::end(reversible)); }; switch (input.getTag()) { case Union::ns: // int[] reverse(_aidl_return->get()); break; case Union::s: // String reverse(_aidl_return->get()); break; case Union::ss: // List reverse(_aidl_return->get()); break; default: break; } return Status::ok(); } Status ReverseNamedCallbackList(const vector>& input, vector>* repeated, vector>* _aidl_return) override { return ReverseArray(input, repeated, _aidl_return); } Status RepeatFileDescriptor(unique_fd read, unique_fd* _aidl_return) override { ALOGE("Repeating file descriptor"); *_aidl_return = unique_fd(dup(read.get())); return Status::ok(); } Status ReverseFileDescriptorArray(const vector& input, vector* repeated, vector* _aidl_return) override { ALOGI("Reversing descriptor array of length %zu", input.size()); repeated->clear(); for (const auto& item : input) { repeated->push_back(unique_fd(dup(item.get()))); _aidl_return->push_back(unique_fd(dup(item.get()))); } std::reverse(_aidl_return->begin(), _aidl_return->end()); return Status::ok(); } }; class NativeService : public BnTestService { public: NativeService() {} virtual ~NativeService() = default; void LogRepeatedStringToken(const String16& token) { ALOGI("Repeating '%s' of length=%zu", android::String8(token).c_str(), token.size()); } template void LogRepeatedToken(const T& token) { std::ostringstream token_str; token_str << token; ALOGI("Repeating token %s", token_str.str().c_str()); } Status TestOneway() override { return Status::fromStatusT(android::UNKNOWN_ERROR); } Status Deprecated() override { return Status::ok(); } Status RepeatBoolean(bool token, bool* _aidl_return) override { LogRepeatedToken(token ? 1 : 0); *_aidl_return = token; return Status::ok(); } Status RepeatByte(int8_t token, int8_t* _aidl_return) override { LogRepeatedToken(token); *_aidl_return = token; return Status::ok(); } Status RepeatChar(char16_t token, char16_t* _aidl_return) override { LogRepeatedStringToken(String16(&token, 1)); *_aidl_return = token; return Status::ok(); } Status RepeatInt(int32_t token, int32_t* _aidl_return) override { LogRepeatedToken(token); *_aidl_return = token; return Status::ok(); } Status RepeatLong(int64_t token, int64_t* _aidl_return) override { LogRepeatedToken(token); *_aidl_return = token; return Status::ok(); } Status RepeatFloat(float token, float* _aidl_return) override { LogRepeatedToken(token); *_aidl_return = token; return Status::ok(); } Status RepeatDouble(double token, double* _aidl_return) override { LogRepeatedToken(token); *_aidl_return = token; return Status::ok(); } Status RepeatString(const String16& token, String16* _aidl_return) override { LogRepeatedStringToken(token); *_aidl_return = token; return Status::ok(); } Status RepeatByteEnum(ByteEnum token, ByteEnum* _aidl_return) override { ALOGI("Repeating ByteEnum token %s", toString(token).c_str()); *_aidl_return = token; return Status::ok(); } Status RepeatIntEnum(IntEnum token, IntEnum* _aidl_return) override { ALOGI("Repeating IntEnum token %s", toString(token).c_str()); *_aidl_return = token; return Status::ok(); } Status RepeatLongEnum(LongEnum token, LongEnum* _aidl_return) override { ALOGI("Repeating LongEnum token %s", toString(token).c_str()); *_aidl_return = token; return Status::ok(); } Status ReverseBoolean(const vector& input, vector* repeated, vector* _aidl_return) override { return ReverseArray(input, repeated, _aidl_return); } Status ReverseByte(const vector& input, vector* repeated, vector* _aidl_return) override { return ReverseArray(input, repeated, _aidl_return); } Status ReverseChar(const vector& input, vector* repeated, vector* _aidl_return) override { return ReverseArray(input, repeated, _aidl_return); } Status ReverseInt(const vector& input, vector* repeated, vector* _aidl_return) override { return ReverseArray(input, repeated, _aidl_return); } Status ReverseLong(const vector& input, vector* repeated, vector* _aidl_return) override { return ReverseArray(input, repeated, _aidl_return); } Status ReverseFloat(const vector& input, vector* repeated, vector* _aidl_return) override { return ReverseArray(input, repeated, _aidl_return); } Status ReverseDouble(const vector& input, vector* repeated, vector* _aidl_return) override { return ReverseArray(input, repeated, _aidl_return); } Status ReverseString(const vector& input, vector* repeated, vector* _aidl_return) override { return ReverseArray(input, repeated, _aidl_return); } Status ReverseByteEnum(const vector& input, vector* repeated, vector* _aidl_return) override { return ReverseArray(input, repeated, _aidl_return); } Status ReverseIntEnum(const vector& input, vector* repeated, vector* _aidl_return) override { return ReverseArray(input, repeated, _aidl_return); } Status ReverseLongEnum(const vector& input, vector* repeated, vector* _aidl_return) override { return ReverseArray(input, repeated, _aidl_return); } Status SetOtherTestService(const String16& name, const sp& service, bool* _aidl_return) override { std::lock_guard guard(service_map_mutex_); const auto& existing = service_map_.find(name); if (existing != service_map_.end() && existing->second == service) { *_aidl_return = true; return Status::ok(); } else { *_aidl_return = false; service_map_[name] = service; return Status::ok(); } } Status GetOtherTestService(const String16& name, sp* returned_service) override { std::lock_guard guard(service_map_mutex_); if (service_map_.find(name) == service_map_.end()) { sp new_item(new NamedCallback(name)); service_map_[name] = new_item; } *returned_service = service_map_[name]; return Status::ok(); } Status VerifyName(const sp& service, const String16& name, bool* returned_value) override { String16 foundName; Status status = service->GetName(&foundName); if (status.isOk()) { *returned_value = foundName == name; } return status; } Status GetInterfaceArray(const vector& names, vector>* _aidl_return) override { vector> services(names.size()); for (size_t i = 0; i < names.size(); i++) { if (auto st = GetOtherTestService(names[i], &services[i]); !st.isOk()) { return st; } } *_aidl_return = std::move(services); return Status::ok(); } Status VerifyNamesWithInterfaceArray(const vector>& services, const vector& names, bool* _aidl_ret) override { if (services.size() == names.size()) { for (size_t i = 0; i < services.size(); i++) { if (auto st = VerifyName(services[i], names[i], _aidl_ret); !st.isOk() || !*_aidl_ret) { return st; } } *_aidl_ret = true; } else { *_aidl_ret = false; } return Status::ok(); } Status GetNullableInterfaceArray(const optional>>& names, optional>>* _aidl_ret) override { vector> services; if (names.has_value()) { for (const auto& name : *names) { if (name.has_value()) { sp ret; if (auto st = GetOtherTestService(*name, &ret); !st.isOk()) { return st; } services.push_back(std::move(ret)); } else { services.emplace_back(); } } } *_aidl_ret = std::move(services); return Status::ok(); } Status VerifyNamesWithNullableInterfaceArray(const optional>>& services, const optional>>& names, bool* _aidl_ret) override { if (services.has_value() && names.has_value()) { if (services->size() == names->size()) { for (size_t i = 0; i < services->size(); i++) { if (services->at(i).get() && names->at(i).has_value()) { if (auto st = VerifyName(services->at(i), names->at(i).value(), _aidl_ret); !st.isOk() || !*_aidl_ret) { return st; } } else if (services->at(i).get() || names->at(i).has_value()) { *_aidl_ret = false; return Status::ok(); } else { // ok if service=null && name=null } } *_aidl_ret = true; } else { *_aidl_ret = false; } } else { *_aidl_ret = services.has_value() == names.has_value(); } return Status::ok(); } Status GetInterfaceList(const optional>>& names, optional>>* _aidl_ret) override { return GetNullableInterfaceArray(names, _aidl_ret); } Status VerifyNamesWithInterfaceList(const optional>>& services, const optional>>& names, bool* _aidl_ret) override { return VerifyNamesWithNullableInterfaceArray(services, names, _aidl_ret); } Status ReverseStringList(const vector& input, vector* repeated, vector* _aidl_return) override { return ReverseArray(input, repeated, _aidl_return); } Status RepeatParcelFileDescriptor(const ParcelFileDescriptor& read, ParcelFileDescriptor* _aidl_return) override { ALOGE("Repeating parcel file descriptor"); _aidl_return->reset(unique_fd(dup(read.get()))); return Status::ok(); } Status ReverseParcelFileDescriptorArray(const vector& input, vector* repeated, vector* _aidl_return) override { ALOGI("Reversing parcel descriptor array of length %zu", input.size()); for (const auto& item : input) { repeated->push_back(ParcelFileDescriptor(unique_fd(dup(item.get())))); } for (auto i = input.rbegin(); i != input.rend(); i++) { _aidl_return->push_back(ParcelFileDescriptor(unique_fd(dup(i->get())))); } return Status::ok(); } Status ThrowServiceException(int code) override { return Status::fromServiceSpecificError(code); } Status RepeatNullableIntArray(const optional>& input, optional>* _aidl_return) { return RepeatNullable(input, _aidl_return); } Status RepeatNullableByteEnumArray(const optional>& input, optional>* _aidl_return) { return RepeatNullable(input, _aidl_return); } Status RepeatNullableIntEnumArray(const optional>& input, optional>* _aidl_return) { return RepeatNullable(input, _aidl_return); } Status RepeatNullableLongEnumArray(const optional>& input, optional>* _aidl_return) { return RepeatNullable(input, _aidl_return); } Status RepeatNullableStringList(const optional>>& input, optional>>* _aidl_return) { ALOGI("Repeating nullable string list"); return RepeatNullable(input, _aidl_return); } Status RepeatNullableString(const optional& input, optional* _aidl_return) { return RepeatNullable(input, _aidl_return); } Status RepeatNullableParcelable(const optional& input, optional* _aidl_return) { return RepeatNullable(input, _aidl_return); } Status RepeatNullableParcelableList( const optional>>& input, optional>>* _aidl_return) { return RepeatNullable(input, _aidl_return); } Status RepeatNullableParcelableArray( const optional>>& input, optional>>* _aidl_return) { return RepeatNullable(input, _aidl_return); } Status TakesAnIBinder(const sp& input) override { (void)input; return Status::ok(); } Status TakesANullableIBinder(const sp& input) { (void)input; return Status::ok(); } Status TakesAnIBinderList(const vector>& input) override { (void)input; return Status::ok(); } Status TakesANullableIBinderList(const optional>>& input) { (void)input; return Status::ok(); } Status RepeatUtf8CppString(const string& token, string* _aidl_return) override { ALOGI("Repeating utf8 string '%s' of length=%zu", token.c_str(), token.size()); *_aidl_return = token; return Status::ok(); } Status RepeatNullableUtf8CppString(const optional& token, optional* _aidl_return) override { if (!token) { ALOGI("Received null @utf8InCpp string"); return Status::ok(); } ALOGI("Repeating utf8 string '%s' of length=%zu", token->c_str(), token->size()); *_aidl_return = token; return Status::ok(); } Status ReverseUtf8CppString(const vector& input, vector* repeated, vector* _aidl_return) { return ReverseArray(input, repeated, _aidl_return); } Status ReverseNullableUtf8CppString(const optional>>& input, optional>>* repeated, optional>>* _aidl_return) { return ReverseUtf8CppStringList(input, repeated, _aidl_return); } Status ReverseUtf8CppStringList(const optional>>& input, optional>>* repeated, optional>>* _aidl_return) { if (!input) { ALOGI("Received null list of utf8 strings"); return Status::ok(); } *_aidl_return = input; *repeated = input; std::reverse((*_aidl_return)->begin(), (*_aidl_return)->end()); return Status::ok(); } Status GetCallback(bool return_null, sp* ret) { if (!return_null) { return GetOtherTestService(String16("ABT: always be testing"), ret); } return Status::ok(); } virtual ::android::binder::Status FillOutStructuredParcelable(StructuredParcelable* parcelable) { parcelable->shouldBeJerry = "Jerry"; parcelable->shouldContainThreeFs = {parcelable->f, parcelable->f, parcelable->f}; parcelable->shouldBeByteBar = ByteEnum::BAR; parcelable->shouldBeIntBar = IntEnum::BAR; parcelable->shouldBeLongBar = LongEnum::BAR; parcelable->shouldContainTwoByteFoos = {ByteEnum::FOO, ByteEnum::FOO}; parcelable->shouldContainTwoIntFoos = {IntEnum::FOO, IntEnum::FOO}; parcelable->shouldContainTwoLongFoos = {LongEnum::FOO, LongEnum::FOO}; parcelable->const_exprs_1 = ConstantExpressionEnum::decInt32_1; parcelable->const_exprs_2 = ConstantExpressionEnum::decInt32_2; parcelable->const_exprs_3 = ConstantExpressionEnum::decInt64_1; parcelable->const_exprs_4 = ConstantExpressionEnum::decInt64_2; parcelable->const_exprs_5 = ConstantExpressionEnum::decInt64_3; parcelable->const_exprs_6 = ConstantExpressionEnum::decInt64_4; parcelable->const_exprs_7 = ConstantExpressionEnum::hexInt32_1; parcelable->const_exprs_8 = ConstantExpressionEnum::hexInt32_2; parcelable->const_exprs_9 = ConstantExpressionEnum::hexInt32_3; parcelable->const_exprs_10 = ConstantExpressionEnum::hexInt64_1; parcelable->shouldSetBit0AndBit2 = StructuredParcelable::BIT0 | StructuredParcelable::BIT2; parcelable->u = Union::make({1, 2, 3}); parcelable->shouldBeConstS1 = Union::S1(); return Status::ok(); } ::android::binder::Status RepeatExtendableParcelable( const ::android::aidl::tests::extension::ExtendableParcelable& ep, ::android::aidl::tests::extension::ExtendableParcelable* ep2) { ep2->a = ep.a; ep2->b = ep.b; std::shared_ptr myExt; ep.ext.getParcelable(&myExt); ep2->ext.setParcelable(myExt); return Status::ok(); } ::android::binder::Status ReverseList(const RecursiveList& list, RecursiveList* ret) override { std::unique_ptr reversed; const RecursiveList* cur = &list; while (cur) { auto node = std::make_unique(); node->value = cur->value; node->next = std::move(reversed); reversed = std::move(node); cur = cur->next.get(); } *ret = std::move(*reversed); return Status::ok(); } Status ReverseIBinderArray(const vector>& input, vector>* repeated, vector>* _aidl_return) override { *repeated = input; *_aidl_return = input; std::reverse(_aidl_return->begin(), _aidl_return->end()); return Status::ok(); } Status ReverseNullableIBinderArray(const std::optional>>& input, std::optional>>* repeated, std::optional>>* _aidl_return) override { *repeated = input; *_aidl_return = input; if (*_aidl_return) { std::reverse((*_aidl_return)->begin(), (*_aidl_return)->end()); } return Status::ok(); } Status RepeatSimpleParcelable(const SimpleParcelable& input, SimpleParcelable* repeat, SimpleParcelable* _aidl_return) override { ALOGI("Repeated a SimpleParcelable %s", input.toString().c_str()); *repeat = input; *_aidl_return = input; return Status::ok(); } Status ReverseSimpleParcelables(const vector& input, vector* repeated, vector* _aidl_return) override { return ReverseArray(input, repeated, _aidl_return); } Status UnimplementedMethod(int32_t /* arg */, int32_t* /* _aidl_return */) override { LOG_ALWAYS_FATAL("UnimplementedMethod shouldn't be called"); } Status GetOldNameInterface(sp* ret) { *ret = new OldName; return Status::ok(); } Status GetNewNameInterface(sp* ret) { *ret = new NewName; return Status::ok(); } Status GetUnionTags(const std::vector& input, std::vector* _aidl_return) override { std::vector tags; std::transform(input.begin(), input.end(), std::back_inserter(tags), std::mem_fn(&Union::getTag)); *_aidl_return = std::move(tags); return Status::ok(); } Status GetCppJavaTests(sp* ret) { *ret = new CppJavaTests; return Status::ok(); } Status getBackendType(BackendType* _aidl_return) override { *_aidl_return = BackendType::CPP; return Status::ok(); } Status GetCircular(CircularParcelable* cp, sp* _aidl_return) override { auto srv = sp::fromExisting(this); cp->testService = srv; *_aidl_return = new Circular(srv); return Status::ok(); } status_t onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) override { if (code == ::android::IBinder::FIRST_CALL_TRANSACTION + 0 /* UnimplementedMethod */) { // pretend that UnimplementedMethod isn't implemented by this service. return android::UNKNOWN_TRANSACTION; } else { return BnTestService::onTransact(code, data, reply, flags); } } private: map> service_map_; std::mutex service_map_mutex_; }; class VersionedService : public android::aidl::versioned::tests::BnFooInterface { public: VersionedService() {} virtual ~VersionedService() = default; Status originalApi() override { return Status::ok(); } Status acceptUnionAndReturnString(const ::android::aidl::versioned::tests::BazUnion& u, std::string* _aidl_return) override { switch (u.getTag()) { case ::android::aidl::versioned::tests::BazUnion::intNum: *_aidl_return = std::to_string(u.get<::android::aidl::versioned::tests::BazUnion::intNum>()); break; } return Status::ok(); } Status returnsLengthOfFooArray(const vector<::android::aidl::versioned::tests::Foo>& foos, int32_t* ret) override { *ret = static_cast(foos.size()); return Status::ok(); } Status ignoreParcelablesAndRepeatInt(const ::android::aidl::versioned::tests::Foo& inFoo, ::android::aidl::versioned::tests::Foo* inoutFoo, ::android::aidl::versioned::tests::Foo* outFoo, int32_t value, int32_t* ret) override { (void)inFoo; (void)inoutFoo; (void)outFoo; *ret = value; return Status::ok(); } }; class TrunkStableService : public android::aidl::test::trunk::BnTrunkStableTest { public: TrunkStableService() {} virtual ~TrunkStableService() = default; Status repeatParcelable( const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override { *_aidl_return = input; return Status::ok(); } Status repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum input, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override { *_aidl_return = input; return Status::ok(); } Status repeatUnion( const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& input, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override { *_aidl_return = input; return Status::ok(); } Status callMyCallback( const ::android::sp<::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& cb) override { if (!cb) return Status::fromExceptionCode(Status::Exception::EX_NULL_POINTER); MyParcelable a, b; MyEnum c = MyEnum::ZERO, d = MyEnum::ZERO; MyUnion e, f; auto status = cb->repeatParcelable(a, &b); if (!status.isOk()) { return status; } status = cb->repeatEnum(c, &d); if (!status.isOk()) { return status; } status = cb->repeatUnion(e, &f); if (!status.isOk()) { return status; } MyOtherParcelable g, h; status = cb->repeatOtherParcelable(g, &h); return Status::ok(); } Status repeatOtherParcelable( const ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) override { *_aidl_return = input; return Status::ok(); } }; class LoggableInterfaceService : public android::aidl::loggable::BnLoggableInterface { public: LoggableInterfaceService() {} virtual ~LoggableInterfaceService() = default; virtual Status LogThis(bool, vector*, int8_t, vector*, char16_t, vector*, int32_t, vector*, int64_t, vector*, float, vector*, double, vector*, const String16&, vector*, vector*, const android::aidl::loggable::Data&, const sp&, optional*, vector*, vector* _aidl_return) override { *_aidl_return = vector{String16("loggable")}; return Status::ok(); } }; using namespace android::aidl::tests::nested; class NestedService : public BnNestedService { public: NestedService() {} virtual ~NestedService() = default; virtual Status flipStatus(const ParcelableWithNested& p, INestedService::Result* _aidl_return) { if (p.status == ParcelableWithNested::Status::OK) { _aidl_return->status = ParcelableWithNested::Status::NOT_OK; } else { _aidl_return->status = ParcelableWithNested::Status::OK; } return Status::ok(); } virtual Status flipStatusWithCallback(ParcelableWithNested::Status status, const sp& cb) { if (status == ParcelableWithNested::Status::OK) { return cb->done(ParcelableWithNested::Status::NOT_OK); } else { return cb->done(ParcelableWithNested::Status::OK); } } }; using android::aidl::fixedsizearray::FixedSizeArrayExample; class FixedSizeArrayService : public FixedSizeArrayExample::BnRepeatFixedSizeArray { public: FixedSizeArrayService() {} virtual ~FixedSizeArrayService() = default; Status RepeatBytes(const std::array& in_input, std::array* out_repeated, std::array* _aidl_return) override { *out_repeated = in_input; *_aidl_return = in_input; return Status::ok(); } Status RepeatInts(const std::array& in_input, std::array* out_repeated, std::array* _aidl_return) override { *out_repeated = in_input; *_aidl_return = in_input; return Status::ok(); } Status RepeatBinders(const std::array, 3>& in_input, std::array, 3>* out_repeated, std::array, 3>* _aidl_return) override { *out_repeated = in_input; *_aidl_return = in_input; return Status::ok(); } Status RepeatParcelables( const std::array& in_input, std::array* out_repeated, std::array* _aidl_return) override { *out_repeated = in_input; *_aidl_return = in_input; return Status::ok(); } Status Repeat2dBytes(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) override { *out_repeated = in_input; *_aidl_return = in_input; return Status::ok(); } Status Repeat2dInts(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) override { *out_repeated = in_input; *_aidl_return = in_input; return Status::ok(); } Status Repeat2dBinders(const std::array, 3>, 2>& in_input, std::array, 3>, 2>* out_repeated, std::array, 3>, 2>* _aidl_return) override { *out_repeated = in_input; *_aidl_return = in_input; return Status::ok(); } Status Repeat2dParcelables( const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) override { *out_repeated = in_input; *_aidl_return = in_input; return Status::ok(); } }; } // namespace int main(int /* argc */, char* /* argv */[]) { IPCThreadState::self()->disableBackgroundScheduling(true); std::vector> services = { sp::make(), sp::make(), sp::make(), sp::make(), sp::make(), sp::make(), }; for (const auto& service : services) { status_t status = defaultServiceManager()->addService(service->getInterfaceDescriptor(), service); if (status != OK) { ALOGE("Failed to add service %s", String8(service->getInterfaceDescriptor()).c_str()); return EXIT_FAILURE; } } IPCThreadState::self()->joinThreadPool(); return EXIT_FAILURE; } ./PaxHeaders.X/tests_aidl_test_service_ndk.cpp0100644 0000000 0000000 00000000034 15172120304 020546 xustar000000000 0000000 28 mtime=1776853188.3720000 tests/aidl_test_service_ndk.cpp0100644 0000000 0000000 00000103256 15172120304 016001 0ustar000000000 0000000 /* * Copyright (C) 2023 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. */ #define LOG_TAG "aidl_ndk_service" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using aidl::android::aidl::tests::BackendType; using aidl::android::aidl::tests::BnCircular; using aidl::android::aidl::tests::BnNamedCallback; using aidl::android::aidl::tests::BnNewName; using aidl::android::aidl::tests::BnOldName; using aidl::android::aidl::tests::BnTestService; using aidl::android::aidl::tests::ByteEnum; using aidl::android::aidl::tests::CircularParcelable; using aidl::android::aidl::tests::ConstantExpressionEnum; using aidl::android::aidl::tests::ICircular; using aidl::android::aidl::tests::INamedCallback; using aidl::android::aidl::tests::INewName; using aidl::android::aidl::tests::IntEnum; using aidl::android::aidl::tests::IOldName; using aidl::android::aidl::tests::ITestService; using aidl::android::aidl::tests::LongEnum; using aidl::android::aidl::tests::RecursiveList; using aidl::android::aidl::tests::SimpleParcelable; using aidl::android::aidl::tests::StructuredParcelable; using aidl::android::aidl::tests::Union; using aidl::android::aidl::tests::extension::ExtendableParcelable; using std::optional; using std::string; using std::vector; using ndk::ScopedAStatus; using ndk::ScopedFileDescriptor; using ndk::SharedRefBase; using ndk::SpAIBinder; namespace { class NamedCallback : public BnNamedCallback { public: explicit NamedCallback(std::string name) : name_(name) {} ScopedAStatus GetName(std::string* ret) override { *ret = name_; return ScopedAStatus::ok(); } private: std::string name_; }; class OldName : public BnOldName { public: OldName() = default; ~OldName() = default; ScopedAStatus RealName(std::string* output) override { *output = std::string("OldName"); return ScopedAStatus::ok(); } }; class NewName : public BnNewName { public: NewName() = default; ~NewName() = default; ScopedAStatus RealName(std::string* output) override { *output = std::string("NewName"); return ScopedAStatus::ok(); } }; class Circular : public BnCircular { public: Circular(std::shared_ptr srv) : mSrv(srv) {} ~Circular() = default; ScopedAStatus GetTestService(std::shared_ptr* _aidl_return) override { *_aidl_return = mSrv; return ScopedAStatus::ok(); } private: std::shared_ptr mSrv; }; template ScopedAStatus ReverseArray(const vector& input, vector* repeated, vector* _aidl_return) { ALOGI("Reversing array of length %zu", input.size()); *repeated = input; *_aidl_return = input; std::reverse(_aidl_return->begin(), _aidl_return->end()); return ScopedAStatus::ok(); } template ScopedAStatus RepeatNullable(const optional& input, optional* _aidl_return) { ALOGI("Repeating nullable value"); *_aidl_return = input; return ScopedAStatus::ok(); } class NativeService : public BnTestService { public: NativeService() {} virtual ~NativeService() = default; void LogRepeatedStringToken(const std::string& token) { ALOGI("Repeating '%s' of length=%zu", token.c_str(), token.size()); } template void LogRepeatedToken(const T& token) { std::ostringstream token_str; token_str << token; ALOGI("Repeating token %s", token_str.str().c_str()); } template <> void LogRepeatedToken(const char16_t& token) { ALOGI("Repeating token (char16_t) %d", token); } ScopedAStatus TestOneway() override { return ScopedAStatus::fromStatus(android::UNKNOWN_ERROR); } ScopedAStatus Deprecated() override { return ScopedAStatus::ok(); } ScopedAStatus RepeatBoolean(bool token, bool* _aidl_return) override { LogRepeatedToken(token ? 1 : 0); *_aidl_return = token; return ScopedAStatus::ok(); } ScopedAStatus RepeatByte(int8_t token, int8_t* _aidl_return) override { LogRepeatedToken(token); *_aidl_return = token; return ScopedAStatus::ok(); } ScopedAStatus RepeatChar(char16_t token, char16_t* _aidl_return) override { LogRepeatedToken(token); *_aidl_return = token; return ScopedAStatus::ok(); } ScopedAStatus RepeatInt(int32_t token, int32_t* _aidl_return) override { LogRepeatedToken(token); *_aidl_return = token; return ScopedAStatus::ok(); } ScopedAStatus RepeatLong(int64_t token, int64_t* _aidl_return) override { LogRepeatedToken(token); *_aidl_return = token; return ScopedAStatus::ok(); } ScopedAStatus RepeatFloat(float token, float* _aidl_return) override { LogRepeatedToken(token); *_aidl_return = token; return ScopedAStatus::ok(); } ScopedAStatus RepeatDouble(double token, double* _aidl_return) override { LogRepeatedToken(token); *_aidl_return = token; return ScopedAStatus::ok(); } ScopedAStatus RepeatString(const std::string& token, std::string* _aidl_return) override { LogRepeatedStringToken(token); *_aidl_return = token; return ScopedAStatus::ok(); } ScopedAStatus RepeatByteEnum(ByteEnum token, ByteEnum* _aidl_return) override { ALOGI("Repeating ByteEnum token %s", toString(token).c_str()); *_aidl_return = token; return ScopedAStatus::ok(); } ScopedAStatus RepeatIntEnum(IntEnum token, IntEnum* _aidl_return) override { ALOGI("Repeating IntEnum token %s", toString(token).c_str()); *_aidl_return = token; return ScopedAStatus::ok(); } ScopedAStatus RepeatLongEnum(LongEnum token, LongEnum* _aidl_return) override { ALOGI("Repeating LongEnum token %s", toString(token).c_str()); *_aidl_return = token; return ScopedAStatus::ok(); } ScopedAStatus ReverseBoolean(const vector& input, vector* repeated, vector* _aidl_return) override { return ReverseArray(input, repeated, _aidl_return); } ScopedAStatus ReverseByte(const vector& input, vector* repeated, vector* _aidl_return) override { return ReverseArray(input, repeated, _aidl_return); } ScopedAStatus ReverseChar(const vector& input, vector* repeated, vector* _aidl_return) override { return ReverseArray(input, repeated, _aidl_return); } ScopedAStatus ReverseInt(const vector& input, vector* repeated, vector* _aidl_return) override { return ReverseArray(input, repeated, _aidl_return); } ScopedAStatus ReverseLong(const vector& input, vector* repeated, vector* _aidl_return) override { return ReverseArray(input, repeated, _aidl_return); } ScopedAStatus ReverseFloat(const vector& input, vector* repeated, vector* _aidl_return) override { return ReverseArray(input, repeated, _aidl_return); } ScopedAStatus ReverseDouble(const vector& input, vector* repeated, vector* _aidl_return) override { return ReverseArray(input, repeated, _aidl_return); } ScopedAStatus ReverseString(const vector& input, vector* repeated, vector* _aidl_return) override { return ReverseArray(input, repeated, _aidl_return); } ScopedAStatus ReverseByteEnum(const vector& input, vector* repeated, vector* _aidl_return) override { return ReverseArray(input, repeated, _aidl_return); } ScopedAStatus ReverseIntEnum(const vector& input, vector* repeated, vector* _aidl_return) override { return ReverseArray(input, repeated, _aidl_return); } ScopedAStatus ReverseLongEnum(const vector& input, vector* repeated, vector* _aidl_return) override { return ReverseArray(input, repeated, _aidl_return); } ScopedAStatus SetOtherTestService(const std::string& name, const std::shared_ptr& service, bool* _aidl_return) override { std::lock_guard guard(service_map_mutex_); const auto& existing = service_map_.find(name); if (existing != service_map_.end() && existing->second == service) { *_aidl_return = true; return ScopedAStatus::ok(); } else { *_aidl_return = false; service_map_[name] = service; return ScopedAStatus::ok(); } } ScopedAStatus GetOtherTestService(const std::string& name, std::shared_ptr* returned_service) override { std::lock_guard guard(service_map_mutex_); if (service_map_.find(name) == service_map_.end()) { service_map_[name] = SharedRefBase::make(name); } *returned_service = service_map_[name]; return ScopedAStatus::ok(); } ScopedAStatus VerifyName(const std::shared_ptr& service, const std::string& name, bool* returned_value) override { std::string foundName; ScopedAStatus status = service->GetName(&foundName); if (status.isOk()) { *returned_value = foundName == name; } return status; } ScopedAStatus GetInterfaceArray(const vector& names, vector>* _aidl_return) override { vector> services(names.size()); for (size_t i = 0; i < names.size(); i++) { if (auto st = GetOtherTestService(names[i], &services[i]); !st.isOk()) { return st; } } *_aidl_return = std::move(services); return ScopedAStatus::ok(); } ScopedAStatus VerifyNamesWithInterfaceArray( const vector>& services, const vector& names, bool* _aidl_ret) override { if (services.size() == names.size()) { for (size_t i = 0; i < services.size(); i++) { if (auto st = VerifyName(services[i], names[i], _aidl_ret); !st.isOk() || !*_aidl_ret) { return st; } } *_aidl_ret = true; } else { *_aidl_ret = false; } return ScopedAStatus::ok(); } ScopedAStatus GetNullableInterfaceArray( const optional>>& names, optional>>* _aidl_ret) override { vector> services; if (names.has_value()) { for (const auto& name : *names) { if (name.has_value()) { std::shared_ptr ret; if (auto st = GetOtherTestService(*name, &ret); !st.isOk()) { return st; } services.push_back(std::move(ret)); } else { services.emplace_back(); } } } *_aidl_ret = std::move(services); return ScopedAStatus::ok(); } ScopedAStatus VerifyNamesWithNullableInterfaceArray( const optional>>& services, const optional>>& names, bool* _aidl_ret) override { if (services.has_value() && names.has_value()) { if (services->size() == names->size()) { for (size_t i = 0; i < services->size(); i++) { if (services->at(i).get() && names->at(i).has_value()) { if (auto st = VerifyName(services->at(i), names->at(i).value(), _aidl_ret); !st.isOk() || !*_aidl_ret) { return st; } } else if (services->at(i).get() || names->at(i).has_value()) { *_aidl_ret = false; return ScopedAStatus::ok(); } else { // ok if service=null && name=null } } *_aidl_ret = true; } else { *_aidl_ret = false; } } else { *_aidl_ret = services.has_value() == names.has_value(); } return ScopedAStatus::ok(); } ScopedAStatus GetInterfaceList( const optional>>& names, optional>>* _aidl_ret) override { return GetNullableInterfaceArray(names, _aidl_ret); } ScopedAStatus VerifyNamesWithInterfaceList( const optional>>& services, const optional>>& names, bool* _aidl_ret) override { return VerifyNamesWithNullableInterfaceArray(services, names, _aidl_ret); } ScopedAStatus ReverseStringList(const vector& input, vector* repeated, vector* _aidl_return) override { return ReverseArray(input, repeated, _aidl_return); } ScopedAStatus RepeatParcelFileDescriptor(const ScopedFileDescriptor& read, ScopedFileDescriptor* _aidl_return) override { ALOGE("Repeating parcel file descriptor"); *_aidl_return = read.dup(); return ScopedAStatus::ok(); } ScopedAStatus ReverseParcelFileDescriptorArray( const vector& input, vector* repeated, vector* _aidl_return) override { ALOGI("Reversing parcel descriptor array of length %zu", input.size()); for (const auto& item : input) { repeated->push_back(item.dup()); } for (auto i = input.rbegin(); i != input.rend(); i++) { _aidl_return->push_back(i->dup()); } return ScopedAStatus::ok(); } ScopedAStatus ThrowServiceException(int code) override { return ScopedAStatus::fromServiceSpecificError(code); } ScopedAStatus RepeatNullableIntArray(const optional>& input, optional>* _aidl_return) { return RepeatNullable(input, _aidl_return); } ScopedAStatus RepeatNullableByteEnumArray(const optional>& input, optional>* _aidl_return) { return RepeatNullable(input, _aidl_return); } ScopedAStatus RepeatNullableIntEnumArray(const optional>& input, optional>* _aidl_return) { return RepeatNullable(input, _aidl_return); } ScopedAStatus RepeatNullableLongEnumArray(const optional>& input, optional>* _aidl_return) { return RepeatNullable(input, _aidl_return); } ScopedAStatus RepeatNullableStringList(const optional>>& input, optional>>* _aidl_return) { ALOGI("Repeating nullable string list"); return RepeatNullable(input, _aidl_return); } ScopedAStatus RepeatNullableString(const optional& input, optional* _aidl_return) { return RepeatNullable(input, _aidl_return); } ScopedAStatus RepeatNullableParcelable(const optional& input, optional* _aidl_return) { return RepeatNullable(input, _aidl_return); } ScopedAStatus RepeatNullableParcelableList( const optional>>& input, optional>>* _aidl_return) { return RepeatNullable(input, _aidl_return); } ScopedAStatus RepeatNullableParcelableArray( const optional>>& input, optional>>* _aidl_return) { return RepeatNullable(input, _aidl_return); } ScopedAStatus TakesAnIBinder(const SpAIBinder& input) override { (void)input; return ScopedAStatus::ok(); } ScopedAStatus TakesANullableIBinder(const SpAIBinder& input) { (void)input; return ScopedAStatus::ok(); } ScopedAStatus TakesAnIBinderList(const vector& input) override { (void)input; return ScopedAStatus::ok(); } ScopedAStatus TakesANullableIBinderList(const optional>& input) { (void)input; return ScopedAStatus::ok(); } ScopedAStatus RepeatUtf8CppString(const string& token, string* _aidl_return) override { ALOGI("Repeating utf8 string '%s' of length=%zu", token.c_str(), token.size()); *_aidl_return = token; return ScopedAStatus::ok(); } ScopedAStatus RepeatNullableUtf8CppString(const optional& token, optional* _aidl_return) override { if (!token) { ALOGI("Received null @utf8InCpp string"); return ScopedAStatus::ok(); } ALOGI("Repeating utf8 string '%s' of length=%zu", token->c_str(), token->size()); *_aidl_return = token; return ScopedAStatus::ok(); } ScopedAStatus ReverseUtf8CppString(const vector& input, vector* repeated, vector* _aidl_return) { return ReverseArray(input, repeated, _aidl_return); } ScopedAStatus ReverseNullableUtf8CppString(const optional>>& input, optional>>* repeated, optional>>* _aidl_return) { return ReverseUtf8CppStringList(input, repeated, _aidl_return); } ScopedAStatus ReverseUtf8CppStringList(const optional>>& input, optional>>* repeated, optional>>* _aidl_return) { if (!input) { ALOGI("Received null list of utf8 strings"); return ScopedAStatus::ok(); } *_aidl_return = input; *repeated = input; std::reverse((*_aidl_return)->begin(), (*_aidl_return)->end()); return ScopedAStatus::ok(); } ScopedAStatus GetCallback(bool return_null, std::shared_ptr* ret) { if (!return_null) { return GetOtherTestService(std::string("ABT: always be testing"), ret); } return ScopedAStatus::ok(); } virtual ScopedAStatus FillOutStructuredParcelable(StructuredParcelable* parcelable) { parcelable->shouldBeJerry = "Jerry"; parcelable->shouldContainThreeFs = {parcelable->f, parcelable->f, parcelable->f}; parcelable->shouldBeByteBar = ByteEnum::BAR; parcelable->shouldBeIntBar = IntEnum::BAR; parcelable->shouldBeLongBar = LongEnum::BAR; parcelable->shouldContainTwoByteFoos = {ByteEnum::FOO, ByteEnum::FOO}; parcelable->shouldContainTwoIntFoos = {IntEnum::FOO, IntEnum::FOO}; parcelable->shouldContainTwoLongFoos = {LongEnum::FOO, LongEnum::FOO}; parcelable->const_exprs_1 = ConstantExpressionEnum::decInt32_1; parcelable->const_exprs_2 = ConstantExpressionEnum::decInt32_2; parcelable->const_exprs_3 = ConstantExpressionEnum::decInt64_1; parcelable->const_exprs_4 = ConstantExpressionEnum::decInt64_2; parcelable->const_exprs_5 = ConstantExpressionEnum::decInt64_3; parcelable->const_exprs_6 = ConstantExpressionEnum::decInt64_4; parcelable->const_exprs_7 = ConstantExpressionEnum::hexInt32_1; parcelable->const_exprs_8 = ConstantExpressionEnum::hexInt32_2; parcelable->const_exprs_9 = ConstantExpressionEnum::hexInt32_3; parcelable->const_exprs_10 = ConstantExpressionEnum::hexInt64_1; parcelable->shouldSetBit0AndBit2 = StructuredParcelable::BIT0 | StructuredParcelable::BIT2; parcelable->u = Union::make({1, 2, 3}); parcelable->shouldBeConstS1 = Union::S1; return ScopedAStatus::ok(); } ScopedAStatus RepeatExtendableParcelable( const ::aidl::android::aidl::tests::extension::ExtendableParcelable& ep, ::aidl::android::aidl::tests::extension::ExtendableParcelable* ep2) { ep2->a = ep.a; ep2->b = ep.b; std::optional myExt; ep.ext.getParcelable(&myExt); if (myExt == std::nullopt) { return ScopedAStatus::fromStatus(android::UNKNOWN_ERROR); } ep2->ext.setParcelable(*myExt); return ScopedAStatus::ok(); } ScopedAStatus ReverseList(const RecursiveList& list, RecursiveList* ret) override { std::unique_ptr reversed; const RecursiveList* cur = &list; while (cur) { auto node = std::make_unique(); node->value = cur->value; node->next = std::move(reversed); reversed = std::move(node); cur = cur->next.get(); } *ret = std::move(*reversed); return ScopedAStatus::ok(); } ScopedAStatus ReverseIBinderArray(const vector& input, vector* repeated, vector* _aidl_return) override { *repeated = input; *_aidl_return = input; std::reverse(_aidl_return->begin(), _aidl_return->end()); return ScopedAStatus::ok(); } ScopedAStatus ReverseNullableIBinderArray( const std::optional>& input, std::optional>* repeated, std::optional>* _aidl_return) override { *repeated = input; *_aidl_return = input; if (*_aidl_return) { std::reverse((*_aidl_return)->begin(), (*_aidl_return)->end()); } return ScopedAStatus::ok(); } ScopedAStatus RepeatSimpleParcelable(const SimpleParcelable& input, SimpleParcelable* repeat, SimpleParcelable* _aidl_return) override { ALOGI("Repeated a SimpleParcelable %s", input.toString().c_str()); *repeat = input; *_aidl_return = input; return ScopedAStatus::ok(); } ScopedAStatus ReverseSimpleParcelables(const vector& input, vector* repeated, vector* _aidl_return) override { return ReverseArray(input, repeated, _aidl_return); } ScopedAStatus UnimplementedMethod(int32_t /* arg */, int32_t* /* _aidl_return */) override { return ScopedAStatus::fromStatus(STATUS_UNKNOWN_TRANSACTION); } ScopedAStatus GetOldNameInterface(std::shared_ptr* ret) { *ret = SharedRefBase::make(); return ScopedAStatus::ok(); } ScopedAStatus GetNewNameInterface(std::shared_ptr* ret) { *ret = SharedRefBase::make(); return ScopedAStatus::ok(); } ScopedAStatus GetUnionTags(const std::vector& input, std::vector* _aidl_return) override { std::vector tags; std::transform(input.begin(), input.end(), std::back_inserter(tags), std::mem_fn(&Union::getTag)); *_aidl_return = std::move(tags); return ScopedAStatus::ok(); } ScopedAStatus GetCppJavaTests(SpAIBinder* ret) { *ret = nullptr; return ScopedAStatus::ok(); } ScopedAStatus getBackendType(BackendType* _aidl_return) override { *_aidl_return = BackendType::NDK; return ScopedAStatus::ok(); } ScopedAStatus GetCircular(CircularParcelable* cp, std::shared_ptr* _aidl_return) override { auto thiz = ref(); cp->testService = thiz; *_aidl_return = SharedRefBase::make(thiz); return ScopedAStatus::ok(); } private: std::map> service_map_; std::mutex service_map_mutex_; }; class VersionedService : public aidl::android::aidl::versioned::tests::BnFooInterface { public: VersionedService() {} virtual ~VersionedService() = default; ScopedAStatus originalApi() override { return ScopedAStatus::ok(); } ScopedAStatus acceptUnionAndReturnString( const ::aidl::android::aidl::versioned::tests::BazUnion& u, std::string* _aidl_return) override { switch (u.getTag()) { case ::aidl::android::aidl::versioned::tests::BazUnion::intNum: *_aidl_return = std::to_string(u.get<::aidl::android::aidl::versioned::tests::BazUnion::intNum>()); break; } return ScopedAStatus::ok(); } ScopedAStatus returnsLengthOfFooArray( const vector<::aidl::android::aidl::versioned::tests::Foo>& foos, int32_t* ret) override { *ret = static_cast(foos.size()); return ScopedAStatus::ok(); } ScopedAStatus ignoreParcelablesAndRepeatInt( const ::aidl::android::aidl::versioned::tests::Foo& inFoo, ::aidl::android::aidl::versioned::tests::Foo* inoutFoo, ::aidl::android::aidl::versioned::tests::Foo* outFoo, int32_t value, int32_t* ret) override { (void)inFoo; (void)inoutFoo; (void)outFoo; *ret = value; return ScopedAStatus::ok(); } }; class LoggableInterfaceService : public aidl::android::aidl::loggable::BnLoggableInterface { public: LoggableInterfaceService() {} virtual ~LoggableInterfaceService() = default; virtual ScopedAStatus LogThis(bool, vector*, int8_t, vector*, char16_t, vector*, int32_t, vector*, int64_t, vector*, float, vector*, double, vector*, const std::string&, vector*, vector*, const aidl::android::aidl::loggable::Data&, const SpAIBinder&, ScopedFileDescriptor*, vector*, vector* _aidl_return) override { *_aidl_return = vector{std::string("loggable")}; return ScopedAStatus::ok(); } }; using namespace aidl::android::aidl::tests::nested; class NestedService : public BnNestedService { public: NestedService() {} virtual ~NestedService() = default; virtual ScopedAStatus flipStatus(const ParcelableWithNested& p, INestedService::Result* _aidl_return) { if (p.status == ParcelableWithNested::Status::OK) { _aidl_return->status = ParcelableWithNested::Status::NOT_OK; } else { _aidl_return->status = ParcelableWithNested::Status::OK; } return ScopedAStatus::ok(); } virtual ScopedAStatus flipStatusWithCallback( ParcelableWithNested::Status status, const std::shared_ptr& cb) { if (status == ParcelableWithNested::Status::OK) { return cb->done(ParcelableWithNested::Status::NOT_OK); } else { return cb->done(ParcelableWithNested::Status::OK); } } }; using aidl::android::aidl::fixedsizearray::FixedSizeArrayExample; class FixedSizeArrayService : public FixedSizeArrayExample::BnRepeatFixedSizeArray { public: FixedSizeArrayService() {} virtual ~FixedSizeArrayService() = default; ScopedAStatus RepeatBytes(const std::array& in_input, std::array* out_repeated, std::array* _aidl_return) override { *out_repeated = in_input; *_aidl_return = in_input; return ScopedAStatus::ok(); } ScopedAStatus RepeatInts(const std::array& in_input, std::array* out_repeated, std::array* _aidl_return) override { *out_repeated = in_input; *_aidl_return = in_input; return ScopedAStatus::ok(); } ScopedAStatus RepeatBinders(const std::array& in_input, std::array* out_repeated, std::array* _aidl_return) override { *out_repeated = in_input; *_aidl_return = in_input; return ScopedAStatus::ok(); } ScopedAStatus RepeatParcelables( const std::array& in_input, std::array* out_repeated, std::array* _aidl_return) override { *out_repeated = in_input; *_aidl_return = in_input; return ScopedAStatus::ok(); } ScopedAStatus Repeat2dBytes(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) override { *out_repeated = in_input; *_aidl_return = in_input; return ScopedAStatus::ok(); } ScopedAStatus Repeat2dInts(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) override { *out_repeated = in_input; *_aidl_return = in_input; return ScopedAStatus::ok(); } ScopedAStatus Repeat2dBinders(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) override { *out_repeated = in_input; *_aidl_return = in_input; return ScopedAStatus::ok(); } ScopedAStatus Repeat2dParcelables( const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) override { *out_repeated = in_input; *_aidl_return = in_input; return ScopedAStatus::ok(); } }; class TrunkStableService : public aidl::android::aidl::test::trunk::BnTrunkStableTest { public: TrunkStableService() {} virtual ~TrunkStableService() = default; ScopedAStatus repeatParcelable( const aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& input, aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override { *_aidl_return = input; return ScopedAStatus::ok(); } ScopedAStatus repeatEnum( aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum input, aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override { *_aidl_return = input; return ScopedAStatus::ok(); } ScopedAStatus repeatUnion( const aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& input, aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override { *_aidl_return = input; return ScopedAStatus::ok(); } ScopedAStatus callMyCallback( const std::shared_ptr& cb) override { if (!cb) return ScopedAStatus::fromStatus(android::UNEXPECTED_NULL); MyParcelable a, b; MyEnum c = MyEnum::ZERO, d = MyEnum::ZERO; MyUnion e, f; auto status = cb->repeatParcelable(a, &b); if (!status.isOk()) { return status; } status = cb->repeatEnum(c, &d); if (!status.isOk()) { return status; } status = cb->repeatUnion(e, &f); if (!status.isOk()) { return status; } MyOtherParcelable g, h; status = cb->repeatOtherParcelable(g, &h); return ScopedAStatus::ok(); } ScopedAStatus repeatOtherParcelable( const aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& input, aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) override { *_aidl_return = input; return ScopedAStatus::ok(); } }; } // namespace int main(int /* argc */, char* /* argv */[]) { std::vector binders = { SharedRefBase::make()->asBinder(), SharedRefBase::make()->asBinder(), SharedRefBase::make()->asBinder(), SharedRefBase::make()->asBinder(), SharedRefBase::make()->asBinder(), SharedRefBase::make()->asBinder(), }; for (const SpAIBinder& binder : binders) { const char* desc = AIBinder_Class_getDescriptor(AIBinder_getClass(binder.get())); if (STATUS_OK != AServiceManager_addService(binder.get(), desc)) { ALOGE("Failed to add service %s", desc); return EXIT_FAILURE; } } ABinderProcess_joinThreadPool(); return EXIT_FAILURE; // should not reach } ./PaxHeaders.X/tests_android_0100644 0000000 0000000 00000000034 15172120304 015220 xustar000000000 0000000 28 mtime=1776853188.3730000 tests/android/0040755 0000000 0000000 00000000000 15172120304 012365 5ustar000000000 0000000 ./PaxHeaders.X/tests_android_aidl_0100644 0000000 0000000 00000000034 15172120304 016211 xustar000000000 0000000 28 mtime=1776853188.3730000 tests/android/aidl/0040755 0000000 0000000 00000000000 15172120304 013276 5ustar000000000 0000000 ./PaxHeaders.X/tests_android_aidl_fixedsizearray_0100644 0000000 0000000 00000000034 15172120304 021322 xustar000000000 0000000 28 mtime=1776853188.3730000 tests/android/aidl/fixedsizearray/0040755 0000000 0000000 00000000000 15172120304 016327 5ustar000000000 0000000 ./PaxHeaders.X/tests_android_aidl_fixedsizearray_FixedSizeArrayExample.aidl0100644 0000000 0000000 00000000034 15172120304 026360 xustar000000000 0000000 28 mtime=1776853188.3730000 tests/android/aidl/fixedsizearray/FixedSizeArrayExample.aidl0100644 0000000 0000000 00000011123 15172120304 023362 0ustar000000000 0000000 /* * Copyright (C) 2021 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. */ package android.aidl.fixedsizearray; @JavaDerive(toString=true) @RustDerive(PartialEq=true) parcelable FixedSizeArrayExample { // to see if NxM array works int[2][3] int2x3 = {{1, 2, 3}, {4, 5, 6}}; boolean[2] boolArray; byte[2] byteArray; char[2] charArray; int[2] intArray; long[2] longArray; float[2] floatArray; double[2] doubleArray; @utf8InCpp String[2] stringArray = {"hello", "world"}; ByteEnum[2] byteEnumArray; IntEnum[2] intEnumArray; LongEnum[2] longEnumArray; IntParcelable[2] parcelableArray; // Following fields are not test-friendly because they should be initialized as non-null. // IBinder[2] binderArray; // ParcelFileDescriptor[2] pfdArray; // IEmptyInterface[2] interfaceArray; boolean[2][2] boolMatrix; byte[2][2] byteMatrix; char[2][2] charMatrix; int[2][2] intMatrix; long[2][2] longMatrix; float[2][2] floatMatrix; double[2][2] doubleMatrix; @utf8InCpp String[2][2] stringMatrix = {{"hello", "world"}, {"Ciao", "mondo"}}; ByteEnum[2][2] byteEnumMatrix; IntEnum[2][2] intEnumMatrix; LongEnum[2][2] longEnumMatrix; IntParcelable[2][2] parcelableMatrix; // Following fields are not test-friendly because they should be initialized as non-null. // ParcelFileDescriptor[2][2] pfdMatrix; // IBinder[2][2] binderMatrix; // IEmptyInterface[2][2] interfaceMatrix; @nullable boolean[2] boolNullableArray; @nullable byte[2] byteNullableArray; @nullable char[2] charNullableArray; @nullable int[2] intNullableArray; @nullable long[2] longNullableArray; @nullable float[2] floatNullableArray; @nullable double[2] doubleNullableArray; @nullable @utf8InCpp String[2] stringNullableArray = {"hello", "world"}; @nullable ByteEnum[2] byteEnumNullableArray; @nullable IntEnum[2] intEnumNullableArray; @nullable LongEnum[2] longEnumNullableArray; @nullable IBinder[2] binderNullableArray; @nullable ParcelFileDescriptor[2] pfdNullableArray; @nullable IntParcelable[2] parcelableNullableArray; @nullable IEmptyInterface[2] interfaceNullableArray; @nullable boolean[2][2] boolNullableMatrix; @nullable byte[2][2] byteNullableMatrix; @nullable char[2][2] charNullableMatrix; @nullable int[2][2] intNullableMatrix; @nullable long[2][2] longNullableMatrix; @nullable float[2][2] floatNullableMatrix; @nullable double[2][2] doubleNullableMatrix; @nullable @utf8InCpp String[2][2] stringNullableMatrix = { {"hello", "world"}, {"Ciao", "mondo"}}; @nullable ByteEnum[2][2] byteEnumNullableMatrix; @nullable IntEnum[2][2] intEnumNullableMatrix; @nullable LongEnum[2][2] longEnumNullableMatrix; @nullable IBinder[2][2] binderNullableMatrix; @nullable ParcelFileDescriptor[2][2] pfdNullableMatrix; @nullable IntParcelable[2][2] parcelableNullableMatrix; @nullable IEmptyInterface[2][2] interfaceNullableMatrix; @SuppressWarnings(value={"out-array"}) interface IRepeatFixedSizeArray { byte[3] RepeatBytes(in byte[3] input, out byte[3] repeated); int[3] RepeatInts(in int[3] input, out int[3] repeated); IBinder[3] RepeatBinders(in IBinder[3] input, out IBinder[3] repeated); IntParcelable[3] RepeatParcelables( in IntParcelable[3] input, out IntParcelable[3] repeated); byte[2][3] Repeat2dBytes(in byte[2][3] input, out byte[2][3] repeated); int[2][3] Repeat2dInts(in int[2][3] input, out int[2][3] repeated); IBinder[2][3] Repeat2dBinders(in IBinder[2][3] input, out IBinder[2][3] repeated); IntParcelable[2][3] Repeat2dParcelables( in IntParcelable[2][3] input, out IntParcelable[2][3] repeated); } enum ByteEnum { A } @Backing(type="int") enum IntEnum { A } @Backing(type="long") enum LongEnum { A } @JavaDerive(equals=true) @RustDerive(Clone=true, Copy=true, PartialEq=true) parcelable IntParcelable { int value; } interface IEmptyInterface {} } ./PaxHeaders.X/tests_android_aidl_loggable_0100644 0000000 0000000 00000000034 15172120304 020045 xustar000000000 0000000 28 mtime=1776853188.3740000 tests/android/aidl/loggable/0040755 0000000 0000000 00000000000 15172120304 015052 5ustar000000000 0000000 ./PaxHeaders.X/tests_android_aidl_loggable_Data.aidl0100644 0000000 0000000 00000000034 15172120304 021547 xustar000000000 0000000 28 mtime=1776853188.3740000 tests/android/aidl/loggable/Data.aidl0100644 0000000 0000000 00000000333 15172120304 016552 0ustar000000000 0000000 package android.aidl.loggable; import android.aidl.loggable.Enum; import android.aidl.loggable.Union; parcelable Data { int num; @utf8InCpp String str; Union nestedUnion; Enum nestedEnum = Enum.FOO; } ./PaxHeaders.X/tests_android_aidl_loggable_Enum.aidl0100644 0000000 0000000 00000000034 15172120304 021602 xustar000000000 0000000 28 mtime=1776853188.3740000 tests/android/aidl/loggable/Enum.aidl0100644 0000000 0000000 00000000067 15172120304 016611 0ustar000000000 0000000 package android.aidl.loggable; enum Enum { FOO = 42 } ./PaxHeaders.X/tests_android_aidl_loggable_ILoggableInterface.aidl0100644 0000000 0000000 00000000034 15172120304 024344 xustar000000000 0000000 28 mtime=1776853188.3740000 tests/android/aidl/loggable/ILoggableInterface.aidl0100644 0000000 0000000 00000001521 15172120304 021347 0ustar000000000 0000000 package android.aidl.loggable; import android.aidl.loggable.Data; interface ILoggableInterface { @SuppressWarnings(value={"inout-parameter", "out-array", "out-nullable"}) String[] LogThis(boolean boolValue, inout boolean[] boolArray, byte byteValue, inout byte[] byteArray, char charValue, inout char[] charArray, int intValue, inout int[] intArray, long longValue, inout long[] longArray, float floatValue, inout float[] floatArray, double doubleValue, inout double[] doubleArray, String stringValue, inout String[] stringArray, inout List listValue, in Data dataValue, @nullable IBinder binderValue, inout @nullable ParcelFileDescriptor pfdValue, inout ParcelFileDescriptor[] pfdArray); interface ISub { void Log(int value); } } ./PaxHeaders.X/tests_android_aidl_loggable_Union.aidl0100644 0000000 0000000 00000000034 15172120304 021766 xustar000000000 0000000 28 mtime=1776853188.3740000 tests/android/aidl/loggable/Union.aidl0100644 0000000 0000000 00000000135 15172120304 016771 0ustar000000000 0000000 package android.aidl.loggable; union Union { int num = 43; @utf8InCpp String str; } ./PaxHeaders.X/tests_android_aidl_tests_0100644 0000000 0000000 00000000034 15172120304 017433 xustar000000000 0000000 28 mtime=1776853188.3740000 tests/android/aidl/tests/0040755 0000000 0000000 00000000000 15172120304 014440 5ustar000000000 0000000 ./PaxHeaders.X/tests_android_aidl_tests_ArrayOfInterfaces.aidl0100644 0000000 0000000 00000000034 15172120304 023633 xustar000000000 0000000 28 mtime=1776853188.3740000 tests/android/aidl/tests/ArrayOfInterfaces.aidl0100644 0000000 0000000 00000003450 15172120304 020641 0ustar000000000 0000000 /* * Copyright (C) 2021 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. */ package android.aidl.tests; @SuppressWarnings(value={"inout-parameter", "out-array"}) parcelable ArrayOfInterfaces { interface IEmptyInterface {} interface IMyInterface { @nullable IEmptyInterface[] methodWithInterfaces(IEmptyInterface iface, @nullable IEmptyInterface nullable_iface, in IEmptyInterface[] iface_array_in, out IEmptyInterface[] iface_array_out, inout IEmptyInterface[] iface_array_inout, in @nullable IEmptyInterface[] nullable_iface_array_in, out @nullable IEmptyInterface[] nullable_iface_array_out, inout @nullable IEmptyInterface[] nullable_iface_array_inout); } @JavaDerive(toString=true, equals=true) parcelable MyParcelable { IEmptyInterface iface; @nullable IEmptyInterface nullable_iface; IEmptyInterface[] iface_array; @nullable IEmptyInterface[] nullable_iface_array; } @JavaDerive(toString=true, equals=true) union MyUnion { IEmptyInterface iface; @nullable IEmptyInterface nullable_iface; IEmptyInterface[] iface_array; @nullable IEmptyInterface[] nullable_iface_array; } } ./PaxHeaders.X/tests_android_aidl_tests_BackendType.aidl0100644 0000000 0000000 00000000034 15172120304 022455 xustar000000000 0000000 28 mtime=1776853188.3740000 tests/android/aidl/tests/BackendType.aidl0100644 0000000 0000000 00000000130 15172120304 017453 0ustar000000000 0000000 package android.aidl.tests; enum BackendType { CPP, JAVA, NDK, RUST, } ./PaxHeaders.X/tests_android_aidl_tests_BadParcelable.aidl0100644 0000000 0000000 00000000034 15172120304 022725 xustar000000000 0000000 28 mtime=1776853188.3740000 tests/android/aidl/tests/BadParcelable.aidl0100644 0000000 0000000 00000001310 15172120304 017724 0ustar000000000 0000000 /* * Copyright (C) 2021 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. */ package android.aidl.tests; parcelable BadParcelable cpp_header "tests/bad_parcelable.h"; ./PaxHeaders.X/tests_android_aidl_tests_ByteEnum.aidl0100644 0000000 0000000 00000000034 15172120304 022014 xustar000000000 0000000 28 mtime=1776853188.3740000 tests/android/aidl/tests/ByteEnum.aidl0100644 0000000 0000000 00000001407 15172120304 017022 0ustar000000000 0000000 /* * Copyright (C) 2019 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. */ package android.aidl.tests; /* * Hello, world! */ @Backing(type="byte") enum ByteEnum { // Comment about FOO. FOO = 1, BAR = 2, BAZ, } ./PaxHeaders.X/tests_android_aidl_tests_CircularParcelable.aidl0100644 0000000 0000000 00000000034 15172120304 024003 xustar000000000 0000000 28 mtime=1776853188.3740000 tests/android/aidl/tests/CircularParcelable.aidl0100644 0000000 0000000 00000001375 15172120304 021015 0ustar000000000 0000000 /* * Copyright (C) 2022 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. */ package android.aidl.tests; import android.aidl.tests.ITestService; parcelable CircularParcelable { @nullable ITestService testService; } ./PaxHeaders.X/tests_android_aidl_tests_ConstantExpressionEnum.aidl0100644 0000000 0000000 00000000034 15172120304 024762 xustar000000000 0000000 28 mtime=1776853188.3740000 tests/android/aidl/tests/ConstantExpressionEnum.aidl0100644 0000000 0000000 00000002662 15172120304 021774 0ustar000000000 0000000 /* * Copyright (C) 2019 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. */ package android.aidl.tests; @SuppressWarnings(value={"const-name"}) @Backing(type="int") enum ConstantExpressionEnum { // Should be all true / ones. // dec literals are either int or long decInt32_1 = (~(-1)) == 0, decInt32_2 = ~~(1 << 31) == (1 << 31), decInt64_1 = (~(-1L)) == 0, decInt64_2 = (~4294967295L) != 0, decInt64_3 = (~4294967295) != 0, decInt64_4 = ~~(1L << 63) == (1L << 63), // hex literals could be int or long // 0x7fffffff is int, hence can be negated hexInt32_1 = -0x7fffffff < 0, // 0x80000000 is int32_t max + 1 hexInt32_2 = 0x80000000 < 0, // 0xFFFFFFFF is int32_t, not long; if it were long then ~(long)0xFFFFFFFF != 0 hexInt32_3 = ~0xFFFFFFFF == 0, // 0x7FFFFFFFFFFFFFFF is long, hence can be negated hexInt64_1 = -0x7FFFFFFFFFFFFFFF < 0 } ./PaxHeaders.X/tests_android_aidl_tests_DeprecatedEnum.aidl0100644 0000000 0000000 00000000034 15172120304 023151 xustar000000000 0000000 28 mtime=1776853188.3750000 tests/android/aidl/tests/DeprecatedEnum.aidl0100644 0000000 0000000 00000001344 15172120304 020157 0ustar000000000 0000000 /* * Copyright (C) 2021 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. */ package android.aidl.tests; /** @deprecated test */ @Backing(type="int") enum DeprecatedEnum { A, B, C, } ./PaxHeaders.X/tests_android_aidl_tests_DeprecatedParcelable.aidl0100644 0000000 0000000 00000000034 15172120304 024277 xustar000000000 0000000 28 mtime=1776853188.3750000 tests/android/aidl/tests/DeprecatedParcelable.aidl0100644 0000000 0000000 00000001305 15172120304 021302 0ustar000000000 0000000 /* * Copyright (C) 2021 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. */ package android.aidl.tests; /** @deprecated test */ parcelable DeprecatedParcelable {} ./PaxHeaders.X/tests_android_aidl_tests_FixedSize.aidl0100644 0000000 0000000 00000000034 15172120304 022156 xustar000000000 0000000 28 mtime=1776853188.3750000 tests/android/aidl/tests/FixedSize.aidl0100644 0000000 0000000 00000002402 15172120304 017160 0ustar000000000 0000000 /* * Copyright (C) 2021 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. */ package android.aidl.tests; import android.aidl.tests.LongEnum; parcelable FixedSize { @FixedSize parcelable FixedParcelable { boolean booleanValue; byte byteValue; char charValue; int intValue; long longValue; float floatValue; double doubleValue; LongEnum enumValue = LongEnum.FOO; FixedUnion parcelableValue; } @FixedSize union FixedUnion { boolean booleanValue = false; byte byteValue; char charValue; int intValue; long longValue; float floatValue; double doubleValue; LongEnum enumValue; } } ./PaxHeaders.X/tests_android_aidl_tests_GenericStructuredParcelable.aidl0100644 0000000 0000000 00000000034 15172120304 025700 xustar000000000 0000000 28 mtime=1776853188.3750000 tests/android/aidl/tests/GenericStructuredParcelable.aidl0100644 0000000 0000000 00000001453 15172120304 022707 0ustar000000000 0000000 /* * 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. */ package android.aidl.tests; @JavaDerive(toString=true) @RustDerive(PartialEq=true, Eq=true, Clone=true, Copy=true) parcelable GenericStructuredParcelable { int a; int b; } ./PaxHeaders.X/tests_android_aidl_tests_ICircular.aidl0100644 0000000 0000000 00000000034 15172120304 022141 xustar000000000 0000000 28 mtime=1776853188.3750000 tests/android/aidl/tests/ICircular.aidl0100644 0000000 0000000 00000001370 15172120304 017146 0ustar000000000 0000000 /* * Copyright (C) 2022 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. */ package android.aidl.tests; import android.aidl.tests.ITestService; interface ICircular { @nullable ITestService GetTestService(); } ./PaxHeaders.X/tests_android_aidl_tests_ICppJavaTests.aidl0100644 0000000 0000000 00000000034 15172120304 022744 xustar000000000 0000000 28 mtime=1776853188.3750000 tests/android/aidl/tests/ICppJavaTests.aidl0100644 0000000 0000000 00000003605 15172120304 017754 0ustar000000000 0000000 /* * 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. */ package android.aidl.tests; import android.aidl.tests.BadParcelable; import android.aidl.tests.GenericStructuredParcelable; import android.aidl.tests.IntEnum; import android.aidl.tests.StructuredParcelable; import android.aidl.tests.Union; import android.os.PersistableBundle; // Tests that are only supported by the C++/Java backends, not NDK/Rust interface ICppJavaTests { BadParcelable RepeatBadParcelable(in BadParcelable input); GenericStructuredParcelable RepeatGenericParcelable( in GenericStructuredParcelable input, out GenericStructuredParcelable repeat); PersistableBundle RepeatPersistableBundle(in PersistableBundle input); PersistableBundle[] ReversePersistableBundles( in PersistableBundle[] input, out PersistableBundle[] repeated); Union ReverseUnion(in Union input, out Union repeated); // Test that List types work correctly. List ReverseNamedCallbackList(in List input, out List repeated); FileDescriptor RepeatFileDescriptor(in FileDescriptor read); FileDescriptor[] ReverseFileDescriptorArray( in FileDescriptor[] input, out FileDescriptor[] repeated); } ./PaxHeaders.X/tests_android_aidl_tests_IDeprecated.aidl0100644 0000000 0000000 00000000034 15172120304 022435 xustar000000000 0000000 28 mtime=1776853188.3750000 tests/android/aidl/tests/IDeprecated.aidl0100644 0000000 0000000 00000001273 15172120304 017444 0ustar000000000 0000000 /* * Copyright (C) 2021 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. */ package android.aidl.tests; /** @deprecated test */ interface IDeprecated {} ./PaxHeaders.X/tests_android_aidl_tests_INamedCallback.aidl0100644 0000000 0000000 00000000034 15172120304 023036 xustar000000000 0000000 28 mtime=1776853188.3750000 tests/android/aidl/tests/INamedCallback.aidl0100644 0000000 0000000 00000001275 15172120304 020047 0ustar000000000 0000000 /* * Copyright (C) 2015 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. */ package android.aidl.tests; interface INamedCallback { String GetName(); } ./PaxHeaders.X/tests_android_aidl_tests_INewName.aidl0100644 0000000 0000000 00000000034 15172120304 021727 xustar000000000 0000000 28 mtime=1776853188.3750000 tests/android/aidl/tests/INewName.aidl0100644 0000000 0000000 00000001351 15172120304 016733 0ustar000000000 0000000 /* * 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. */ package android.aidl.tests; @Descriptor(value="android.aidl.tests.IOldName") interface INewName { String RealName(); } ./PaxHeaders.X/tests_android_aidl_tests_IOldName.aidl0100644 0000000 0000000 00000000034 15172120304 021714 xustar000000000 0000000 28 mtime=1776853188.3750000 tests/android/aidl/tests/IOldName.aidl0100644 0000000 0000000 00000001270 15172120304 016720 0ustar000000000 0000000 /* * 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. */ package android.aidl.tests; interface IOldName { String RealName(); } ./PaxHeaders.X/tests_android_aidl_tests_ITestService.aidl0100644 0000000 0000000 00000000034 15172120304 022635 xustar000000000 0000000 28 mtime=1776853188.3750000 tests/android/aidl/tests/ITestService.aidl0100644 0000000 0000000 00000032143 15172120304 017644 0ustar000000000 0000000 /* * Copyright (C) 2015 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. */ // package comment package android.aidl.tests; import android.aidl.tests.BackendType; import android.aidl.tests.ByteEnum; import android.aidl.tests.CircularParcelable; import android.aidl.tests.ICircular; import android.aidl.tests.INamedCallback; import android.aidl.tests.INewName; // import comment import android.aidl.tests.IOldName; import android.aidl.tests.IntEnum; import android.aidl.tests.LongEnum; import android.aidl.tests.RecursiveList; import android.aidl.tests.SimpleParcelable; import android.aidl.tests.StructuredParcelable; import android.aidl.tests.Union; import android.aidl.tests.extension.ExtendableParcelable; /** * interface comment */ @SuppressWarnings(value={"inout-parameter", "mixed-oneway", "out-array", "interface-name"}) /** * interface comment 2 */ @SensitiveData // interface comment 3 @JavaDefault // interface comment 4 @JavaDelegator interface ITestService { // Test that constants are accessible /** * extra doc comment */ // extra line comment /* * extra regular comment */ /** * const comment */ const int CONSTANT = 42; const int CONSTANT2 = -42; const int CONSTANT3 = +42; const int CONSTANT4 = +4; const int CONSTANT5 = -4; const int CONSTANT6 = -0; const int CONSTANT7 = +0; const int CONSTANT8 = 0; const int CONSTANT9 = 0x56; const int CONSTANT10 = 0xa5; const int CONSTANT11 = 0xFA; const int CONSTANT12 = 0xffffffff; const byte BYTE_CONSTANT = 17; const long LONG_CONSTANT = 1L << 40; const String STRING_CONSTANT = "foo"; const String STRING_CONSTANT2 = "bar"; const float FLOAT_CONSTANT = 1.0f; const float FLOAT_CONSTANT2 = -1.0f; const float FLOAT_CONSTANT3 = +1.0f; const float FLOAT_CONSTANT4 = +2.2f; const float FLOAT_CONSTANT5 = -2.2f; const float FLOAT_CONSTANT6 = -0.0f; const float FLOAT_CONSTANT7 = +0.0f; const double DOUBLE_CONSTANT = 1.0; const double DOUBLE_CONSTANT2 = -1.0; const double DOUBLE_CONSTANT3 = +1.0; const double DOUBLE_CONSTANT4 = +2.2; const double DOUBLE_CONSTANT5 = -2.2; const double DOUBLE_CONSTANT6 = -0.0; const double DOUBLE_CONSTANT7 = +0.0; const double DOUBLE_CONSTANT8 = 1.1f; const double DOUBLE_CONSTANT9 = -1.1f; const @utf8InCpp String STRING_CONSTANT_UTF8 = "baz"; // This is to emulate a method that is added after the service is implemented. // So the client cannot assume that a call to this method will be successful // or not. However, inside the test environment, we can't build client and // the server with different version of this AIDL file. So, we let the server // actually implement this and intercept the dispatch to the method // inside onTransact(). // WARNING: Must be first method. // This requires hard coding the transaction number. As long as this method is // the first in this interface, it can keep the // "::android::IBinder::FIRST_CALL_TRANSACTION + 0" value and allow // methods to be added and removed. int UnimplementedMethod(int arg); /** * @deprecated to make sure we have something in system/tools/aidl which does a compile check * of deprecated and make sure this is reflected in goldens */ void Deprecated(); oneway void TestOneway(); // Test that primitives work as parameters and return types. boolean RepeatBoolean(boolean token); byte RepeatByte(byte token); char RepeatChar(char token); int RepeatInt(int token); long RepeatLong(long token); float RepeatFloat(float token); double RepeatDouble(double token); String RepeatString(String token); ByteEnum RepeatByteEnum(ByteEnum token); IntEnum RepeatIntEnum(IntEnum token); LongEnum RepeatLongEnum(LongEnum token); // Test that arrays work as parameters and return types. boolean[] ReverseBoolean(in boolean[] input, out boolean[] repeated); byte[] ReverseByte(in byte[] input, out byte[] repeated); char[] ReverseChar(in char[] input, out char[] repeated); int[] ReverseInt(in int[] input, out int[] repeated); long[] ReverseLong(in long[] input, out long[] repeated); float[] ReverseFloat(in float[] input, out float[] repeated); double[] ReverseDouble(in double[] input, out double[] repeated); String[] ReverseString(in String[] input, out String[] repeated); ByteEnum[] ReverseByteEnum(in ByteEnum[] input, out ByteEnum[] repeated); IntEnum[] ReverseIntEnum(in IntEnum[] input, out IntEnum[] repeated); LongEnum[] ReverseLongEnum(in LongEnum[] input, out LongEnum[] repeated); // Test that clients can send and receive Binders. @PropagateAllowBlocking INamedCallback GetOtherTestService(String name); // returns true if the same service is already registered with the same name boolean SetOtherTestService(String name, INamedCallback service); boolean VerifyName(INamedCallback service, String name); INamedCallback[] GetInterfaceArray(in String[] names); boolean VerifyNamesWithInterfaceArray(in INamedCallback[] services, in String[] names); @nullable INamedCallback[] GetNullableInterfaceArray( in @nullable String[] names); boolean VerifyNamesWithNullableInterfaceArray( in @nullable INamedCallback[] services, in @nullable String[] names); @nullable List GetInterfaceList(in @nullable String[] names); boolean VerifyNamesWithInterfaceList(in @nullable List services, in @nullable String[] names); // Test that List types work correctly. List ReverseStringList(in List input, out List repeated); ParcelFileDescriptor RepeatParcelFileDescriptor(in ParcelFileDescriptor read); ParcelFileDescriptor[] ReverseParcelFileDescriptorArray( in ParcelFileDescriptor[] input, out ParcelFileDescriptor[] repeated); // Test that service specific exceptions work correctly. void ThrowServiceException(int code); // Test nullability @nullable int[] RepeatNullableIntArray(in @nullable int[] input); @nullable ByteEnum[] RepeatNullableByteEnumArray(in @nullable ByteEnum[] input); @nullable IntEnum[] RepeatNullableIntEnumArray(in @nullable IntEnum[] input); @nullable LongEnum[] RepeatNullableLongEnumArray(in @nullable LongEnum[] input); @nullable String RepeatNullableString(in @nullable String input); @nullable List RepeatNullableStringList( in @nullable List input); // Small empty parcelable for nullability check @JavaDerive(equals=true) @RustDerive(Clone=true, PartialEq=true) parcelable Empty {} @nullable Empty RepeatNullableParcelable(in @nullable Empty input); @nullable Empty[] RepeatNullableParcelableArray(in @nullable Empty[] input); @nullable List RepeatNullableParcelableList( in @nullable List input); void TakesAnIBinder(in IBinder input); void TakesANullableIBinder(in @nullable IBinder input); void TakesAnIBinderList(in List input); void TakesANullableIBinderList(in @nullable List input); // Test utf8 decoding from utf16 wire format @utf8InCpp String RepeatUtf8CppString(@utf8InCpp String token); @nullable @utf8InCpp String RepeatNullableUtf8CppString( @nullable @utf8InCpp String token); @utf8InCpp String[] ReverseUtf8CppString( in @utf8InCpp String[] input, out @utf8InCpp String[] repeated); @SuppressWarnings(value={"out-nullable"}) @nullable @utf8InCpp String[] ReverseNullableUtf8CppString( in @nullable @utf8InCpp String[] input, out @nullable @utf8InCpp String[] repeated); @SuppressWarnings(value={"out-nullable"}) @nullable @utf8InCpp List ReverseUtf8CppStringList( in @nullable @utf8InCpp List input, out @nullable @utf8InCpp List repeated); /** * comment before annotation */ @nullable INamedCallback GetCallback(boolean return_null); // Since this paracelable has clearly defined default values, it would be // inefficient to use an IPC to fill it out in practice. void FillOutStructuredParcelable(inout StructuredParcelable parcel); void RepeatExtendableParcelable(in ExtendableParcelable ep, out ExtendableParcelable ep2); RecursiveList ReverseList(in RecursiveList list); IBinder[] ReverseIBinderArray(in IBinder[] input, out IBinder[] repeated); @nullable IBinder[] ReverseNullableIBinderArray( in @nullable IBinder[] input, out @nullable IBinder[] repeated); SimpleParcelable RepeatSimpleParcelable(in SimpleParcelable input, out SimpleParcelable repeat); SimpleParcelable[] ReverseSimpleParcelables( in SimpleParcelable[] input, out SimpleParcelable[] repeated); // All these constant expressions should be equal to 1 const int A1 = (~(-1)) == 0; const int A2 = ~~(1 << 31) == (1 << 31); const int A3 = -0x7fffffff < 0; const int A4 = 0x80000000 < 0; const int A5 = 0x7fffffff == 2147483647; const int A6 = (1 << 31) == 0x80000000; const int A7 = (1 + 2) == 3; const int A8 = (8 - 9) == -1; const int A9 = (9 * 9) == 81; const int A10 = (29 / 3) == 9; const int A11 = (29 % 3) == 2; const int A12 = (0xC0010000 | 0xF00D) == (0xC001F00D); const int A13 = (10 | 6) == 14; const int A14 = (10 & 6) == 2; const int A15 = (10 ^ 6) == 12; const int A16 = 6 < 10; const int A17 = (10 < 10) == 0; const int A18 = (6 > 10) == 0; const int A19 = (10 > 10) == 0; const int A20 = 19 >= 10; const int A21 = 10 >= 10; const int A22 = 5 <= 10; const int A23 = (19 <= 10) == 0; const int A24 = 19 != 10; const int A25 = (10 != 10) == 0; const int A26 = (22 << 1) == 44; const int A27 = (11 >> 1) == 5; const int A28 = (1 || 0) == 1; const int A29 = (1 || 1) == 1; const int A30 = (0 || 0) == 0; const int A31 = (0 || 1) == 1; const int A32 = (1 && 0) == 0; const int A33 = (1 && 1) == 1; const int A34 = (0 && 0) == 0; const int A35 = (0 && 1) == 0; const int A36 = 4 == 4; const int A37 = -4 < 0; const int A38 = 0xffffffff == -1; const int A39 = 4 + 1 == 5; const int A40 = 2 + 3 - 4; const int A41 = 2 - 3 + 4 == 3; const int A42 = 1 == 4 == 0; const int A43 = 1 && 1; const int A44 = 1 || 1 && 0; // && higher than || const int A45 = 1 < 2; const int A46 = !!((3 != 4 || (2 < 3 <= 3 > 4)) >= 0); const int A47 = !(1 == 7) && ((3 != 4 || (2 < 3 <= 3 > 4)) >= 0); const int A48 = (1 << 2) >= 0; const int A49 = (4 >> 1) == 2; const int A50 = (8 << -1) == 4; const int A51 = (1 << 30 >> 30) == 1; const int A52 = (1 | 16 >> 2) == 5; const int A53 = (0x0f ^ 0x33 & 0x99) == 0x1e; // & higher than ^ const int A54 = (~42 & (1 << 3 | 16 >> 2) ^ 7) == 3; const int A55 = (2 + 3 - 4 * -7 / (10 % 3)) - 33 == 0; const int A56 = (2 + (-3 & 4 / 7)) == 2; const int A57 = (((((1 + 0))))); IOldName GetOldNameInterface(); INewName GetNewNameInterface(); Union.Tag[] GetUnionTags(in Union[] input); // Retrieve the ICppJavaTests if the server supports it @nullable IBinder GetCppJavaTests(); BackendType getBackendType(); parcelable CompilerChecks { // IBinder IBinder binder; @nullable IBinder nullable_binder; IBinder[] binder_array; @nullable IBinder[] nullable_binder_array; List binder_list; @nullable List nullable_binder_list; // ParcelFileDescriptor ParcelFileDescriptor pfd; @nullable ParcelFileDescriptor nullable_pfd; ParcelFileDescriptor[] pfd_array; @nullable ParcelFileDescriptor[] nullable_pfd_array; List pfd_list; @nullable List nullable_pfd_list; // parcelable Empty parcel; @nullable Empty nullable_parcel; Empty[] parcel_array; @nullable Empty[] nullable_parcel_array; List parcel_list; @nullable List nullable_parcel_list; // interface without I- interface Foo {} parcelable HasDeprecated { /** @deprecated field */ int deprecated; } union UsingHasDeprecated { int n; HasDeprecated m; } interface NoPrefixInterface { parcelable Nested {} interface NestedNoPrefixInterface { void foo(); } void foo(); } } ICircular GetCircular(out CircularParcelable cp); } ./PaxHeaders.X/tests_android_aidl_tests_IntEnum.aidl0100644 0000000 0000000 00000000034 15172120304 021643 xustar000000000 0000000 28 mtime=1776853188.3760000 tests/android/aidl/tests/IntEnum.aidl0100644 0000000 0000000 00000001444 15172120304 016652 0ustar000000000 0000000 /* * Copyright (C) 2019 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. */ package android.aidl.tests; @JavaDerive(toString=true) @Backing(type="int") enum IntEnum { FOO = 1000, BAR = 2000, BAZ, /** @deprecated do not use this */ QUX, } ./PaxHeaders.X/tests_android_aidl_tests_ListOfInterfaces.aidl0100644 0000000 0000000 00000000034 15172120304 023470 xustar000000000 0000000 28 mtime=1776853188.3760000 tests/android/aidl/tests/ListOfInterfaces.aidl0100644 0000000 0000000 00000003514 15172120304 020477 0ustar000000000 0000000 /* * Copyright (C) 2021 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. */ package android.aidl.tests; @SuppressWarnings(value={"inout-parameter", "out-nullable"}) parcelable ListOfInterfaces { interface IEmptyInterface {} interface IMyInterface { @nullable List methodWithInterfaces(IEmptyInterface iface, @nullable IEmptyInterface nullable_iface, in List iface_list_in, out List iface_list_out, inout List iface_list_inout, in @nullable List nullable_iface_list_in, out @nullable List nullable_iface_list_out, inout @nullable List nullable_iface_list_inout); } @JavaDerive(toString=true, equals=true) parcelable MyParcelable { IEmptyInterface iface; @nullable IEmptyInterface nullable_iface; List iface_list; @nullable List nullable_iface_list; } @JavaDerive(toString=true, equals=true) union MyUnion { IEmptyInterface iface; @nullable IEmptyInterface nullable_iface; List iface_list; @nullable List nullable_iface_list; } } ./PaxHeaders.X/tests_android_aidl_tests_LongEnum.aidl0100644 0000000 0000000 00000000034 15172120304 022010 xustar000000000 0000000 28 mtime=1776853188.3760000 tests/android/aidl/tests/LongEnum.aidl0100644 0000000 0000000 00000001353 15172120304 017016 0ustar000000000 0000000 /* * Copyright (C) 2019 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. */ package android.aidl.tests; @Backing(type="long") enum LongEnum { FOO = 100000000000, BAR = 200000000000, BAZ, } ./PaxHeaders.X/tests_android_aidl_tests_OtherParcelableForToString.aidl0100644 0000000 0000000 00000000034 15172120304 025461 xustar000000000 0000000 28 mtime=1776853188.3760000 tests/android/aidl/tests/OtherParcelableForToString.aidl0100644 0000000 0000000 00000001341 15172120304 022464 0ustar000000000 0000000 /* * 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. */ package android.aidl.tests; @JavaDerive(toString=true) parcelable OtherParcelableForToString { String field; } ./PaxHeaders.X/tests_android_aidl_tests_ParcelableForToString.aidl0100644 0000000 0000000 00000000034 15172120304 024457 xustar000000000 0000000 28 mtime=1776853188.3760000 tests/android/aidl/tests/ParcelableForToString.aidl0100644 0000000 0000000 00000003113 15172120304 021461 0ustar000000000 0000000 /* * 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. */ package android.aidl.tests; import android.aidl.tests.GenericStructuredParcelable; import android.aidl.tests.IntEnum; import android.aidl.tests.OtherParcelableForToString; import android.aidl.tests.StructuredParcelable; import android.aidl.tests.Union; @JavaDerive(toString=true) parcelable ParcelableForToString { int intValue; int[] intArray; long longValue; long[] longArray; double doubleValue; double[] doubleArray; float floatValue; float[] floatArray; byte byteValue; byte[] byteArray; boolean booleanValue; boolean[] booleanArray; String stringValue; String[] stringArray; List stringList; OtherParcelableForToString parcelableValue; OtherParcelableForToString[] parcelableArray; IntEnum enumValue = IntEnum.FOO; IntEnum[] enumArray; String[] nullArray; List nullList; GenericStructuredParcelable parcelableGeneric; Union unionValue; } ./PaxHeaders.X/tests_android_aidl_tests_RecursiveList.aidl0100644 0000000 0000000 00000000034 15172120304 023067 xustar000000000 0000000 28 mtime=1776853188.3770000 tests/android/aidl/tests/RecursiveList.aidl0100644 0000000 0000000 00000001343 15172120304 020074 0ustar000000000 0000000 /* * Copyright (C) 2021 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. */ package android.aidl.tests; parcelable RecursiveList { int value; @nullable(heap=true) RecursiveList next; } ./PaxHeaders.X/tests_android_aidl_tests_SimpleParcelable.aidl0100644 0000000 0000000 00000000034 15172120304 023470 xustar000000000 0000000 28 mtime=1776853188.3770000 tests/android/aidl/tests/SimpleParcelable.aidl0100644 0000000 0000000 00000001567 15172120304 020505 0ustar000000000 0000000 /* * Copyright (C) 2015 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. */ package android.aidl.tests; parcelable SimpleParcelable cpp_header "tests/simple_parcelable.h" ndk_header "tests/simple_parcelable_ndk.h" rust_type "simple_parcelable::SimpleParcelable"; ./PaxHeaders.X/tests_android_aidl_tests_StructuredParcelable.aidl0100644 0000000 0000000 00000000034 15172120304 024403 xustar000000000 0000000 28 mtime=1776853188.3770000 tests/android/aidl/tests/StructuredParcelable.aidl0100644 0000000 0000000 00000014703 15172120304 021414 0ustar000000000 0000000 /* * Copyright (C) 2018 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package android.aidl.tests; import android.aidl.tests.ByteEnum; import android.aidl.tests.ConstantExpressionEnum; import android.aidl.tests.IntEnum; import android.aidl.tests.LongEnum; import android.aidl.tests.Union; @SuppressWarnings(value={"enum-explicit-default"}) @JavaDerive(toString=true, equals=true) @RustDerive(Clone=true, PartialEq=true) parcelable StructuredParcelable { int[] shouldContainThreeFs; int f; @utf8InCpp String shouldBeJerry; ByteEnum shouldBeByteBar; IntEnum shouldBeIntBar; LongEnum shouldBeLongBar; ByteEnum[] shouldContainTwoByteFoos; IntEnum[] shouldContainTwoIntFoos; LongEnum[] shouldContainTwoLongFoos; String stringDefaultsToFoo = "foo"; byte byteDefaultsToFour = 4; int intDefaultsToFive = 5; long longDefaultsToNegativeSeven = -7; boolean booleanDefaultsToTrue = true; char charDefaultsToC = 'C'; float floatDefaultsToPi = 3.14f; double doubleWithDefault = -3.14e17; int[] arrayDefaultsTo123 = { 1, 2, 3, }; int[] arrayDefaultsToEmpty = {}; boolean boolDefault; byte byteDefault; int intDefault; long longDefault; float floatDefault; double doubleDefault; // parse checks only double checkDoubleFromFloat = 3.14f; String[] checkStringArray1 = {"a", "b"}; @utf8InCpp String[] checkStringArray2 = {"a", "b"}; // Add test to verify corner cases int int32_min = -2147483648; int int32_max = 2147483647; long int64_max = 9223372036854775807; int hexInt32_neg_1 = 0xffffffff; @nullable IBinder ibinder; // Make sure we can send an empty parcelable @JavaDerive(toString=true, equals=true) @RustDerive(Clone=true, PartialEq=true) parcelable Empty {} Empty empty; // Constant expressions that evaluate to 1 byte[] int8_1 = { 1, 0xffu8 + 1 == 0, 255u8 + 1 == 0, 0x80u8 == -128, // u8 type is reinterpreted as a signed type 0x80u8 / 2 == -0x40u8, }; int[] int32_1 = { (~(-1)) == 0, ~~(1 << 31) == (1 << 31), -0x7fffffff < 0, 0x8000_0000 < 0, 0x7fffffff == 2_147_483_647, // Shifting for more than 31 bits are undefined. Not tested. (1 << 31) == 0x80000000, // Should be all true / ones. (1 + 2) == 3, (8 - 9) == -1, (9 * 9) == 81, (29 / 3) == 9, (29 % 3) == 2, (0xC0010000 | 0xF00D) == (0xC001F00D), (10 | 6) == 14, (10 & 6) == 2, (10 ^ 6) == 12, 6 < 10, (10 < 10) == 0, (6 > 10) == 0, (10 > 10) == 0, 19 >= 10, 10 >= 10, 5 <= 10, (19 <= 10) == 0, 19 != 10, (10 != 10) == 0, (22 << 1) == 44, (11 >> 1) == 5, (1 || 0) == 1, (1 || 1) == 1, (0 || 0) == 0, (0 || 1) == 1, (1 && 0) == 0, (1 && 1) == 1, (0 && 0) == 0, (0 && 1) == 0, // precedence tests -- all 1s 4 == 4, -4 < 0, 0xffffffff == -1, 4 + 1 == 5, 2 + 3 - 4, 2 - 3 + 4 == 3, 1 == 4 == 0, 1 && 1, 1 || 1 && 0, // && higher than || 1 < 2, !!((3 != 4 || (2 < 3 <= 3 > 4)) >= 0), !(1 == 7) && ((3 != 4 || (2 < 3 <= 3 > 4)) >= 0), (1 << 2) >= 0, (4 >> 1) == 2, (8 << -1) == 4, (1 << 30 >> 30) == 1, (1 | 16 >> 2) == 5, (0x0f ^ 0x33 & 0x99) == 0x1e, // & higher than ^ (~42 & (1 << 3 | 16 >> 2) ^ 7) == 3, (2 + 3 - 4 * -7 / (10 % 3)) - 33 == 0, (2 + (-3 & 4 / 7)) == 2, (((((1 + 0))))), 100u32 + 100u32 == 200u32, 0x80000000u32 / 2 == -0x40000000u32, 2000000000u32 - 1000000000u32 == 1000000000u32, 0xffffffffu32 + 1 == 0, 4294967295u32 + 1 == 0, 0x80000000u32 == -2147483648, }; long[] int64_1 = { (~(-1)) == 0, (~4294967295) != 0, (~4294967295) != 0, ~~(1L << 63) == (1L << 63), -0x7FFFFFFFFFFFFFFF < 0, 0x7fff_ffff == 2147483647, 0xfffffffff == 68719476735, 0xffffffffffffffff == -1, (0xfL << 32L) == 0xf00000000, (0xfL << 32) == 0xf00000000, 10L == 1_0L, 10_0_0 == 1000L, (8000000000u64 + 8000000000u64) == 16000000000u64, 0x8000000000000000u64 / 2 == -0x4000000000000000u64, 16000000000u64 - 8000000000u64 == 8000000000u64, 0xffffffffffffffffu64 + 1 == 0, 18446744073709551615u64 + 1 == 0, 0x8000000000000000u64 == -9223372036854775807L - 1, }; int hexInt32_pos_1 = -0xffffffff; int hexInt64_pos_1 = -0xfffffffffff < 0; ConstantExpressionEnum const_exprs_1; ConstantExpressionEnum const_exprs_2; ConstantExpressionEnum const_exprs_3; ConstantExpressionEnum const_exprs_4; ConstantExpressionEnum const_exprs_5; ConstantExpressionEnum const_exprs_6; ConstantExpressionEnum const_exprs_7; ConstantExpressionEnum const_exprs_8; ConstantExpressionEnum const_exprs_9; ConstantExpressionEnum const_exprs_10; // String expressions @utf8InCpp String addString1 = "hello" + " world!"; @utf8InCpp String addString2 = "The quick brown fox jumps " + "over the lazy dog."; const int BIT0 = 0x1; const int BIT1 = 0x1 << 1; const int BIT2 = 0x1 << 2; int shouldSetBit0AndBit2; @nullable Union u; @nullable Union shouldBeConstS1; IntEnum defaultWithFoo = IntEnum.FOO; } ./PaxHeaders.X/tests_android_aidl_tests_Union.aidl0100644 0000000 0000000 00000000034 15172120304 021354 xustar000000000 0000000 28 mtime=1776853188.3770000 tests/android/aidl/tests/Union.aidl0100644 0000000 0000000 00000001740 15172120304 016362 0ustar000000000 0000000 /* * 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. */ package android.aidl.tests; import android.aidl.tests.ByteEnum; @JavaDerive(toString=true, equals=true) @RustDerive(Clone=true, PartialEq=true) union Union { int[] ns = {}; int n; int m; @utf8InCpp String s; @nullable IBinder ibinder; @utf8InCpp List ss; ByteEnum be; const @utf8InCpp String S1 = "a string constant in union"; } ./PaxHeaders.X/tests_android_aidl_tests_UnionWithFd.aidl0100644 0000000 0000000 00000000034 15172120304 022462 xustar000000000 0000000 28 mtime=1776853188.3770000 tests/android/aidl/tests/UnionWithFd.aidl0100644 0000000 0000000 00000001313 15172120304 017464 0ustar000000000 0000000 /* * 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. */ package android.aidl.tests; union UnionWithFd { int num; ParcelFileDescriptor pfd; } ./PaxHeaders.X/tests_android_aidl_tests_extension_0100644 0000000 0000000 00000000034 15172120304 021527 xustar000000000 0000000 28 mtime=1776853188.3770000 tests/android/aidl/tests/extension/0040755 0000000 0000000 00000000000 15172120304 016454 5ustar000000000 0000000 ./PaxHeaders.X/tests_android_aidl_tests_extension_ExtendableParcelable.aidl0100644 0000000 0000000 00000000034 15172120304 026406 xustar000000000 0000000 28 mtime=1776853188.3770000 tests/android/aidl/tests/extension/ExtendableParcelable.aidl0100644 0000000 0000000 00000001435 15172120304 023335 0ustar000000000 0000000 /* * 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. */ package android.aidl.tests.extension; parcelable ExtendableParcelable { int a; @utf8InCpp String b; ParcelableHolder ext; long c; ParcelableHolder ext2; } ./PaxHeaders.X/tests_android_aidl_tests_extension_MyExt.aidl0100644 0000000 0000000 00000000034 15172120304 023426 xustar000000000 0000000 28 mtime=1776853188.3770000 tests/android/aidl/tests/extension/MyExt.aidl0100644 0000000 0000000 00000001315 15172120304 020352 0ustar000000000 0000000 /* * 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. */ package android.aidl.tests.extension; parcelable MyExt { int a; @utf8InCpp String b; } ./PaxHeaders.X/tests_android_aidl_tests_extension_MyExt2.aidl0100644 0000000 0000000 00000000034 15172120304 023510 xustar000000000 0000000 28 mtime=1776853188.3770000 tests/android/aidl/tests/extension/MyExt2.aidl0100644 0000000 0000000 00000001407 15172120304 020436 0ustar000000000 0000000 /* * 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. */ package android.aidl.tests.extension; import android.aidl.tests.extension.MyExt; parcelable MyExt2 { int a; MyExt b; @utf8InCpp String c; } ./PaxHeaders.X/tests_android_aidl_tests_extension_MyExtLike.aidl0100644 0000000 0000000 00000000034 15172120304 024233 xustar000000000 0000000 28 mtime=1776853188.3770000 tests/android/aidl/tests/extension/MyExtLike.aidl0100644 0000000 0000000 00000001306 15172120304 021157 0ustar000000000 0000000 /* * 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. */ package android.aidl.tests.extension; parcelable MyExtLike { int a; String b; } ./PaxHeaders.X/tests_android_aidl_tests_generic_0100644 0000000 0000000 00000000034 15172120304 021127 xustar000000000 0000000 28 mtime=1776853188.3770000 tests/android/aidl/tests/generic/0040755 0000000 0000000 00000000000 15172120304 016054 5ustar000000000 0000000 ./PaxHeaders.X/tests_android_aidl_tests_generic_Baz.aidl0100644 0000000 0000000 00000000034 15172120304 022474 xustar000000000 0000000 28 mtime=1776853188.3770000 tests/android/aidl/tests/generic/Baz.aidl0100644 0000000 0000000 00000001260 15172120304 017417 0ustar000000000 0000000 /* * Copyright (C) 2019 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. */ package android.aidl.tests.generic; parcelable Baz { int a; } ./PaxHeaders.X/tests_android_aidl_tests_generic_IFaz.aidl0100644 0000000 0000000 00000000034 15172120304 022611 xustar000000000 0000000 28 mtime=1776853188.3770000 tests/android/aidl/tests/generic/IFaz.aidl0100644 0000000 0000000 00000001573 15172120304 017543 0ustar000000000 0000000 /* * Copyright (C) 2019 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. */ package android.aidl.tests.generic; import android.aidl.tests.IntEnum; import android.aidl.tests.generic.Baz; import android.aidl.tests.generic.Pair; interface IFaz { Pair getPair(); Pair getPair2(); Pair getPair3(); } ./PaxHeaders.X/tests_android_aidl_tests_generic_Pair.aidl0100644 0000000 0000000 00000000034 15172120304 022653 xustar000000000 0000000 28 mtime=1776853188.3770000 tests/android/aidl/tests/generic/Pair.aidl0100644 0000000 0000000 00000001251 15172120304 017576 0ustar000000000 0000000 /* * Copyright (C) 2019 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. */ package android.aidl.tests.generic; parcelable Pair; ./PaxHeaders.X/tests_android_aidl_tests_immutable_0100644 0000000 0000000 00000000034 15172120304 021472 xustar000000000 0000000 28 mtime=1776853188.3770000 tests/android/aidl/tests/immutable/0040755 0000000 0000000 00000000000 15172120304 016417 5ustar000000000 0000000 ./PaxHeaders.X/tests_android_aidl_tests_immutable_Bar.aidl0100644 0000000 0000000 00000000034 15172120304 023027 xustar000000000 0000000 28 mtime=1776853188.3770000 tests/android/aidl/tests/immutable/Bar.aidl0100644 0000000 0000000 00000001320 15172120304 017747 0ustar000000000 0000000 /* * 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. */ package android.aidl.tests.immutable; @JavaOnlyImmutable parcelable Bar { String s = "bar"; } ./PaxHeaders.X/tests_android_aidl_tests_immutable_Foo.aidl0100644 0000000 0000000 00000000034 15172120304 023046 xustar000000000 0000000 28 mtime=1776853188.3770000 tests/android/aidl/tests/immutable/Foo.aidl0100644 0000000 0000000 00000001555 15172120304 020000 0ustar000000000 0000000 /* * 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. */ package android.aidl.tests.immutable; import android.aidl.tests.immutable.Bar; import android.aidl.tests.immutable.Union; @JavaOnlyImmutable parcelable Foo { int a = 10; Bar b; List c; Map d; Bar[] e; Union u; } ./PaxHeaders.X/tests_android_aidl_tests_immutable_IBaz.aidl0100644 0000000 0000000 00000000034 15172120304 023150 xustar000000000 0000000 28 mtime=1776853188.3770000 tests/android/aidl/tests/immutable/IBaz.aidl0100644 0000000 0000000 00000001356 15172120304 020101 0ustar000000000 0000000 /* * 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. */ package android.aidl.tests.immutable; import android.aidl.tests.immutable.Foo; interface IBaz { Foo RepeatFoo(in Foo a); } ./PaxHeaders.X/tests_android_aidl_tests_immutable_Union.aidl0100644 0000000 0000000 00000000034 15172120304 023413 xustar000000000 0000000 28 mtime=1776853188.3770000 tests/android/aidl/tests/immutable/Union.aidl0100644 0000000 0000000 00000000240 15172120304 020333 0ustar000000000 0000000 package android.aidl.tests.immutable; import android.aidl.tests.immutable.Bar; @JavaOnlyImmutable union Union { int num; String[] str; Bar bar; } ./PaxHeaders.X/tests_android_aidl_tests_map_0100644 0000000 0000000 00000000034 15172120304 020270 xustar000000000 0000000 28 mtime=1776853188.3770000 tests/android/aidl/tests/map/0040755 0000000 0000000 00000000000 15172120304 015215 5ustar000000000 0000000 ./PaxHeaders.X/tests_android_aidl_tests_map_Bar.aidl0100644 0000000 0000000 00000000034 15172120304 021625 xustar000000000 0000000 28 mtime=1776853188.3770000 tests/android/aidl/tests/map/Bar.aidl0100644 0000000 0000000 00000001272 15172120304 016553 0ustar000000000 0000000 /* * Copyright (C) 2019 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. */ package android.aidl.tests.map; parcelable Bar { int a; String b; } ./PaxHeaders.X/tests_android_aidl_tests_map_Foo.aidl0100644 0000000 0000000 00000000034 15172120304 021644 xustar000000000 0000000 28 mtime=1776853188.3780000 tests/android/aidl/tests/map/Foo.aidl0100644 0000000 0000000 00000002073 15172120304 016572 0ustar000000000 0000000 /* * Copyright (C) 2019 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. */ package android.aidl.tests.map; import android.aidl.tests.map.Bar; import android.aidl.tests.map.IEmpty; import android.aidl.tests.map.IntEnum; parcelable Foo { Map intEnumArrayMap; Map intArrayMap; Map barMap; Map barArrayMap; Map stringMap; Map stringArrayMap; Map interfaceMap; Map ibinderMap; } ./PaxHeaders.X/tests_android_aidl_tests_map_IEmpty.aidl0100644 0000000 0000000 00000000034 15172120304 022330 xustar000000000 0000000 28 mtime=1776853188.3780000 tests/android/aidl/tests/map/IEmpty.aidl0100644 0000000 0000000 00000001242 15172120304 017253 0ustar000000000 0000000 /* * Copyright (C) 2019 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. */ package android.aidl.tests.map; interface IEmpty {} ./PaxHeaders.X/tests_android_aidl_tests_map_IMapTest.aidl0100644 0000000 0000000 00000000034 15172120304 022607 xustar000000000 0000000 28 mtime=1776853188.3780000 tests/android/aidl/tests/map/IMapTest.aidl0100644 0000000 0000000 00000003274 15172120304 017541 0ustar000000000 0000000 /* * Copyright (C) 2021 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. */ package android.aidl.tests.map; import android.aidl.tests.map.Bar; import android.aidl.tests.map.IEmpty; import android.aidl.tests.map.IntEnum; interface IMapTest { Map repeatIntEnumArrayMap( in Map input, out Map output); Map repeatIntArrayMap( in Map input, out Map output); Map repeatBarMap(in Map input, out Map output); Map repeatBarArrayMap( in Map input, out Map output); Map repeatStringMap( in Map input, out Map output); Map repeatStringArrayMap( in Map input, out Map output); Map repeatInterfaceMap( in Map input, out Map output); Map repeatIbinderMap( in Map input, out Map output); } ./PaxHeaders.X/tests_android_aidl_tests_map_IntEnum.aidl0100644 0000000 0000000 00000000034 15172120304 022500 xustar000000000 0000000 28 mtime=1776853188.3780000 tests/android/aidl/tests/map/IntEnum.aidl0100644 0000000 0000000 00000001335 15172120304 017426 0ustar000000000 0000000 /* * Copyright (C) 2021 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. */ package android.aidl.tests.map; @Backing(type="int") enum IntEnum { FOO = 1000, BAR = 2000, BAZ, } ./PaxHeaders.X/tests_android_aidl_tests_nested_0100644 0000000 0000000 00000000034 15172120304 020775 xustar000000000 0000000 28 mtime=1776853188.3780000 tests/android/aidl/tests/nested/0040755 0000000 0000000 00000000000 15172120304 015722 5ustar000000000 0000000 ./PaxHeaders.X/tests_android_aidl_tests_nested_DeeplyNested.aidl0100644 0000000 0000000 00000000034 15172120304 024213 xustar000000000 0000000 28 mtime=1776853188.3800000 tests/android/aidl/tests/nested/DeeplyNested.aidl0100644 0000000 0000000 00000001646 15172120304 021146 0ustar000000000 0000000 /* * Copyright (C) 2021 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. */ package android.aidl.tests.nested; parcelable DeeplyNested { parcelable A { // Can reference deeply nested type of a sibling type. B.C.D.E e = B.C.D.E.OK; } parcelable B { parcelable C { parcelable D { enum E { OK } } } } } ./PaxHeaders.X/tests_android_aidl_tests_nested_INestedService.aidl0100644 0000000 0000000 00000000034 15172120304 024502 xustar000000000 0000000 28 mtime=1776853188.3800000 tests/android/aidl/tests/nested/INestedService.aidl0100644 0000000 0000000 00000002117 15172120304 021427 0ustar000000000 0000000 /* * Copyright (C) 2021 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. */ package android.aidl.tests.nested; import android.aidl.tests.nested.ParcelableWithNested; interface INestedService { @RustDerive(PartialEq=true) parcelable Result { ParcelableWithNested.Status status = ParcelableWithNested.Status.OK; } Result flipStatus(in ParcelableWithNested p); interface ICallback { void done(ParcelableWithNested.Status status); } void flipStatusWithCallback(ParcelableWithNested.Status status, ICallback cb); } ./PaxHeaders.X/tests_android_aidl_tests_nested_ParcelableWithNested.aidl0100644 0000000 0000000 00000000034 15172120304 025657 xustar000000000 0000000 28 mtime=1776853188.3800000 tests/android/aidl/tests/nested/ParcelableWithNested.aidl0100644 0000000 0000000 00000001363 15172120304 022606 0ustar000000000 0000000 /* * Copyright (C) 2021 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. */ package android.aidl.tests.nested; parcelable ParcelableWithNested { enum Status { OK, NOT_OK } Status status = Status.OK; } ./PaxHeaders.X/tests_android_aidl_tests_permission_0100644 0000000 0000000 00000000034 15172120304 021703 xustar000000000 0000000 28 mtime=1776853188.3800000 tests/android/aidl/tests/permission/0040755 0000000 0000000 00000000000 15172120304 016630 5ustar000000000 0000000 ./PaxHeaders.X/tests_android_aidl_tests_permission_INoPermission.aidl0100644 0000000 0000000 00000000034 15172120304 025272 xustar000000000 0000000 28 mtime=1776853188.3800000 tests/android/aidl/tests/permission/INoPermission.aidl0100644 0000000 0000000 00000000152 15172120304 022214 0ustar000000000 0000000 package android.aidl.tests.permission; @RequiresNoPermission interface INoPermission { void foo(); } ./PaxHeaders.X/tests_android_aidl_tests_permission_IProtected.aidl0100644 0000000 0000000 00000000034 15172120304 024576 xustar000000000 0000000 28 mtime=1776853188.3800000 tests/android/aidl/tests/permission/IProtected.aidl0100644 0000000 0000000 00000001263 15172120304 021524 0ustar000000000 0000000 package android.aidl.tests.permission; interface IProtected { @EnforcePermission("READ_PHONE_STATE") void PermissionProtected(); @EnforcePermission(allOf={"INTERNET", "VIBRATE"}) void MultiplePermissionsAll(); @EnforcePermission(anyOf={"INTERNET", "VIBRATE"}) void MultiplePermissionsAny(); @EnforcePermission("android.net.NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK") void NonManifestPermission(); // Used by the integration tests to dynamically set permissions that are considered granted. @RequiresNoPermission void Grant(in String permission); @RequiresNoPermission void Revoke(in String permission); @RequiresNoPermission void RevokeAll(); } ./PaxHeaders.X/tests_android_aidl_tests_permission_IProtectedInterface.aidl0100644 0000000 0000000 00000000034 15172120304 026417 xustar000000000 0000000 28 mtime=1776853188.3800000 tests/android/aidl/tests/permission/IProtectedInterface.aidl0100644 0000000 0000000 00000000235 15172120304 023343 0ustar000000000 0000000 package android.aidl.tests.permission; @EnforcePermission("ACCESS_FINE_LOCATION") interface IProtectedInterface { void Method1(); void Method2(); } ./PaxHeaders.X/tests_android_aidl_tests_permission_platform_0100644 0000000 0000000 00000000034 15172120304 023607 xustar000000000 0000000 28 mtime=1776853188.3800000 tests/android/aidl/tests/permission/platform/0040755 0000000 0000000 00000000000 15172120304 020454 5ustar000000000 0000000 ./PaxHeaders.X/tests_android_aidl_tests_permission_platform_IProtected.aidl0100644 0000000 0000000 00000000034 15172120304 026502 xustar000000000 0000000 28 mtime=1776853188.3800000 tests/android/aidl/tests/permission/platform/IProtected.aidl0100644 0000000 0000000 00000000361 15172120304 023346 0ustar000000000 0000000 package android.aidl.tests.permission.platform; import android.content.AttributionSource; interface IProtected { @EnforcePermission(allOf={"INTERNET", "VIBRATE"}) void ProtectedWithSourceAttribution(in AttributionSource source); } ./PaxHeaders.X/tests_android_aidl_tests_unions_0100644 0000000 0000000 00000000034 15172120304 021026 xustar000000000 0000000 28 mtime=1776853188.3800000 tests/android/aidl/tests/unions/0040755 0000000 0000000 00000000000 15172120304 015753 5ustar000000000 0000000 ./PaxHeaders.X/tests_android_aidl_tests_unions_EnumUnion.aidl0100644 0000000 0000000 00000000034 15172120304 023574 xustar000000000 0000000 28 mtime=1776853188.3800000 tests/android/aidl/tests/unions/EnumUnion.aidl0100644 0000000 0000000 00000001666 15172120304 020531 0ustar000000000 0000000 /* * 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. */ package android.aidl.tests.unions; import android.aidl.tests.IntEnum; import android.aidl.tests.LongEnum; @JavaDerive(toString=true, equals=true) @RustDerive(Clone=true, PartialEq=true) union EnumUnion { IntEnum intEnum = IntEnum.FOO; LongEnum longEnum; /** @deprecated do not use this */ int deprecatedField; } ./PaxHeaders.X/tests_android_aidl_tests_unions_UnionInUnion.aidl0100644 0000000 0000000 00000000034 15172120304 024247 xustar000000000 0000000 28 mtime=1776853188.3800000 tests/android/aidl/tests/unions/UnionInUnion.aidl0100644 0000000 0000000 00000001511 15172120304 021171 0ustar000000000 0000000 /* * Copyright (C) 2021 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. */ package android.aidl.tests.unions; import android.aidl.tests.unions.EnumUnion; @JavaDerive(toString=true, equals=true) @RustDerive(Clone=true, PartialEq=true) union UnionInUnion { EnumUnion first; int second; } ./PaxHeaders.X/tests_bad_parcelable.cpp0100644 0000000 0000000 00000000034 15172120304 017122 xustar000000000 0000000 28 mtime=1776853188.3800000 tests/bad_parcelable.cpp0100644 0000000 0000000 00000003606 15172120304 014353 0ustar000000000 0000000 /* * Copyright (C) 2021 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 "tests/bad_parcelable.h" #include #include #include using android::base::StringPrintf; namespace android { namespace aidl { namespace tests { BadParcelable::BadParcelable(bool bad, const std::string& name, int32_t number) : bad_(bad), name_(name.c_str(), name.length()), number_(number) {} status_t BadParcelable::writeToParcel(Parcel* parcel) const { if (auto status = parcel->writeBool(bad_); status != OK) return status; if (auto status = parcel->writeString16(name_); status != OK) return status; if (auto status = parcel->writeInt32(number_); status != OK) return status; // BAD! write superfluous data if (bad_) parcel->writeInt32(42); return OK; } status_t BadParcelable::readFromParcel(const Parcel* parcel) { if (auto status = parcel->readBool(&bad_); status != OK) return status; if (auto status = parcel->readString16(&name_); status != OK) return status; if (auto status = parcel->readInt32(&number_); status != OK) return status; return OK; } std::string BadParcelable::toString() const { return StringPrintf("BadParcelable{bad=%d,name=%s,number=%d}", bad_, String8(name_).c_str(), number_); } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_bad_parcelable.h0100644 0000000 0000000 00000000034 15172120304 016567 xustar000000000 0000000 28 mtime=1776853188.3810000 tests/bad_parcelable.h0100644 0000000 0000000 00000003076 15172120304 014021 0ustar000000000 0000000 /* * Copyright (C) 2021 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. */ #pragma once #include #include #include #include #include namespace android { namespace aidl { namespace tests { class BadParcelable : public Parcelable { public: BadParcelable() = default; BadParcelable(bool bad, const std::string& name, int32_t number); virtual ~BadParcelable() = default; status_t writeToParcel(Parcel* parcel) const override; status_t readFromParcel(const Parcel* parcel) override; std::string toString() const; friend bool operator==(const BadParcelable& lhs, const BadParcelable& rhs) { return (lhs.bad_ == rhs.bad_) && (lhs.name_ == rhs.name_) && (lhs.number_ == rhs.number_); } friend bool operator!=(const BadParcelable& lhs, const BadParcelable& rhs) { return !(lhs == rhs); } private: bool bad_; String16 name_; int32_t number_ = 0; }; // class BadParcelable } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_corpus_0100644 0000000 0000000 00000000034 15172120304 015113 xustar000000000 0000000 28 mtime=1776853188.3810000 tests/corpus/0040755 0000000 0000000 00000000000 15172120304 012260 5ustar000000000 0000000 ./PaxHeaders.X/tests_corpus_example_cpp0100644 0000000 0000000 00000000034 15172120304 017331 xustar000000000 0000000 28 mtime=1776853188.3810000 tests/corpus/example_cpp0100644 0000000 0000000 00000000205 15172120304 014472 0ustar000000000 0000000 aidl\ --lang=cpp\ tests/IFoo.aidl\ --out\ .\ --header_out\ .\ tests/IFoo.aidl\ interface IFoo { const int a = 3 + 3; void doFoo(); }./PaxHeaders.X/tests_corpus_example_enforce0100644 0000000 0000000 00000000034 15172120304 020170 xustar000000000 0000000 28 mtime=1776853188.3810000 tests/corpus/example_enforce0100644 0000000 0000000 00000000242 15172120304 015332 0ustar000000000 0000000 aidl\ --lang=java\ tests/IFoo.aidl\ --out\ .\ --header_out\ .\ tests/IFoo.aidl\ interface IFoo { @Enforce("permission = ABC || permission=DEF") void doFoo(); } ./PaxHeaders.X/tests_corpus_example_java0100644 0000000 0000000 00000000034 15172120304 017470 xustar000000000 0000000 28 mtime=1776853188.3810000 tests/corpus/example_java0100644 0000000 0000000 00000000206 15172120304 014632 0ustar000000000 0000000 aidl\ --lang=java\ tests/IFoo.aidl\ --out\ .\ --header_out\ .\ tests/IFoo.aidl\ interface IFoo { const int a = 3 + 3; void doFoo(); }./PaxHeaders.X/tests_corpus_example_ndk0100644 0000000 0000000 00000000034 15172120304 017323 xustar000000000 0000000 28 mtime=1776853188.3810000 tests/corpus/example_ndk0100644 0000000 0000000 00000000205 15172120304 014464 0ustar000000000 0000000 aidl\ --lang=ndk\ tests/IFoo.aidl\ --out\ .\ --header_out\ .\ tests/IFoo.aidl\ interface IFoo { const int a = 3 + 3; void doFoo(); }./PaxHeaders.X/tests_corpus_example_rust0100644 0000000 0000000 00000000034 15172120304 017544 xustar000000000 0000000 28 mtime=1776853188.3810000 tests/corpus/example_rust0100644 0000000 0000000 00000000206 15172120304 014706 0ustar000000000 0000000 aidl\ --lang=rust\ tests/IFoo.aidl\ --out\ .\ --header_out\ .\ tests/IFoo.aidl\ interface IFoo { const int a = 3 + 3; void doFoo(); }./PaxHeaders.X/tests_corpus_java_map0100644 0000000 0000000 00000000034 15172120304 016612 xustar000000000 0000000 28 mtime=1776853188.3810000 tests/corpus/java_map0100644 0000000 0000000 00000000227 15172120304 013757 0ustar000000000 0000000 aidl\ --lang=java\ tests/IFoo.aidl\ --out\ .\ --header_out\ .\ tests/IFoo.aidl\ interface IFoo { boolean getFds(out Map fds); }./PaxHeaders.X/tests_corpus_overflow_in_nested_interface0100644 0000000 0000000 00000000034 15172120304 022747 xustar000000000 0000000 28 mtime=1776853188.3810000 tests/corpus/overflow_in_nested_interface0100644 0000000 0000000 00000000132 15172120304 020107 0ustar000000000 0000000 \ -a\ tests/IFoo.aidl\ -t\ \ tests/IFoo.aidl\ interface oo{interface o{const int a=0/0;}}./PaxHeaders.X/tests_fake_io_delegate.cpp0100644 0000000 0000000 00000000034 15172120304 017451 xustar000000000 0000000 28 mtime=1776853188.3810000 tests/fake_io_delegate.cpp0100644 0000000 0000000 00000006527 15172120304 014707 0ustar000000000 0000000 /* * Copyright (C) 2015, 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 "fake_io_delegate.h" #include #include #include "logging.h" #include "os.h" #include "tests/test_util.h" using android::base::Result; using android::base::StringAppendF; using android::base::StringPrintf; using std::string; using std::unique_ptr; using std::vector; namespace android { namespace aidl { namespace test { // Claims to always write successfully, but can't close the file. class BrokenCodeWriter : public CodeWriter { bool WriteString(const std::string& /* str */) override { return true; } bool Close() override { return false; } ~BrokenCodeWriter() override = default; }; // class BrokenCodeWriter unique_ptr FakeIoDelegate::GetFileContents( const string& relative_filename, const string& content_suffix) const { string filename = CleanPath(relative_filename); unique_ptr contents; auto it = file_contents_.find(filename); if (it == file_contents_.end()) { return contents; } contents.reset(new string); *contents = it->second; contents->append(content_suffix); return contents; } bool FakeIoDelegate::FileIsReadable(const string& path) const { return file_contents_.find(CleanPath(path)) != file_contents_.end(); } std::unique_ptr FakeIoDelegate::GetCodeWriter( const std::string& file_path) const { if (broken_files_.count(file_path) > 0) { return unique_ptr(new BrokenCodeWriter); } written_file_contents_[file_path] = ""; return CodeWriter::ForString(&written_file_contents_[file_path]); } void FakeIoDelegate::SetFileContents(const string& filename, const string& contents) { file_contents_[filename] = contents; } Result> FakeIoDelegate::ListFiles(const string& dir) const { const string dir_name = dir.back() == OS_PATH_SEPARATOR ? dir : dir + OS_PATH_SEPARATOR; vector files; for (auto it = file_contents_.begin(); it != file_contents_.end(); it++) { if (android::base::StartsWith(it->first, dir_name)) { files.emplace_back(it->first); } } return files; } void FakeIoDelegate::AddBrokenFilePath(const std::string& path) { broken_files_.insert(path); } bool FakeIoDelegate::GetWrittenContents(const string& path, string* content) const { const auto it = written_file_contents_.find(path); if (it == written_file_contents_.end()) { return false; } if (content) { *content = it->second; } return true; } const std::map& FakeIoDelegate::InputFiles() const { return file_contents_; } const std::map& FakeIoDelegate::OutputFiles() const { return written_file_contents_; } } // namespace test } // namespace aidl } // namespace android ./PaxHeaders.X/tests_fake_io_delegate.h0100644 0000000 0000000 00000000034 15172120304 017116 xustar000000000 0000000 28 mtime=1776853188.3810000 tests/fake_io_delegate.h0100644 0000000 0000000 00000005232 15172120304 014344 0ustar000000000 0000000 /* * Copyright (C) 2015, 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. */ #pragma once #include #include #include #include #include #include "io_delegate.h" namespace android { namespace aidl { namespace test { class FakeIoDelegate : public IoDelegate { public: FakeIoDelegate() = default; virtual ~FakeIoDelegate() = default; // non-copyable, non-movable FakeIoDelegate(const FakeIoDelegate&) = delete; FakeIoDelegate(FakeIoDelegate&&) = delete; FakeIoDelegate& operator=(const FakeIoDelegate&) = delete; FakeIoDelegate& operator=(FakeIoDelegate&&) = delete; // Overrides from the real IoDelegate std::unique_ptr GetFileContents( const std::string& filename, const std::string& append_content_suffix = "") const override; bool FileIsReadable(const std::string& path) const override; std::unique_ptr GetCodeWriter( const std::string& file_path) const override; android::base::Result> ListFiles(const std::string& dir) const override; // Methods added to facilitate testing. void SetFileContents(const std::string& filename, const std::string& contents); void AddBrokenFilePath(const std::string& path); // Returns true iff we've previously written to |path|. // When we return true, we'll set *contents to the written string. bool GetWrittenContents(const std::string& path, std::string* content) const; const std::map& InputFiles() const; const std::map& OutputFiles() const; private: std::map file_contents_; // Normally, writing to files leaves the IoDelegate unchanged, so // GetCodeWriter is a const method. However, for tests, we break this // intentionally by storing the written strings. mutable std::map written_file_contents_; // We normally just write to strings in |written_file_contents_| but for // files in this list, we simulate I/O errors. std::set broken_files_; }; // class FakeIoDelegate } // namespace test } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_0100644 0000000 0000000 00000000034 15172120304 016470 xustar000000000 0000000 28 mtime=1776853188.3810000 tests/golden_output/0040755 0000000 0000000 00000000000 15172120304 013635 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_.clang-format0100644 0000000 0000000 00000000034 15172120304 021041 xustar000000000 0000000 28 mtime=1776853188.3810000 tests/golden_output/.clang-format0100644 0000000 0000000 00000001205 15172120304 016203 0ustar000000000 0000000 # # 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. # DisableFormat: true SortIncludes: false ./PaxHeaders.X/tests_golden_output_aidl-cpp-java-test-interface-cpp-source_0100644 0000000 0000000 00000000034 15172120304 026151 xustar000000000 0000000 28 mtime=1776853188.3810000 tests/golden_output/aidl-cpp-java-test-interface-cpp-source/0040755 0000000 0000000 00000000000 15172120304 023236 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-cpp-java-test-interface-cpp-source_gen_0100644 0000000 0000000 00000000034 15172120304 027002 xustar000000000 0000000 28 mtime=1776853188.3810000 tests/golden_output/aidl-cpp-java-test-interface-cpp-source/gen/0040755 0000000 0000000 00000000000 15172120304 024007 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-cpp-java-test-interface-cpp-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 030502 xustar000000000 0000000 28 mtime=1776853188.3810000 tests/golden_output/aidl-cpp-java-test-interface-cpp-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 025427 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-cpp-java-test-interface-cpp-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 031473 xustar000000000 0000000 28 mtime=1776853188.3810000 tests/golden_output/aidl-cpp-java-test-interface-cpp-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 026340 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-cpp-java-test-interface-cpp-source_gen_android_aidl_tests_0100644 0000000 0000000 00000000034 15172120304 032715 xustar000000000 0000000 28 mtime=1776853188.3810000 tests/golden_output/aidl-cpp-java-test-interface-cpp-source/gen/android/aidl/tests/0040755 0000000 0000000 00000000000 15172120304 027502 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-cpp-java-test-interface-cpp-source_gen_android_aidl_tests_B0100644 0000000 0000000 00000000212 15172120304 033015 xustar000000000 0000000 110 path=tests/golden_output/aidl-cpp-java-test-interface-cpp-source/gen/android/aidl/tests/BadParcelable.cpp 28 mtime=1776853188.3810000 tests/golden_output/aidl-cpp-java-test-interface-cpp-source/gen/android/aidl/tests/BadParcelable.cpp0100644 0000000 0000000 00000001467 15172120304 032654 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -t --min_sdk_version current -pout/soong/.intermediates/system/tools/aidl/aidl-test-interface_interface/preprocessed.aidl --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/staging/android/aidl/tests/BadParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/staging -Iframeworks/native/aidl/binder -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/BadParcelable.aidl */ // This file is intentionally left blank as placeholder for parcel declaration. ./PaxHeaders.X/tests_golden_output_aidl-cpp-java-test-interface-cpp-source_gen_android_aidl_tests_B0100644 0000000 0000000 00000000214 15172120304 033017 xustar000000000 0000000 112 path=tests/golden_output/aidl-cpp-java-test-interface-cpp-source/gen/android/aidl/tests/BadParcelable.cpp.d 28 mtime=1776853188.3810000 tests/golden_output/aidl-cpp-java-test-interface-cpp-source/gen/android/aidl/tests/BadParcelable.cpp0100644 0000000 0000000 00000000300 15172120304 032635 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/android/aidl/tests/BadParcelable.cpp : \ system/tools/aidl/tests/android/aidl/tests/BadParcelable.aidl ./PaxHeaders.X/tests_golden_output_aidl-cpp-java-test-interface-cpp-source_gen_android_aidl_tests_I0100644 0000000 0000000 00000000212 15172120304 033024 xustar000000000 0000000 110 path=tests/golden_output/aidl-cpp-java-test-interface-cpp-source/gen/android/aidl/tests/ICppJavaTests.cpp 28 mtime=1776853188.3820000 tests/golden_output/aidl-cpp-java-test-interface-cpp-source/gen/android/aidl/tests/ICppJavaTests.cpp0100644 0000000 0000000 00000065625 15172120304 032701 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -t --min_sdk_version current -pout/soong/.intermediates/system/tools/aidl/aidl-test-interface_interface/preprocessed.aidl --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/staging/android/aidl/tests/ICppJavaTests.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/staging -Iframeworks/native/aidl/binder -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ICppJavaTests.aidl */ #include #include namespace android { namespace aidl { namespace tests { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE(CppJavaTests, "android.aidl.tests.ICppJavaTests") } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { BpCppJavaTests::BpCppJavaTests(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } ::android::binder::Status BpCppJavaTests::RepeatBadParcelable(const ::android::aidl::tests::BadParcelable& input, ::android::aidl::tests::BadParcelable* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICppJavaTests::RepeatBadParcelable::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnCppJavaTests::TRANSACTION_RepeatBadParcelable, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ICppJavaTests::getDefaultImpl()) [[unlikely]] { return ICppJavaTests::getDefaultImpl()->RepeatBadParcelable(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpCppJavaTests::RepeatGenericParcelable(const ::android::aidl::tests::GenericStructuredParcelable& input, ::android::aidl::tests::GenericStructuredParcelable* repeat, ::android::aidl::tests::GenericStructuredParcelable* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICppJavaTests::RepeatGenericParcelable::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnCppJavaTests::TRANSACTION_RepeatGenericParcelable, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ICppJavaTests::getDefaultImpl()) [[unlikely]] { return ICppJavaTests::getDefaultImpl()->RepeatGenericParcelable(input, repeat, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readParcelable(repeat); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpCppJavaTests::RepeatPersistableBundle(const ::android::os::PersistableBundle& input, ::android::os::PersistableBundle* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICppJavaTests::RepeatPersistableBundle::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnCppJavaTests::TRANSACTION_RepeatPersistableBundle, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ICppJavaTests::getDefaultImpl()) [[unlikely]] { return ICppJavaTests::getDefaultImpl()->RepeatPersistableBundle(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpCppJavaTests::ReversePersistableBundles(const ::std::vector<::android::os::PersistableBundle>& input, ::std::vector<::android::os::PersistableBundle>* repeated, ::std::vector<::android::os::PersistableBundle>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICppJavaTests::ReversePersistableBundles::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelableVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnCppJavaTests::TRANSACTION_ReversePersistableBundles, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ICppJavaTests::getDefaultImpl()) [[unlikely]] { return ICppJavaTests::getDefaultImpl()->ReversePersistableBundles(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelableVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readParcelableVector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpCppJavaTests::ReverseUnion(const ::android::aidl::tests::Union& input, ::android::aidl::tests::Union* repeated, ::android::aidl::tests::Union* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICppJavaTests::ReverseUnion::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnCppJavaTests::TRANSACTION_ReverseUnion, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ICppJavaTests::getDefaultImpl()) [[unlikely]] { return ICppJavaTests::getDefaultImpl()->ReverseUnion(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readParcelable(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpCppJavaTests::ReverseNamedCallbackList(const ::std::vector<::android::sp<::android::IBinder>>& input, ::std::vector<::android::sp<::android::IBinder>>* repeated, ::std::vector<::android::sp<::android::IBinder>>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICppJavaTests::ReverseNamedCallbackList::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinderVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnCppJavaTests::TRANSACTION_ReverseNamedCallbackList, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ICppJavaTests::getDefaultImpl()) [[unlikely]] { return ICppJavaTests::getDefaultImpl()->ReverseNamedCallbackList(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpCppJavaTests::RepeatFileDescriptor(::android::base::unique_fd read, ::android::base::unique_fd* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICppJavaTests::RepeatFileDescriptor::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeUniqueFileDescriptor(read); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnCppJavaTests::TRANSACTION_RepeatFileDescriptor, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ICppJavaTests::getDefaultImpl()) [[unlikely]] { return ICppJavaTests::getDefaultImpl()->RepeatFileDescriptor(std::move(read), _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readUniqueFileDescriptor(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpCppJavaTests::ReverseFileDescriptorArray(const ::std::vector<::android::base::unique_fd>& input, ::std::vector<::android::base::unique_fd>* repeated, ::std::vector<::android::base::unique_fd>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICppJavaTests::ReverseFileDescriptorArray::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeUniqueFileDescriptorVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnCppJavaTests::TRANSACTION_ReverseFileDescriptorArray, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ICppJavaTests::getDefaultImpl()) [[unlikely]] { return ICppJavaTests::getDefaultImpl()->ReverseFileDescriptorArray(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readUniqueFileDescriptorVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readUniqueFileDescriptorVector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { BnCppJavaTests::BnCppJavaTests() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t BnCppJavaTests::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnCppJavaTests::TRANSACTION_RepeatBadParcelable: { ::android::aidl::tests::BadParcelable in_input; ::android::aidl::tests::BadParcelable _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICppJavaTests::RepeatBadParcelable::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatBadParcelable(in_input, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnCppJavaTests::TRANSACTION_RepeatGenericParcelable: { ::android::aidl::tests::GenericStructuredParcelable in_input; ::android::aidl::tests::GenericStructuredParcelable out_repeat; ::android::aidl::tests::GenericStructuredParcelable _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICppJavaTests::RepeatGenericParcelable::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatGenericParcelable(in_input, &out_repeat, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(out_repeat); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnCppJavaTests::TRANSACTION_RepeatPersistableBundle: { ::android::os::PersistableBundle in_input; ::android::os::PersistableBundle _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICppJavaTests::RepeatPersistableBundle::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatPersistableBundle(in_input, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnCppJavaTests::TRANSACTION_ReversePersistableBundles: { ::std::vector<::android::os::PersistableBundle> in_input; ::std::vector<::android::os::PersistableBundle> out_repeated; ::std::vector<::android::os::PersistableBundle> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICppJavaTests::ReversePersistableBundles::cppServer"); _aidl_ret_status = _aidl_data.readParcelableVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReversePersistableBundles(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelableVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeParcelableVector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnCppJavaTests::TRANSACTION_ReverseUnion: { ::android::aidl::tests::Union in_input; ::android::aidl::tests::Union out_repeated; ::android::aidl::tests::Union _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICppJavaTests::ReverseUnion::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseUnion(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnCppJavaTests::TRANSACTION_ReverseNamedCallbackList: { ::std::vector<::android::sp<::android::IBinder>> in_input; ::std::vector<::android::sp<::android::IBinder>> out_repeated; ::std::vector<::android::sp<::android::IBinder>> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICppJavaTests::ReverseNamedCallbackList::cppServer"); _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseNamedCallbackList(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnCppJavaTests::TRANSACTION_RepeatFileDescriptor: { ::android::base::unique_fd in_read; ::android::base::unique_fd _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICppJavaTests::RepeatFileDescriptor::cppServer"); _aidl_ret_status = _aidl_data.readUniqueFileDescriptor(&in_read); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatFileDescriptor(std::move(in_read), &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeUniqueFileDescriptor(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnCppJavaTests::TRANSACTION_ReverseFileDescriptorArray: { ::std::vector<::android::base::unique_fd> in_input; ::std::vector<::android::base::unique_fd> out_repeated; ::std::vector<::android::base::unique_fd> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICppJavaTests::ReverseFileDescriptorArray::cppServer"); _aidl_ret_status = _aidl_data.readUniqueFileDescriptorVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseFileDescriptorArray(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeUniqueFileDescriptorVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeUniqueFileDescriptorVector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-cpp-java-test-interface-cpp-source_gen_android_aidl_tests_I0100644 0000000 0000000 00000000214 15172120304 033026 xustar000000000 0000000 112 path=tests/golden_output/aidl-cpp-java-test-interface-cpp-source/gen/android/aidl/tests/ICppJavaTests.cpp.d 28 mtime=1776853188.3820000 tests/golden_output/aidl-cpp-java-test-interface-cpp-source/gen/android/aidl/tests/ICppJavaTests.cpp0100644 0000000 0000000 00000000506 15172120304 032664 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/android/aidl/tests/ICppJavaTests.cpp : \ system/tools/aidl/tests/android/aidl/tests/ICppJavaTests.aidl \ system/tools/aidl/tests/android/aidl/tests/BadParcelable.aidl \ frameworks/native/aidl/binder/android/os/PersistableBundle.aidl ./PaxHeaders.X/tests_golden_output_aidl-cpp-java-test-interface-cpp-source_gen_include_0100644 0000000 0000000 00000000034 15172120304 030505 xustar000000000 0000000 28 mtime=1776853188.3820000 tests/golden_output/aidl-cpp-java-test-interface-cpp-source/gen/include/0040755 0000000 0000000 00000000000 15172120304 025432 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-cpp-java-test-interface-cpp-source_gen_include_android_0100644 0000000 0000000 00000000034 15172120304 032205 xustar000000000 0000000 28 mtime=1776853188.3820000 tests/golden_output/aidl-cpp-java-test-interface-cpp-source/gen/include/android/0040755 0000000 0000000 00000000000 15172120304 027052 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-cpp-java-test-interface-cpp-source_gen_include_android_aidl0100644 0000000 0000000 00000000034 15172120304 033037 xustar000000000 0000000 28 mtime=1776853188.3820000 tests/golden_output/aidl-cpp-java-test-interface-cpp-source/gen/include/android/aidl/0040755 0000000 0000000 00000000000 15172120304 027763 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-cpp-java-test-interface-cpp-source_gen_include_android_aidl0100644 0000000 0000000 00000000034 15172120304 033037 xustar000000000 0000000 28 mtime=1776853188.3820000 tests/golden_output/aidl-cpp-java-test-interface-cpp-source/gen/include/android/aidl/tests/0040755 0000000 0000000 00000000000 15172120304 031125 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-cpp-java-test-interface-cpp-source_gen_include_android_aidl0100644 0000000 0000000 00000000220 15172120304 033034 xustar000000000 0000000 116 path=tests/golden_output/aidl-cpp-java-test-interface-cpp-source/gen/include/android/aidl/tests/BadParcelable.h 28 mtime=1776853188.3820000 tests/golden_output/aidl-cpp-java-test-interface-cpp-source/gen/include/android/aidl/tests/BadParcel0100644 0000000 0000000 00000001437 15172120304 032667 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -t --min_sdk_version current -pout/soong/.intermediates/system/tools/aidl/aidl-test-interface_interface/preprocessed.aidl --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/staging/android/aidl/tests/BadParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/staging -Iframeworks/native/aidl/binder -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/BadParcelable.aidl */ #error TODO(b/111362593) parcelables do not have headers./PaxHeaders.X/tests_golden_output_aidl-cpp-java-test-interface-cpp-source_gen_include_android_aidl0100644 0000000 0000000 00000000222 15172120304 033036 xustar000000000 0000000 118 path=tests/golden_output/aidl-cpp-java-test-interface-cpp-source/gen/include/android/aidl/tests/BnBadParcelable.h 28 mtime=1776853188.3820000 tests/golden_output/aidl-cpp-java-test-interface-cpp-source/gen/include/android/aidl/tests/BnBadParc0100644 0000000 0000000 00000001442 15172120304 032622 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -t --min_sdk_version current -pout/soong/.intermediates/system/tools/aidl/aidl-test-interface_interface/preprocessed.aidl --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/staging/android/aidl/tests/BadParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/staging -Iframeworks/native/aidl/binder -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/BadParcelable.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_aidl-cpp-java-test-interface-cpp-source_gen_include_android_aidl0100644 0000000 0000000 00000000221 15172120304 033035 xustar000000000 0000000 117 path=tests/golden_output/aidl-cpp-java-test-interface-cpp-source/gen/include/android/aidl/tests/BnCppJavaTests.h 28 mtime=1776853188.3820000 tests/golden_output/aidl-cpp-java-test-interface-cpp-source/gen/include/android/aidl/tests/BnCppJava0100644 0000000 0000000 00000011761 15172120304 032657 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -t --min_sdk_version current -pout/soong/.intermediates/system/tools/aidl/aidl-test-interface_interface/preprocessed.aidl --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/staging/android/aidl/tests/ICppJavaTests.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/staging -Iframeworks/native/aidl/binder -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ICppJavaTests.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { class BnCppJavaTests : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_RepeatBadParcelable = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_RepeatGenericParcelable = ::android::IBinder::FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_RepeatPersistableBundle = ::android::IBinder::FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_ReversePersistableBundles = ::android::IBinder::FIRST_CALL_TRANSACTION + 3; static constexpr uint32_t TRANSACTION_ReverseUnion = ::android::IBinder::FIRST_CALL_TRANSACTION + 4; static constexpr uint32_t TRANSACTION_ReverseNamedCallbackList = ::android::IBinder::FIRST_CALL_TRANSACTION + 5; static constexpr uint32_t TRANSACTION_RepeatFileDescriptor = ::android::IBinder::FIRST_CALL_TRANSACTION + 6; static constexpr uint32_t TRANSACTION_ReverseFileDescriptorArray = ::android::IBinder::FIRST_CALL_TRANSACTION + 7; explicit BnCppJavaTests(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnCppJavaTests class ICppJavaTestsDelegator : public BnCppJavaTests { public: explicit ICppJavaTestsDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status RepeatBadParcelable(const ::android::aidl::tests::BadParcelable& input, ::android::aidl::tests::BadParcelable* _aidl_return) override { return _aidl_delegate->RepeatBadParcelable(input, _aidl_return); } ::android::binder::Status RepeatGenericParcelable(const ::android::aidl::tests::GenericStructuredParcelable& input, ::android::aidl::tests::GenericStructuredParcelable* repeat, ::android::aidl::tests::GenericStructuredParcelable* _aidl_return) override { return _aidl_delegate->RepeatGenericParcelable(input, repeat, _aidl_return); } ::android::binder::Status RepeatPersistableBundle(const ::android::os::PersistableBundle& input, ::android::os::PersistableBundle* _aidl_return) override { return _aidl_delegate->RepeatPersistableBundle(input, _aidl_return); } ::android::binder::Status ReversePersistableBundles(const ::std::vector<::android::os::PersistableBundle>& input, ::std::vector<::android::os::PersistableBundle>* repeated, ::std::vector<::android::os::PersistableBundle>* _aidl_return) override { return _aidl_delegate->ReversePersistableBundles(input, repeated, _aidl_return); } ::android::binder::Status ReverseUnion(const ::android::aidl::tests::Union& input, ::android::aidl::tests::Union* repeated, ::android::aidl::tests::Union* _aidl_return) override { return _aidl_delegate->ReverseUnion(input, repeated, _aidl_return); } ::android::binder::Status ReverseNamedCallbackList(const ::std::vector<::android::sp<::android::IBinder>>& input, ::std::vector<::android::sp<::android::IBinder>>* repeated, ::std::vector<::android::sp<::android::IBinder>>* _aidl_return) override { return _aidl_delegate->ReverseNamedCallbackList(input, repeated, _aidl_return); } ::android::binder::Status RepeatFileDescriptor(::android::base::unique_fd read, ::android::base::unique_fd* _aidl_return) override { return _aidl_delegate->RepeatFileDescriptor(std::move(read), _aidl_return); } ::android::binder::Status ReverseFileDescriptorArray(const ::std::vector<::android::base::unique_fd>& input, ::std::vector<::android::base::unique_fd>* repeated, ::std::vector<::android::base::unique_fd>* _aidl_return) override { return _aidl_delegate->ReverseFileDescriptorArray(input, repeated, _aidl_return); } private: ::android::sp _aidl_delegate; }; // class ICppJavaTestsDelegator } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-cpp-java-test-interface-cpp-source_gen_include_android_aidl0100644 0000000 0000000 00000000222 15172120304 033036 xustar000000000 0000000 118 path=tests/golden_output/aidl-cpp-java-test-interface-cpp-source/gen/include/android/aidl/tests/BpBadParcelable.h 28 mtime=1776853188.3820000 tests/golden_output/aidl-cpp-java-test-interface-cpp-source/gen/include/android/aidl/tests/BpBadParc0100644 0000000 0000000 00000001442 15172120304 032624 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -t --min_sdk_version current -pout/soong/.intermediates/system/tools/aidl/aidl-test-interface_interface/preprocessed.aidl --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/staging/android/aidl/tests/BadParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/staging -Iframeworks/native/aidl/binder -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/BadParcelable.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_aidl-cpp-java-test-interface-cpp-source_gen_include_android_aidl0100644 0000000 0000000 00000000221 15172120304 033035 xustar000000000 0000000 117 path=tests/golden_output/aidl-cpp-java-test-interface-cpp-source/gen/include/android/aidl/tests/BpCppJavaTests.h 28 mtime=1776853188.3820000 tests/golden_output/aidl-cpp-java-test-interface-cpp-source/gen/include/android/aidl/tests/BpCppJava0100644 0000000 0000000 00000006060 15172120304 032655 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -t --min_sdk_version current -pout/soong/.intermediates/system/tools/aidl/aidl-test-interface_interface/preprocessed.aidl --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/staging/android/aidl/tests/ICppJavaTests.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/staging -Iframeworks/native/aidl/binder -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ICppJavaTests.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { class BpCppJavaTests : public ::android::BpInterface { public: explicit BpCppJavaTests(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpCppJavaTests() = default; ::android::binder::Status RepeatBadParcelable(const ::android::aidl::tests::BadParcelable& input, ::android::aidl::tests::BadParcelable* _aidl_return) override; ::android::binder::Status RepeatGenericParcelable(const ::android::aidl::tests::GenericStructuredParcelable& input, ::android::aidl::tests::GenericStructuredParcelable* repeat, ::android::aidl::tests::GenericStructuredParcelable* _aidl_return) override; ::android::binder::Status RepeatPersistableBundle(const ::android::os::PersistableBundle& input, ::android::os::PersistableBundle* _aidl_return) override; ::android::binder::Status ReversePersistableBundles(const ::std::vector<::android::os::PersistableBundle>& input, ::std::vector<::android::os::PersistableBundle>* repeated, ::std::vector<::android::os::PersistableBundle>* _aidl_return) override; ::android::binder::Status ReverseUnion(const ::android::aidl::tests::Union& input, ::android::aidl::tests::Union* repeated, ::android::aidl::tests::Union* _aidl_return) override; ::android::binder::Status ReverseNamedCallbackList(const ::std::vector<::android::sp<::android::IBinder>>& input, ::std::vector<::android::sp<::android::IBinder>>* repeated, ::std::vector<::android::sp<::android::IBinder>>* _aidl_return) override; ::android::binder::Status RepeatFileDescriptor(::android::base::unique_fd read, ::android::base::unique_fd* _aidl_return) override; ::android::binder::Status ReverseFileDescriptorArray(const ::std::vector<::android::base::unique_fd>& input, ::std::vector<::android::base::unique_fd>* repeated, ::std::vector<::android::base::unique_fd>* _aidl_return) override; }; // class BpCppJavaTests } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-cpp-java-test-interface-cpp-source_gen_include_android_aidl0100644 0000000 0000000 00000000220 15172120304 033034 xustar000000000 0000000 116 path=tests/golden_output/aidl-cpp-java-test-interface-cpp-source/gen/include/android/aidl/tests/ICppJavaTests.h 28 mtime=1776853188.3820000 tests/golden_output/aidl-cpp-java-test-interface-cpp-source/gen/include/android/aidl/tests/ICppJavaT0100644 0000000 0000000 00000014536 15172120304 032637 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -t --min_sdk_version current -pout/soong/.intermediates/system/tools/aidl/aidl-test-interface_interface/preprocessed.aidl --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/staging/android/aidl/tests/ICppJavaTests.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/staging -Iframeworks/native/aidl/binder -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ICppJavaTests.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace android::aidl::tests { template class GenericStructuredParcelable; class StructuredParcelable; } // namespace android::aidl::tests namespace android { namespace aidl { namespace tests { class ICppJavaTestsDelegator; class ICppJavaTests : public ::android::IInterface { public: typedef ICppJavaTestsDelegator DefaultDelegator; DECLARE_META_INTERFACE(CppJavaTests) virtual ::android::binder::Status RepeatBadParcelable(const ::android::aidl::tests::BadParcelable& input, ::android::aidl::tests::BadParcelable* _aidl_return) = 0; virtual ::android::binder::Status RepeatGenericParcelable(const ::android::aidl::tests::GenericStructuredParcelable& input, ::android::aidl::tests::GenericStructuredParcelable* repeat, ::android::aidl::tests::GenericStructuredParcelable* _aidl_return) = 0; virtual ::android::binder::Status RepeatPersistableBundle(const ::android::os::PersistableBundle& input, ::android::os::PersistableBundle* _aidl_return) = 0; virtual ::android::binder::Status ReversePersistableBundles(const ::std::vector<::android::os::PersistableBundle>& input, ::std::vector<::android::os::PersistableBundle>* repeated, ::std::vector<::android::os::PersistableBundle>* _aidl_return) = 0; virtual ::android::binder::Status ReverseUnion(const ::android::aidl::tests::Union& input, ::android::aidl::tests::Union* repeated, ::android::aidl::tests::Union* _aidl_return) = 0; virtual ::android::binder::Status ReverseNamedCallbackList(const ::std::vector<::android::sp<::android::IBinder>>& input, ::std::vector<::android::sp<::android::IBinder>>* repeated, ::std::vector<::android::sp<::android::IBinder>>* _aidl_return) = 0; virtual ::android::binder::Status RepeatFileDescriptor(::android::base::unique_fd read, ::android::base::unique_fd* _aidl_return) = 0; virtual ::android::binder::Status ReverseFileDescriptorArray(const ::std::vector<::android::base::unique_fd>& input, ::std::vector<::android::base::unique_fd>* repeated, ::std::vector<::android::base::unique_fd>* _aidl_return) = 0; }; // class ICppJavaTests class ICppJavaTestsDefault : public ICppJavaTests { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status RepeatBadParcelable(const ::android::aidl::tests::BadParcelable& /*input*/, ::android::aidl::tests::BadParcelable* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatGenericParcelable(const ::android::aidl::tests::GenericStructuredParcelable& /*input*/, ::android::aidl::tests::GenericStructuredParcelable* /*repeat*/, ::android::aidl::tests::GenericStructuredParcelable* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatPersistableBundle(const ::android::os::PersistableBundle& /*input*/, ::android::os::PersistableBundle* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReversePersistableBundles(const ::std::vector<::android::os::PersistableBundle>& /*input*/, ::std::vector<::android::os::PersistableBundle>* /*repeated*/, ::std::vector<::android::os::PersistableBundle>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseUnion(const ::android::aidl::tests::Union& /*input*/, ::android::aidl::tests::Union* /*repeated*/, ::android::aidl::tests::Union* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseNamedCallbackList(const ::std::vector<::android::sp<::android::IBinder>>& /*input*/, ::std::vector<::android::sp<::android::IBinder>>* /*repeated*/, ::std::vector<::android::sp<::android::IBinder>>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatFileDescriptor(::android::base::unique_fd /*read*/, ::android::base::unique_fd* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseFileDescriptorArray(const ::std::vector<::android::base::unique_fd>& /*input*/, ::std::vector<::android::base::unique_fd>* /*repeated*/, ::std::vector<::android::base::unique_fd>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } }; // class ICppJavaTestsDefault } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-cpp-java-test-interface-cpp-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 030726 xustar000000000 0000000 28 mtime=1776853188.3830000 tests/golden_output/aidl-cpp-java-test-interface-cpp-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 025720 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-cpp-java-test-interface-java-source_0100644 0000000 0000000 00000000034 15172120304 026310 xustar000000000 0000000 28 mtime=1776853188.3830000 tests/golden_output/aidl-cpp-java-test-interface-java-source/0040755 0000000 0000000 00000000000 15172120304 023375 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-cpp-java-test-interface-java-source_gen_0100644 0000000 0000000 00000000034 15172120304 027141 xustar000000000 0000000 28 mtime=1776853188.3830000 tests/golden_output/aidl-cpp-java-test-interface-java-source/gen/0040755 0000000 0000000 00000000000 15172120304 024146 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-cpp-java-test-interface-java-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 030641 xustar000000000 0000000 28 mtime=1776853188.3830000 tests/golden_output/aidl-cpp-java-test-interface-java-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 025566 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-cpp-java-test-interface-java-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 031632 xustar000000000 0000000 28 mtime=1776853188.3830000 tests/golden_output/aidl-cpp-java-test-interface-java-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 026477 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-cpp-java-test-interface-java-source_gen_android_aidl_tests_0100644 0000000 0000000 00000000034 15172120304 033054 xustar000000000 0000000 28 mtime=1776853188.3830000 tests/golden_output/aidl-cpp-java-test-interface-java-source/gen/android/aidl/tests/0040755 0000000 0000000 00000000000 15172120304 027641 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-cpp-java-test-interface-java-source_gen_android_aidl_tests_0100644 0000000 0000000 00000000214 15172120304 033054 xustar000000000 0000000 112 path=tests/golden_output/aidl-cpp-java-test-interface-java-source/gen/android/aidl/tests/BadParcelable.java 28 mtime=1776853188.3830000 tests/golden_output/aidl-cpp-java-test-interface-java-source/gen/android/aidl/tests/BadParcelable.ja0100644 0000000 0000000 00000000000 15172120304 032601 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-cpp-java-test-interface-java-source_gen_android_aidl_tests_0100644 0000000 0000000 00000000216 15172120304 033056 xustar000000000 0000000 114 path=tests/golden_output/aidl-cpp-java-test-interface-java-source/gen/android/aidl/tests/BadParcelable.java.d 28 mtime=1776853188.3830000 tests/golden_output/aidl-cpp-java-test-interface-java-source/gen/android/aidl/tests/BadParcelable.ja0100644 0000000 0000000 00000000105 15172120304 032607 0ustar000000000 0000000 : \ system/tools/aidl/tests/android/aidl/tests/BadParcelable.aidl ./PaxHeaders.X/tests_golden_output_aidl-cpp-java-test-interface-java-source_gen_android_aidl_tests_0100644 0000000 0000000 00000000214 15172120304 033054 xustar000000000 0000000 112 path=tests/golden_output/aidl-cpp-java-test-interface-java-source/gen/android/aidl/tests/ICppJavaTests.java 28 mtime=1776853188.3830000 tests/golden_output/aidl-cpp-java-test-interface-java-source/gen/android/aidl/tests/ICppJavaTests.ja0100644 0000000 0000000 00000050663 15172120304 032644 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -t --min_sdk_version platform_apis -pout/soong/.intermediates/system/tools/aidl/aidl-test-interface_interface/preprocessed.aidl --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-java-source/gen/android/aidl/tests/ICppJavaTests.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-java-source/gen -Iframeworks/native/aidl/binder -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ICppJavaTests.aidl */ package android.aidl.tests; // Tests that are only supported by the C++/Java backends, not NDK/Rust public interface ICppJavaTests extends android.os.IInterface { /** Default implementation for ICppJavaTests. */ public static class Default implements android.aidl.tests.ICppJavaTests { @Override public android.aidl.tests.BadParcelable RepeatBadParcelable(android.aidl.tests.BadParcelable input) throws android.os.RemoteException { return null; } @Override public android.aidl.tests.GenericStructuredParcelable RepeatGenericParcelable(android.aidl.tests.GenericStructuredParcelable input, android.aidl.tests.GenericStructuredParcelable repeat) throws android.os.RemoteException { return null; } @Override public android.os.PersistableBundle RepeatPersistableBundle(android.os.PersistableBundle input) throws android.os.RemoteException { return null; } @Override public android.os.PersistableBundle[] ReversePersistableBundles(android.os.PersistableBundle[] input, android.os.PersistableBundle[] repeated) throws android.os.RemoteException { return null; } @Override public android.aidl.tests.Union ReverseUnion(android.aidl.tests.Union input, android.aidl.tests.Union repeated) throws android.os.RemoteException { return null; } // Test that List types work correctly. @Override public java.util.List ReverseNamedCallbackList(java.util.List input, java.util.List repeated) throws android.os.RemoteException { return null; } @Override public java.io.FileDescriptor RepeatFileDescriptor(java.io.FileDescriptor read) throws android.os.RemoteException { return null; } @Override public java.io.FileDescriptor[] ReverseFileDescriptorArray(java.io.FileDescriptor[] input, java.io.FileDescriptor[] repeated) throws android.os.RemoteException { return null; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.ICppJavaTests { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.ICppJavaTests interface, * generating a proxy if needed. */ public static android.aidl.tests.ICppJavaTests asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.ICppJavaTests))) { return ((android.aidl.tests.ICppJavaTests)iin); } return new android.aidl.tests.ICppJavaTests.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_RepeatBadParcelable: { return "RepeatBadParcelable"; } case TRANSACTION_RepeatGenericParcelable: { return "RepeatGenericParcelable"; } case TRANSACTION_RepeatPersistableBundle: { return "RepeatPersistableBundle"; } case TRANSACTION_ReversePersistableBundles: { return "ReversePersistableBundles"; } case TRANSACTION_ReverseUnion: { return "ReverseUnion"; } case TRANSACTION_ReverseNamedCallbackList: { return "ReverseNamedCallbackList"; } case TRANSACTION_RepeatFileDescriptor: { return "RepeatFileDescriptor"; } case TRANSACTION_ReverseFileDescriptorArray: { return "ReverseFileDescriptorArray"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_RepeatBadParcelable: { android.aidl.tests.BadParcelable _arg0; _arg0 = data.readTypedObject(android.aidl.tests.BadParcelable.CREATOR); data.enforceNoDataAvail(); android.aidl.tests.BadParcelable _result = this.RepeatBadParcelable(_arg0); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_RepeatGenericParcelable: { android.aidl.tests.GenericStructuredParcelable _arg0; _arg0 = data.readTypedObject(android.aidl.tests.GenericStructuredParcelable.CREATOR); android.aidl.tests.GenericStructuredParcelable _arg1; _arg1 = new android.aidl.tests.GenericStructuredParcelable(); data.enforceNoDataAvail(); android.aidl.tests.GenericStructuredParcelable _result = this.RepeatGenericParcelable(_arg0, _arg1); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); reply.writeTypedObject(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_RepeatPersistableBundle: { android.os.PersistableBundle _arg0; _arg0 = data.readTypedObject(android.os.PersistableBundle.CREATOR); data.enforceNoDataAvail(); android.os.PersistableBundle _result = this.RepeatPersistableBundle(_arg0); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_ReversePersistableBundles: { android.os.PersistableBundle[] _arg0; _arg0 = data.createTypedArray(android.os.PersistableBundle.CREATOR); android.os.PersistableBundle[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new android.os.PersistableBundle[_arg1_length]; } data.enforceNoDataAvail(); android.os.PersistableBundle[] _result = this.ReversePersistableBundles(_arg0, _arg1); reply.writeNoException(); reply.writeTypedArray(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); reply.writeTypedArray(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_ReverseUnion: { android.aidl.tests.Union _arg0; _arg0 = data.readTypedObject(android.aidl.tests.Union.CREATOR); android.aidl.tests.Union _arg1; _arg1 = new android.aidl.tests.Union(); data.enforceNoDataAvail(); android.aidl.tests.Union _result = this.ReverseUnion(_arg0, _arg1); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); reply.writeTypedObject(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_ReverseNamedCallbackList: { java.util.List _arg0; _arg0 = data.createBinderArrayList(); java.util.List _arg1; _arg1 = new java.util.ArrayList(); data.enforceNoDataAvail(); java.util.List _result = this.ReverseNamedCallbackList(_arg0, _arg1); reply.writeNoException(); reply.writeBinderList(_result); reply.writeBinderList(_arg1); break; } case TRANSACTION_RepeatFileDescriptor: { java.io.FileDescriptor _arg0; _arg0 = data.readRawFileDescriptor(); data.enforceNoDataAvail(); java.io.FileDescriptor _result = this.RepeatFileDescriptor(_arg0); reply.writeNoException(); reply.writeRawFileDescriptor(_result); break; } case TRANSACTION_ReverseFileDescriptorArray: { java.io.FileDescriptor[] _arg0; _arg0 = data.createRawFileDescriptorArray(); java.io.FileDescriptor[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new java.io.FileDescriptor[_arg1_length]; } data.enforceNoDataAvail(); java.io.FileDescriptor[] _result = this.ReverseFileDescriptorArray(_arg0, _arg1); reply.writeNoException(); reply.writeRawFileDescriptorArray(_result); reply.writeRawFileDescriptorArray(_arg1); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.ICppJavaTests { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public android.aidl.tests.BadParcelable RepeatBadParcelable(android.aidl.tests.BadParcelable input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.BadParcelable _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatBadParcelable, _data, _reply, 0); _reply.readException(); _result = _reply.readTypedObject(android.aidl.tests.BadParcelable.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.tests.GenericStructuredParcelable RepeatGenericParcelable(android.aidl.tests.GenericStructuredParcelable input, android.aidl.tests.GenericStructuredParcelable repeat) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.GenericStructuredParcelable _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatGenericParcelable, _data, _reply, 0); _reply.readException(); _result = _reply.readTypedObject(android.aidl.tests.GenericStructuredParcelable.CREATOR); if ((0!=_reply.readInt())) { repeat.readFromParcel(_reply); } } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.os.PersistableBundle RepeatPersistableBundle(android.os.PersistableBundle input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.os.PersistableBundle _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatPersistableBundle, _data, _reply, 0); _reply.readException(); _result = _reply.readTypedObject(android.os.PersistableBundle.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.os.PersistableBundle[] ReversePersistableBundles(android.os.PersistableBundle[] input, android.os.PersistableBundle[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.os.PersistableBundle[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedArray(input, 0); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReversePersistableBundles, _data, _reply, 0); _reply.readException(); _result = _reply.createTypedArray(android.os.PersistableBundle.CREATOR); _reply.readTypedArray(repeated, android.os.PersistableBundle.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.tests.Union ReverseUnion(android.aidl.tests.Union input, android.aidl.tests.Union repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.Union _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseUnion, _data, _reply, 0); _reply.readException(); _result = _reply.readTypedObject(android.aidl.tests.Union.CREATOR); if ((0!=_reply.readInt())) { repeated.readFromParcel(_reply); } } finally { _reply.recycle(); _data.recycle(); } return _result; } // Test that List types work correctly. @Override public java.util.List ReverseNamedCallbackList(java.util.List input, java.util.List repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.util.List _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeBinderList(input); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseNamedCallbackList, _data, _reply, 0); _reply.readException(); _result = _reply.createBinderArrayList(); _reply.readBinderList(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.io.FileDescriptor RepeatFileDescriptor(java.io.FileDescriptor read) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.io.FileDescriptor _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeRawFileDescriptor(read); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatFileDescriptor, _data, _reply, 0); _reply.readException(); _result = _reply.readRawFileDescriptor(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.io.FileDescriptor[] ReverseFileDescriptorArray(java.io.FileDescriptor[] input, java.io.FileDescriptor[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.io.FileDescriptor[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeRawFileDescriptorArray(input); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseFileDescriptorArray, _data, _reply, 0); _reply.readException(); _result = _reply.createRawFileDescriptorArray(); _reply.readRawFileDescriptorArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } } static final int TRANSACTION_RepeatBadParcelable = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); static final int TRANSACTION_RepeatGenericParcelable = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1); static final int TRANSACTION_RepeatPersistableBundle = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2); static final int TRANSACTION_ReversePersistableBundles = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3); static final int TRANSACTION_ReverseUnion = (android.os.IBinder.FIRST_CALL_TRANSACTION + 4); static final int TRANSACTION_ReverseNamedCallbackList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 5); static final int TRANSACTION_RepeatFileDescriptor = (android.os.IBinder.FIRST_CALL_TRANSACTION + 6); static final int TRANSACTION_ReverseFileDescriptorArray = (android.os.IBinder.FIRST_CALL_TRANSACTION + 7); /** @hide */ public int getMaxTransactionId() { return 7; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.ICppJavaTests"; public android.aidl.tests.BadParcelable RepeatBadParcelable(android.aidl.tests.BadParcelable input) throws android.os.RemoteException; public android.aidl.tests.GenericStructuredParcelable RepeatGenericParcelable(android.aidl.tests.GenericStructuredParcelable input, android.aidl.tests.GenericStructuredParcelable repeat) throws android.os.RemoteException; public android.os.PersistableBundle RepeatPersistableBundle(android.os.PersistableBundle input) throws android.os.RemoteException; public android.os.PersistableBundle[] ReversePersistableBundles(android.os.PersistableBundle[] input, android.os.PersistableBundle[] repeated) throws android.os.RemoteException; public android.aidl.tests.Union ReverseUnion(android.aidl.tests.Union input, android.aidl.tests.Union repeated) throws android.os.RemoteException; // Test that List types work correctly. public java.util.List ReverseNamedCallbackList(java.util.List input, java.util.List repeated) throws android.os.RemoteException; public java.io.FileDescriptor RepeatFileDescriptor(java.io.FileDescriptor read) throws android.os.RemoteException; public java.io.FileDescriptor[] ReverseFileDescriptorArray(java.io.FileDescriptor[] input, java.io.FileDescriptor[] repeated) throws android.os.RemoteException; } ./PaxHeaders.X/tests_golden_output_aidl-cpp-java-test-interface-java-source_gen_android_aidl_tests_0100644 0000000 0000000 00000000216 15172120304 033056 xustar000000000 0000000 114 path=tests/golden_output/aidl-cpp-java-test-interface-java-source/gen/android/aidl/tests/ICppJavaTests.java.d 28 mtime=1776853188.3830000 tests/golden_output/aidl-cpp-java-test-interface-java-source/gen/android/aidl/tests/ICppJavaTests.ja0100644 0000000 0000000 00000000510 15172120304 032626 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-java-source/gen/android/aidl/tests/ICppJavaTests.java : \ system/tools/aidl/tests/android/aidl/tests/ICppJavaTests.aidl \ system/tools/aidl/tests/android/aidl/tests/BadParcelable.aidl \ frameworks/native/aidl/binder/android/os/PersistableBundle.aidl ./PaxHeaders.X/tests_golden_output_aidl-cpp-java-test-interface-java-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 031065 xustar000000000 0000000 28 mtime=1776853188.3830000 tests/golden_output/aidl-cpp-java-test-interface-java-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 026057 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-extras-java-source_0100644 0000000 0000000 00000000034 15172120304 024157 xustar000000000 0000000 28 mtime=1776853188.3830000 tests/golden_output/aidl-test-extras-java-source/0040755 0000000 0000000 00000000000 15172120304 021244 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-extras-java-source_gen_0100644 0000000 0000000 00000000034 15172120304 025010 xustar000000000 0000000 28 mtime=1776853188.3830000 tests/golden_output/aidl-test-extras-java-source/gen/0040755 0000000 0000000 00000000000 15172120304 022015 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-extras-java-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 026510 xustar000000000 0000000 28 mtime=1776853188.3830000 tests/golden_output/aidl-test-extras-java-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 023435 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-extras-java-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 027501 xustar000000000 0000000 28 mtime=1776853188.3830000 tests/golden_output/aidl-test-extras-java-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 024346 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-extras-java-source_gen_android_aidl_tests_0100644 0000000 0000000 00000000034 15172120304 030723 xustar000000000 0000000 28 mtime=1776853188.3830000 tests/golden_output/aidl-test-extras-java-source/gen/android/aidl/tests/0040755 0000000 0000000 00000000000 15172120304 025510 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-extras-java-source_gen_android_aidl_tests_generic_0100644 0000000 0000000 00000000034 15172120304 032417 xustar000000000 0000000 28 mtime=1776853188.3830000 tests/golden_output/aidl-test-extras-java-source/gen/android/aidl/tests/generic/0040755 0000000 0000000 00000000000 15172120304 027124 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-extras-java-source_gen_android_aidl_tests_generic_Baz.0100644 0000000 0000000 00000000034 15172120304 033132 xustar000000000 0000000 28 mtime=1776853188.3830000 tests/golden_output/aidl-test-extras-java-source/gen/android/aidl/tests/generic/Baz.java0100644 0000000 0000000 00000004245 15172120304 030505 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/generic/Baz.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/generic/Baz.aidl */ package android.aidl.tests.generic; public class Baz implements android.os.Parcelable { public int a = 0; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public Baz createFromParcel(android.os.Parcel _aidl_source) { Baz _aidl_out = new Baz(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public Baz[] newArray(int _aidl_size) { return new Baz[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(a); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; a = _aidl_parcel.readInt(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } } ./PaxHeaders.X/tests_golden_output_aidl-test-extras-java-source_gen_android_aidl_tests_generic_Baz.0100644 0000000 0000000 00000000034 15172120304 033132 xustar000000000 0000000 28 mtime=1776853188.3830000 tests/golden_output/aidl-test-extras-java-source/gen/android/aidl/tests/generic/Baz.java.d0100644 0000000 0000000 00000000262 15172120304 030722 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/generic/Baz.java : \ system/tools/aidl/tests/android/aidl/tests/generic/Baz.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-extras-java-source_gen_android_aidl_tests_generic_IFaz0100644 0000000 0000000 00000000034 15172120304 033171 xustar000000000 0000000 28 mtime=1776853188.3840000 tests/golden_output/aidl-test-extras-java-source/gen/android/aidl/tests/generic/IFaz.java0100644 0000000 0000000 00000017420 15172120304 030621 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/generic/IFaz.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/generic/IFaz.aidl */ package android.aidl.tests.generic; public interface IFaz extends android.os.IInterface { /** Default implementation for IFaz. */ public static class Default implements android.aidl.tests.generic.IFaz { @Override public android.aidl.tests.generic.Pair getPair() throws android.os.RemoteException { return null; } @Override public android.aidl.tests.generic.Pair getPair2() throws android.os.RemoteException { return null; } @Override public android.aidl.tests.generic.Pair getPair3() throws android.os.RemoteException { return null; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.generic.IFaz { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.generic.IFaz interface, * generating a proxy if needed. */ public static android.aidl.tests.generic.IFaz asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.generic.IFaz))) { return ((android.aidl.tests.generic.IFaz)iin); } return new android.aidl.tests.generic.IFaz.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_getPair: { return "getPair"; } case TRANSACTION_getPair2: { return "getPair2"; } case TRANSACTION_getPair3: { return "getPair3"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_getPair: { android.aidl.tests.generic.Pair _result = this.getPair(); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_getPair2: { android.aidl.tests.generic.Pair _result = this.getPair2(); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_getPair3: { android.aidl.tests.generic.Pair _result = this.getPair3(); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.generic.IFaz { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public android.aidl.tests.generic.Pair getPair() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.generic.Pair _result; try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getPair, _data, _reply, 0); _reply.readException(); _result = _reply.readTypedObject(android.aidl.tests.generic.Pair.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.tests.generic.Pair getPair2() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.generic.Pair _result; try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getPair2, _data, _reply, 0); _reply.readException(); _result = _reply.readTypedObject(android.aidl.tests.generic.Pair.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.tests.generic.Pair getPair3() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.generic.Pair _result; try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getPair3, _data, _reply, 0); _reply.readException(); _result = _reply.readTypedObject(android.aidl.tests.generic.Pair.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } } static final int TRANSACTION_getPair = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); static final int TRANSACTION_getPair2 = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1); static final int TRANSACTION_getPair3 = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2); /** @hide */ public int getMaxTransactionId() { return 2; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.generic.IFaz"; public android.aidl.tests.generic.Pair getPair() throws android.os.RemoteException; public android.aidl.tests.generic.Pair getPair2() throws android.os.RemoteException; public android.aidl.tests.generic.Pair getPair3() throws android.os.RemoteException; } ./PaxHeaders.X/tests_golden_output_aidl-test-extras-java-source_gen_android_aidl_tests_generic_IFaz0100644 0000000 0000000 00000000034 15172120304 033171 xustar000000000 0000000 28 mtime=1776853188.3840000 tests/golden_output/aidl-test-extras-java-source/gen/android/aidl/tests/generic/IFaz.java.d0100644 0000000 0000000 00000000561 15172120304 031041 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/generic/IFaz.java : \ system/tools/aidl/tests/android/aidl/tests/generic/IFaz.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/generic/Baz.aidl \ system/tools/aidl/tests/android/aidl/tests/generic/Pair.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-extras-java-source_gen_android_aidl_tests_generic_Pair0100644 0000000 0000000 00000000034 15172120304 033233 xustar000000000 0000000 28 mtime=1776853188.3840000 tests/golden_output/aidl-test-extras-java-source/gen/android/aidl/tests/generic/Pair.java0100644 0000000 0000000 00000000000 15172120304 030645 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-extras-java-source_gen_android_aidl_tests_generic_Pair0100644 0000000 0000000 00000000034 15172120304 033233 xustar000000000 0000000 28 mtime=1776853188.3840000 tests/golden_output/aidl-test-extras-java-source/gen/android/aidl/tests/generic/Pair.java.d0100644 0000000 0000000 00000000104 15172120304 031074 0ustar000000000 0000000 : \ system/tools/aidl/tests/android/aidl/tests/generic/Pair.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-extras-java-source_gen_android_aidl_tests_immutable_0100644 0000000 0000000 00000000034 15172120304 032762 xustar000000000 0000000 28 mtime=1776853188.3840000 tests/golden_output/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/0040755 0000000 0000000 00000000000 15172120304 027467 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-extras-java-source_gen_android_aidl_tests_immutable_Ba0100644 0000000 0000000 00000000034 15172120304 033225 xustar000000000 0000000 28 mtime=1776853188.3840000 tests/golden_output/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/Bar.java0100644 0000000 0000000 00000005373 15172120304 031043 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/Bar.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/immutable/Bar.aidl */ package android.aidl.tests.immutable; public class Bar implements android.os.Parcelable { public final java.lang.String s; public static final class Builder { private java.lang.String s = "bar"; public Builder setS(java.lang.String s) { this.s = s; return this; } public android.aidl.tests.immutable.Bar build() { return new android.aidl.tests.immutable.Bar(s); } } public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public Bar createFromParcel(android.os.Parcel _aidl_source) { return internalCreateFromParcel(_aidl_source); } @Override public Bar[] newArray(int _aidl_size) { return new Bar[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeString(s); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public Bar(java.lang.String s) { this.s = s; } private static Bar internalCreateFromParcel(android.os.Parcel _aidl_parcel) { Builder _aidl_parcelable_builder = new Builder(); int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small"); _aidl_parcelable_builder.build(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return _aidl_parcelable_builder.build(); java.lang.String _aidl_temp_s; _aidl_temp_s = _aidl_parcel.readString(); _aidl_parcelable_builder.setS(_aidl_temp_s); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_parcelable_builder.build(); } } @Override public int describeContents() { int _mask = 0; return _mask; } } ./PaxHeaders.X/tests_golden_output_aidl-test-extras-java-source_gen_android_aidl_tests_immutable_Ba0100644 0000000 0000000 00000000034 15172120304 033225 xustar000000000 0000000 28 mtime=1776853188.3840000 tests/golden_output/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/Bar.java.d0100644 0000000 0000000 00000000266 15172120304 031261 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/Bar.java : \ system/tools/aidl/tests/android/aidl/tests/immutable/Bar.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-extras-java-source_gen_android_aidl_tests_immutable_Fo0100644 0000000 0000000 00000000034 15172120304 033247 xustar000000000 0000000 28 mtime=1776853188.3840000 tests/golden_output/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/Foo.java0100644 0000000 0000000 00000016673 15172120304 031067 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/Foo.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/immutable/Foo.aidl */ package android.aidl.tests.immutable; public class Foo implements android.os.Parcelable { public final int a; public final android.aidl.tests.immutable.Bar b; public final java.util.List c; public final java.util.Map d; public final android.aidl.tests.immutable.Bar[] e; public final android.aidl.tests.immutable.Union u; public static final class Builder { private int a = 10; public Builder setA(int a) { this.a = a; return this; } private android.aidl.tests.immutable.Bar b; public Builder setB(android.aidl.tests.immutable.Bar b) { this.b = b; return this; } private java.util.List c; public Builder setC(java.util.List c) { this.c = c; return this; } private java.util.Map d; public Builder setD(java.util.Map d) { this.d = d; return this; } private android.aidl.tests.immutable.Bar[] e; public Builder setE(android.aidl.tests.immutable.Bar[] e) { this.e = e; return this; } private android.aidl.tests.immutable.Union u; public Builder setU(android.aidl.tests.immutable.Union u) { this.u = u; return this; } public android.aidl.tests.immutable.Foo build() { return new android.aidl.tests.immutable.Foo(a, b, c, d, e, u); } } public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public Foo createFromParcel(android.os.Parcel _aidl_source) { return internalCreateFromParcel(_aidl_source); } @Override public Foo[] newArray(int _aidl_size) { return new Foo[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(a); _aidl_parcel.writeTypedObject(b, _aidl_flag); _aidl_parcel.writeTypedList(c, _aidl_flag); if (d == null) { _aidl_parcel.writeInt(-1); } else { _aidl_parcel.writeInt(d.size()); d.forEach((k, v) -> { _aidl_parcel.writeString(k); _aidl_parcel.writeTypedObject(v, _aidl_flag); }); } _aidl_parcel.writeTypedArray(e, _aidl_flag); _aidl_parcel.writeTypedObject(u, _aidl_flag); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public Foo(int a, android.aidl.tests.immutable.Bar b, java.util.List c, java.util.Map d, android.aidl.tests.immutable.Bar[] e, android.aidl.tests.immutable.Union u) { this.a = a; this.b = b; this.c = c == null ? null : java.util.Collections.unmodifiableList(c); this.d = d == null ? null : java.util.Collections.unmodifiableMap(d); this.e = e; this.u = u; } private static Foo internalCreateFromParcel(android.os.Parcel _aidl_parcel) { Builder _aidl_parcelable_builder = new Builder(); int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small"); _aidl_parcelable_builder.build(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return _aidl_parcelable_builder.build(); int _aidl_temp_a; _aidl_temp_a = _aidl_parcel.readInt(); _aidl_parcelable_builder.setA(_aidl_temp_a); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return _aidl_parcelable_builder.build(); android.aidl.tests.immutable.Bar _aidl_temp_b; _aidl_temp_b = _aidl_parcel.readTypedObject(android.aidl.tests.immutable.Bar.CREATOR); _aidl_parcelable_builder.setB(_aidl_temp_b); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return _aidl_parcelable_builder.build(); java.util.List _aidl_temp_c; _aidl_temp_c = _aidl_parcel.createTypedArrayList(android.aidl.tests.immutable.Bar.CREATOR); _aidl_parcelable_builder.setC(_aidl_temp_c); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return _aidl_parcelable_builder.build(); java.util.Map _aidl_temp_d; { int N = _aidl_parcel.readInt(); _aidl_temp_d = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = _aidl_parcel.readString(); android.aidl.tests.immutable.Bar v; v = _aidl_parcel.readTypedObject(android.aidl.tests.immutable.Bar.CREATOR); _aidl_temp_d.put(k, v); }); } _aidl_parcelable_builder.setD(_aidl_temp_d); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return _aidl_parcelable_builder.build(); android.aidl.tests.immutable.Bar[] _aidl_temp_e; _aidl_temp_e = _aidl_parcel.createTypedArray(android.aidl.tests.immutable.Bar.CREATOR); _aidl_parcelable_builder.setE(_aidl_temp_e); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return _aidl_parcelable_builder.build(); android.aidl.tests.immutable.Union _aidl_temp_u; _aidl_temp_u = _aidl_parcel.readTypedObject(android.aidl.tests.immutable.Union.CREATOR); _aidl_parcelable_builder.setU(_aidl_temp_u); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_parcelable_builder.build(); } } @Override public int describeContents() { int _mask = 0; _mask |= describeContents(b); _mask |= describeContents(c); _mask |= describeContents(d); _mask |= describeContents(e); _mask |= describeContents(u); return _mask; } private int describeContents(Object _v) { if (_v == null) return 0; if (_v instanceof Object[]) { int _mask = 0; for (Object o : (Object[]) _v) { _mask |= describeContents(o); } return _mask; } if (_v instanceof java.util.Collection) { int _mask = 0; for (Object o : (java.util.Collection) _v) { _mask |= describeContents(o); } return _mask; } if (_v instanceof java.util.Map) { return describeContents(((java.util.Map) _v).values()); } if (_v instanceof android.os.Parcelable) { return ((android.os.Parcelable) _v).describeContents(); } return 0; } } ./PaxHeaders.X/tests_golden_output_aidl-test-extras-java-source_gen_android_aidl_tests_immutable_Fo0100644 0000000 0000000 00000000034 15172120304 033247 xustar000000000 0000000 28 mtime=1776853188.3840000 tests/golden_output/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/Foo.java.d0100644 0000000 0000000 00000000474 15172120304 031301 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/Foo.java : \ system/tools/aidl/tests/android/aidl/tests/immutable/Foo.aidl \ system/tools/aidl/tests/android/aidl/tests/immutable/Bar.aidl \ system/tools/aidl/tests/android/aidl/tests/immutable/Union.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-extras-java-source_gen_android_aidl_tests_immutable_IB0100644 0000000 0000000 00000000034 15172120304 033175 xustar000000000 0000000 28 mtime=1776853188.3840000 tests/golden_output/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/IBaz.java0100644 0000000 0000000 00000011722 15172120304 031157 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/IBaz.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/immutable/IBaz.aidl */ package android.aidl.tests.immutable; public interface IBaz extends android.os.IInterface { /** Default implementation for IBaz. */ public static class Default implements android.aidl.tests.immutable.IBaz { @Override public android.aidl.tests.immutable.Foo RepeatFoo(android.aidl.tests.immutable.Foo a) throws android.os.RemoteException { return null; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.immutable.IBaz { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.immutable.IBaz interface, * generating a proxy if needed. */ public static android.aidl.tests.immutable.IBaz asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.immutable.IBaz))) { return ((android.aidl.tests.immutable.IBaz)iin); } return new android.aidl.tests.immutable.IBaz.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_RepeatFoo: { return "RepeatFoo"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_RepeatFoo: { android.aidl.tests.immutable.Foo _arg0; _arg0 = data.readTypedObject(android.aidl.tests.immutable.Foo.CREATOR); data.enforceNoDataAvail(); android.aidl.tests.immutable.Foo _result = this.RepeatFoo(_arg0); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.immutable.IBaz { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public android.aidl.tests.immutable.Foo RepeatFoo(android.aidl.tests.immutable.Foo a) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.immutable.Foo _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(a, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatFoo, _data, _reply, 0); _reply.readException(); _result = _reply.readTypedObject(android.aidl.tests.immutable.Foo.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } } static final int TRANSACTION_RepeatFoo = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.immutable.IBaz"; public android.aidl.tests.immutable.Foo RepeatFoo(android.aidl.tests.immutable.Foo a) throws android.os.RemoteException; } ./PaxHeaders.X/tests_golden_output_aidl-test-extras-java-source_gen_android_aidl_tests_immutable_IB0100644 0000000 0000000 00000000034 15172120304 033175 xustar000000000 0000000 28 mtime=1776853188.3840000 tests/golden_output/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/IBaz.java.d0100644 0000000 0000000 00000000600 15172120304 031372 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/IBaz.java : \ system/tools/aidl/tests/android/aidl/tests/immutable/IBaz.aidl \ system/tools/aidl/tests/android/aidl/tests/immutable/Foo.aidl \ system/tools/aidl/tests/android/aidl/tests/immutable/Bar.aidl \ system/tools/aidl/tests/android/aidl/tests/immutable/Union.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-extras-java-source_gen_android_aidl_tests_immutable_Un0100644 0000000 0000000 00000000034 15172120304 033265 xustar000000000 0000000 28 mtime=1776853188.3840000 tests/golden_output/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/Union.java0100644 0000000 0000000 00000010203 15172120304 031413 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/Union.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/immutable/Union.aidl */ package android.aidl.tests.immutable; public final class Union implements android.os.Parcelable { // tags for union fields public final static int num = 0; // int num; public final static int str = 1; // String[] str; public final static int bar = 2; // android.aidl.tests.immutable.Bar bar; private final int _tag; private final Object _value; public Union() { int _value = 0; this._tag = num; this._value = _value; } private Union(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public int getTag() { return _tag; } // int num; public static Union num(int _value) { return new Union(num, _value); } public int getNum() { _assertTag(num); return (int) _value; } // String[] str; public static Union str(java.lang.String[] _value) { return new Union(str, _value); } public java.lang.String[] getStr() { _assertTag(str); return (java.lang.String[]) _value; } // android.aidl.tests.immutable.Bar bar; public static Union bar(android.aidl.tests.immutable.Bar _value) { return new Union(bar, _value); } public android.aidl.tests.immutable.Bar getBar() { _assertTag(bar); return (android.aidl.tests.immutable.Bar) _value; } public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public Union createFromParcel(android.os.Parcel _aidl_source) { return internalCreateFromParcel(_aidl_source); } @Override public Union[] newArray(int _aidl_size) { return new Union[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { _aidl_parcel.writeInt(_tag); switch (_tag) { case num: _aidl_parcel.writeInt(getNum()); break; case str: _aidl_parcel.writeStringArray(getStr()); break; case bar: _aidl_parcel.writeTypedObject(getBar(), _aidl_flag); break; } } private static Union internalCreateFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_tag; _aidl_tag = _aidl_parcel.readInt(); switch (_aidl_tag) { case num: { int _aidl_value; _aidl_value = _aidl_parcel.readInt(); return new Union(_aidl_tag, _aidl_value); } case str: { java.lang.String[] _aidl_value; _aidl_value = _aidl_parcel.createStringArray(); return new Union(_aidl_tag, _aidl_value); } case bar: { android.aidl.tests.immutable.Bar _aidl_value; _aidl_value = _aidl_parcel.readTypedObject(android.aidl.tests.immutable.Bar.CREATOR); return new Union(_aidl_tag, _aidl_value); } } throw new IllegalArgumentException("union: unknown tag: " + _aidl_tag); } @Override public int describeContents() { int _mask = 0; switch (getTag()) { case bar: _mask |= describeContents(getBar()); break; } return _mask; } private int describeContents(Object _v) { if (_v == null) return 0; if (_v instanceof android.os.Parcelable) { return ((android.os.Parcelable) _v).describeContents(); } return 0; } private void _assertTag(int tag) { if (getTag() != tag) { throw new IllegalStateException("bad access: " + _tagString(tag) + ", " + _tagString(getTag()) + " is available."); } } private String _tagString(int _tag) { switch (_tag) { case num: return "num"; case str: return "str"; case bar: return "bar"; } throw new IllegalStateException("unknown field: " + _tag); } public static @interface Tag { public static final int num = 0; public static final int str = 1; public static final int bar = 2; } } ./PaxHeaders.X/tests_golden_output_aidl-test-extras-java-source_gen_android_aidl_tests_immutable_Un0100644 0000000 0000000 00000000034 15172120304 033265 xustar000000000 0000000 28 mtime=1776853188.3850000 tests/golden_output/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/Union.java.d0100644 0000000 0000000 00000000374 15172120304 031645 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/Union.java : \ system/tools/aidl/tests/android/aidl/tests/immutable/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/immutable/Bar.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-extras-java-source_gen_android_aidl_tests_map_0100644 0000000 0000000 00000000034 15172120304 031560 xustar000000000 0000000 28 mtime=1776853188.3850000 tests/golden_output/aidl-test-extras-java-source/gen/android/aidl/tests/map/0040755 0000000 0000000 00000000000 15172120304 026265 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-extras-java-source_gen_android_aidl_tests_map_Bar.java0100644 0000000 0000000 00000000034 15172120304 033125 xustar000000000 0000000 28 mtime=1776853188.3850000 tests/golden_output/aidl-test-extras-java-source/gen/android/aidl/tests/map/Bar.java0100644 0000000 0000000 00000004526 15172120304 027640 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/map/Bar.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/map/Bar.aidl */ package android.aidl.tests.map; public class Bar implements android.os.Parcelable { public int a = 0; public java.lang.String b; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public Bar createFromParcel(android.os.Parcel _aidl_source) { Bar _aidl_out = new Bar(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public Bar[] newArray(int _aidl_size) { return new Bar[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(a); _aidl_parcel.writeString(b); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; a = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; b = _aidl_parcel.readString(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } } ./PaxHeaders.X/tests_golden_output_aidl-test-extras-java-source_gen_android_aidl_tests_map_Bar.java0100644 0000000 0000000 00000000034 15172120304 033125 xustar000000000 0000000 28 mtime=1776853188.3850000 tests/golden_output/aidl-test-extras-java-source/gen/android/aidl/tests/map/Bar.java.d0100644 0000000 0000000 00000000252 15172120304 030052 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/map/Bar.java : \ system/tools/aidl/tests/android/aidl/tests/map/Bar.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-extras-java-source_gen_android_aidl_tests_map_Foo.java0100644 0000000 0000000 00000000034 15172120304 033144 xustar000000000 0000000 28 mtime=1776853188.3850000 tests/golden_output/aidl-test-extras-java-source/gen/android/aidl/tests/map/Foo.java0100644 0000000 0000000 00000021631 15172120304 027653 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/map/Foo.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/map/Foo.aidl */ package android.aidl.tests.map; public class Foo implements android.os.Parcelable { public java.util.Map intEnumArrayMap; public java.util.Map intArrayMap; public java.util.Map barMap; public java.util.Map barArrayMap; public java.util.Map stringMap; public java.util.Map stringArrayMap; public java.util.Map interfaceMap; public java.util.Map ibinderMap; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public Foo createFromParcel(android.os.Parcel _aidl_source) { Foo _aidl_out = new Foo(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public Foo[] newArray(int _aidl_size) { return new Foo[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); if (intEnumArrayMap == null) { _aidl_parcel.writeInt(-1); } else { _aidl_parcel.writeInt(intEnumArrayMap.size()); intEnumArrayMap.forEach((k, v) -> { _aidl_parcel.writeString(k); _aidl_parcel.writeIntArray(v); }); } if (intArrayMap == null) { _aidl_parcel.writeInt(-1); } else { _aidl_parcel.writeInt(intArrayMap.size()); intArrayMap.forEach((k, v) -> { _aidl_parcel.writeString(k); _aidl_parcel.writeIntArray(v); }); } if (barMap == null) { _aidl_parcel.writeInt(-1); } else { _aidl_parcel.writeInt(barMap.size()); barMap.forEach((k, v) -> { _aidl_parcel.writeString(k); _aidl_parcel.writeTypedObject(v, _aidl_flag); }); } if (barArrayMap == null) { _aidl_parcel.writeInt(-1); } else { _aidl_parcel.writeInt(barArrayMap.size()); barArrayMap.forEach((k, v) -> { _aidl_parcel.writeString(k); _aidl_parcel.writeTypedArray(v, _aidl_flag); }); } if (stringMap == null) { _aidl_parcel.writeInt(-1); } else { _aidl_parcel.writeInt(stringMap.size()); stringMap.forEach((k, v) -> { _aidl_parcel.writeString(k); _aidl_parcel.writeString(v); }); } if (stringArrayMap == null) { _aidl_parcel.writeInt(-1); } else { _aidl_parcel.writeInt(stringArrayMap.size()); stringArrayMap.forEach((k, v) -> { _aidl_parcel.writeString(k); _aidl_parcel.writeStringArray(v); }); } if (interfaceMap == null) { _aidl_parcel.writeInt(-1); } else { _aidl_parcel.writeInt(interfaceMap.size()); interfaceMap.forEach((k, v) -> { _aidl_parcel.writeString(k); _aidl_parcel.writeStrongInterface(v); }); } if (ibinderMap == null) { _aidl_parcel.writeInt(-1); } else { _aidl_parcel.writeInt(ibinderMap.size()); ibinderMap.forEach((k, v) -> { _aidl_parcel.writeString(k); _aidl_parcel.writeStrongBinder(v); }); } int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; { int N = _aidl_parcel.readInt(); intEnumArrayMap = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = _aidl_parcel.readString(); int[] v; v = _aidl_parcel.createIntArray(); intEnumArrayMap.put(k, v); }); } if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; { int N = _aidl_parcel.readInt(); intArrayMap = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = _aidl_parcel.readString(); int[] v; v = _aidl_parcel.createIntArray(); intArrayMap.put(k, v); }); } if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; { int N = _aidl_parcel.readInt(); barMap = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = _aidl_parcel.readString(); android.aidl.tests.map.Bar v; v = _aidl_parcel.readTypedObject(android.aidl.tests.map.Bar.CREATOR); barMap.put(k, v); }); } if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; { int N = _aidl_parcel.readInt(); barArrayMap = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = _aidl_parcel.readString(); android.aidl.tests.map.Bar[] v; v = _aidl_parcel.createTypedArray(android.aidl.tests.map.Bar.CREATOR); barArrayMap.put(k, v); }); } if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; { int N = _aidl_parcel.readInt(); stringMap = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = _aidl_parcel.readString(); java.lang.String v; v = _aidl_parcel.readString(); stringMap.put(k, v); }); } if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; { int N = _aidl_parcel.readInt(); stringArrayMap = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = _aidl_parcel.readString(); java.lang.String[] v; v = _aidl_parcel.createStringArray(); stringArrayMap.put(k, v); }); } if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; { int N = _aidl_parcel.readInt(); interfaceMap = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = _aidl_parcel.readString(); android.aidl.tests.map.IEmpty v; v = android.aidl.tests.map.IEmpty.Stub.asInterface(_aidl_parcel.readStrongBinder()); interfaceMap.put(k, v); }); } if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; { int N = _aidl_parcel.readInt(); ibinderMap = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = _aidl_parcel.readString(); android.os.IBinder v; v = _aidl_parcel.readStrongBinder(); ibinderMap.put(k, v); }); } } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; _mask |= describeContents(barMap); _mask |= describeContents(barArrayMap); return _mask; } private int describeContents(Object _v) { if (_v == null) return 0; if (_v instanceof Object[]) { int _mask = 0; for (Object o : (Object[]) _v) { _mask |= describeContents(o); } return _mask; } if (_v instanceof java.util.Collection) { int _mask = 0; for (Object o : (java.util.Collection) _v) { _mask |= describeContents(o); } return _mask; } if (_v instanceof java.util.Map) { return describeContents(((java.util.Map) _v).values()); } if (_v instanceof android.os.Parcelable) { return ((android.os.Parcelable) _v).describeContents(); } return 0; } } ./PaxHeaders.X/tests_golden_output_aidl-test-extras-java-source_gen_android_aidl_tests_map_Foo.java0100644 0000000 0000000 00000000034 15172120304 033144 xustar000000000 0000000 28 mtime=1776853188.3850000 tests/golden_output/aidl-test-extras-java-source/gen/android/aidl/tests/map/Foo.java.d0100644 0000000 0000000 00000000545 15172120304 030076 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/map/Foo.java : \ system/tools/aidl/tests/android/aidl/tests/map/Foo.aidl \ system/tools/aidl/tests/android/aidl/tests/map/Bar.aidl \ system/tools/aidl/tests/android/aidl/tests/map/IEmpty.aidl \ system/tools/aidl/tests/android/aidl/tests/map/IntEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-extras-java-source_gen_android_aidl_tests_map_IEmpty.j0100644 0000000 0000000 00000000034 15172120304 033140 xustar000000000 0000000 28 mtime=1776853188.3850000 tests/golden_output/aidl-test-extras-java-source/gen/android/aidl/tests/map/IEmpty.java0100644 0000000 0000000 00000006124 15172120304 030337 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/map/IEmpty.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/map/IEmpty.aidl */ package android.aidl.tests.map; public interface IEmpty extends android.os.IInterface { /** Default implementation for IEmpty. */ public static class Default implements android.aidl.tests.map.IEmpty { @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.map.IEmpty { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.map.IEmpty interface, * generating a proxy if needed. */ public static android.aidl.tests.map.IEmpty asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.map.IEmpty))) { return ((android.aidl.tests.map.IEmpty)iin); } return new android.aidl.tests.map.IEmpty.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { default: { return super.onTransact(code, data, reply, flags); } } } private static class Proxy implements android.aidl.tests.map.IEmpty { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } } /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.map.IEmpty"; } ./PaxHeaders.X/tests_golden_output_aidl-test-extras-java-source_gen_android_aidl_tests_map_IEmpty.j0100644 0000000 0000000 00000000034 15172120304 033140 xustar000000000 0000000 28 mtime=1776853188.3850000 tests/golden_output/aidl-test-extras-java-source/gen/android/aidl/tests/map/IEmpty.java.d0100644 0000000 0000000 00000000260 15172120304 030554 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/map/IEmpty.java : \ system/tools/aidl/tests/android/aidl/tests/map/IEmpty.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-extras-java-source_gen_android_aidl_tests_map_IMapTest0100644 0000000 0000000 00000000034 15172120304 033167 xustar000000000 0000000 28 mtime=1776853188.3850000 tests/golden_output/aidl-test-extras-java-source/gen/android/aidl/tests/map/IMapTest.java0100644 0000000 0000000 00000102573 15172120304 030623 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/map/IMapTest.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/map/IMapTest.aidl */ package android.aidl.tests.map; public interface IMapTest extends android.os.IInterface { /** Default implementation for IMapTest. */ public static class Default implements android.aidl.tests.map.IMapTest { @Override public java.util.Map repeatIntEnumArrayMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException { return null; } @Override public java.util.Map repeatIntArrayMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException { return null; } @Override public java.util.Map repeatBarMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException { return null; } @Override public java.util.Map repeatBarArrayMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException { return null; } @Override public java.util.Map repeatStringMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException { return null; } @Override public java.util.Map repeatStringArrayMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException { return null; } @Override public java.util.Map repeatInterfaceMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException { return null; } @Override public java.util.Map repeatIbinderMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException { return null; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.map.IMapTest { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.map.IMapTest interface, * generating a proxy if needed. */ public static android.aidl.tests.map.IMapTest asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.map.IMapTest))) { return ((android.aidl.tests.map.IMapTest)iin); } return new android.aidl.tests.map.IMapTest.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_repeatIntEnumArrayMap: { return "repeatIntEnumArrayMap"; } case TRANSACTION_repeatIntArrayMap: { return "repeatIntArrayMap"; } case TRANSACTION_repeatBarMap: { return "repeatBarMap"; } case TRANSACTION_repeatBarArrayMap: { return "repeatBarArrayMap"; } case TRANSACTION_repeatStringMap: { return "repeatStringMap"; } case TRANSACTION_repeatStringArrayMap: { return "repeatStringArrayMap"; } case TRANSACTION_repeatInterfaceMap: { return "repeatInterfaceMap"; } case TRANSACTION_repeatIbinderMap: { return "repeatIbinderMap"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_repeatIntEnumArrayMap: { java.util.Map _arg0; { int N = data.readInt(); _arg0 = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = data.readString(); int[] v; v = data.createIntArray(); _arg0.put(k, v); }); } java.util.Map _arg1; _arg1 = new java.util.HashMap(); data.enforceNoDataAvail(); java.util.Map _result = this.repeatIntEnumArrayMap(_arg0, _arg1); reply.writeNoException(); if (_result == null) { reply.writeInt(-1); } else { reply.writeInt(_result.size()); _result.forEach((k, v) -> { reply.writeString(k); reply.writeIntArray(v); }); } if (_arg1 == null) { reply.writeInt(-1); } else { reply.writeInt(_arg1.size()); _arg1.forEach((k, v) -> { reply.writeString(k); reply.writeIntArray(v); }); } break; } case TRANSACTION_repeatIntArrayMap: { java.util.Map _arg0; { int N = data.readInt(); _arg0 = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = data.readString(); int[] v; v = data.createIntArray(); _arg0.put(k, v); }); } java.util.Map _arg1; _arg1 = new java.util.HashMap(); data.enforceNoDataAvail(); java.util.Map _result = this.repeatIntArrayMap(_arg0, _arg1); reply.writeNoException(); if (_result == null) { reply.writeInt(-1); } else { reply.writeInt(_result.size()); _result.forEach((k, v) -> { reply.writeString(k); reply.writeIntArray(v); }); } if (_arg1 == null) { reply.writeInt(-1); } else { reply.writeInt(_arg1.size()); _arg1.forEach((k, v) -> { reply.writeString(k); reply.writeIntArray(v); }); } break; } case TRANSACTION_repeatBarMap: { java.util.Map _arg0; { int N = data.readInt(); _arg0 = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = data.readString(); android.aidl.tests.map.Bar v; v = data.readTypedObject(android.aidl.tests.map.Bar.CREATOR); _arg0.put(k, v); }); } java.util.Map _arg1; _arg1 = new java.util.HashMap(); data.enforceNoDataAvail(); java.util.Map _result = this.repeatBarMap(_arg0, _arg1); reply.writeNoException(); if (_result == null) { reply.writeInt(-1); } else { reply.writeInt(_result.size()); _result.forEach((k, v) -> { reply.writeString(k); reply.writeTypedObject(v, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); }); } if (_arg1 == null) { reply.writeInt(-1); } else { reply.writeInt(_arg1.size()); _arg1.forEach((k, v) -> { reply.writeString(k); reply.writeTypedObject(v, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); }); } break; } case TRANSACTION_repeatBarArrayMap: { java.util.Map _arg0; { int N = data.readInt(); _arg0 = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = data.readString(); android.aidl.tests.map.Bar[] v; v = data.createTypedArray(android.aidl.tests.map.Bar.CREATOR); _arg0.put(k, v); }); } java.util.Map _arg1; _arg1 = new java.util.HashMap(); data.enforceNoDataAvail(); java.util.Map _result = this.repeatBarArrayMap(_arg0, _arg1); reply.writeNoException(); if (_result == null) { reply.writeInt(-1); } else { reply.writeInt(_result.size()); _result.forEach((k, v) -> { reply.writeString(k); reply.writeTypedArray(v, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); }); } if (_arg1 == null) { reply.writeInt(-1); } else { reply.writeInt(_arg1.size()); _arg1.forEach((k, v) -> { reply.writeString(k); reply.writeTypedArray(v, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); }); } break; } case TRANSACTION_repeatStringMap: { java.util.Map _arg0; { int N = data.readInt(); _arg0 = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = data.readString(); java.lang.String v; v = data.readString(); _arg0.put(k, v); }); } java.util.Map _arg1; _arg1 = new java.util.HashMap(); data.enforceNoDataAvail(); java.util.Map _result = this.repeatStringMap(_arg0, _arg1); reply.writeNoException(); if (_result == null) { reply.writeInt(-1); } else { reply.writeInt(_result.size()); _result.forEach((k, v) -> { reply.writeString(k); reply.writeString(v); }); } if (_arg1 == null) { reply.writeInt(-1); } else { reply.writeInt(_arg1.size()); _arg1.forEach((k, v) -> { reply.writeString(k); reply.writeString(v); }); } break; } case TRANSACTION_repeatStringArrayMap: { java.util.Map _arg0; { int N = data.readInt(); _arg0 = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = data.readString(); java.lang.String[] v; v = data.createStringArray(); _arg0.put(k, v); }); } java.util.Map _arg1; _arg1 = new java.util.HashMap(); data.enforceNoDataAvail(); java.util.Map _result = this.repeatStringArrayMap(_arg0, _arg1); reply.writeNoException(); if (_result == null) { reply.writeInt(-1); } else { reply.writeInt(_result.size()); _result.forEach((k, v) -> { reply.writeString(k); reply.writeStringArray(v); }); } if (_arg1 == null) { reply.writeInt(-1); } else { reply.writeInt(_arg1.size()); _arg1.forEach((k, v) -> { reply.writeString(k); reply.writeStringArray(v); }); } break; } case TRANSACTION_repeatInterfaceMap: { java.util.Map _arg0; { int N = data.readInt(); _arg0 = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = data.readString(); android.aidl.tests.map.IEmpty v; v = android.aidl.tests.map.IEmpty.Stub.asInterface(data.readStrongBinder()); _arg0.put(k, v); }); } java.util.Map _arg1; _arg1 = new java.util.HashMap(); data.enforceNoDataAvail(); java.util.Map _result = this.repeatInterfaceMap(_arg0, _arg1); reply.writeNoException(); if (_result == null) { reply.writeInt(-1); } else { reply.writeInt(_result.size()); _result.forEach((k, v) -> { reply.writeString(k); reply.writeStrongInterface(v); }); } if (_arg1 == null) { reply.writeInt(-1); } else { reply.writeInt(_arg1.size()); _arg1.forEach((k, v) -> { reply.writeString(k); reply.writeStrongInterface(v); }); } break; } case TRANSACTION_repeatIbinderMap: { java.util.Map _arg0; { int N = data.readInt(); _arg0 = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = data.readString(); android.os.IBinder v; v = data.readStrongBinder(); _arg0.put(k, v); }); } java.util.Map _arg1; _arg1 = new java.util.HashMap(); data.enforceNoDataAvail(); java.util.Map _result = this.repeatIbinderMap(_arg0, _arg1); reply.writeNoException(); if (_result == null) { reply.writeInt(-1); } else { reply.writeInt(_result.size()); _result.forEach((k, v) -> { reply.writeString(k); reply.writeStrongBinder(v); }); } if (_arg1 == null) { reply.writeInt(-1); } else { reply.writeInt(_arg1.size()); _arg1.forEach((k, v) -> { reply.writeString(k); reply.writeStrongBinder(v); }); } break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.map.IMapTest { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public java.util.Map repeatIntEnumArrayMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.util.Map _result; try { _data.writeInterfaceToken(DESCRIPTOR); if (input == null) { _data.writeInt(-1); } else { _data.writeInt(input.size()); input.forEach((k, v) -> { _data.writeString(k); _data.writeIntArray(v); }); } boolean _status = mRemote.transact(Stub.TRANSACTION_repeatIntEnumArrayMap, _data, _reply, 0); _reply.readException(); { int N = _reply.readInt(); _result = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = _reply.readString(); int[] v; v = _reply.createIntArray(); _result.put(k, v); }); } if (output != null) output.clear(); java.util.stream.IntStream.range(0, _reply.readInt()).forEach(i -> { String k = _reply.readString(); int[] v; v = _reply.createIntArray(); output.put(k, v); }); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.util.Map repeatIntArrayMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.util.Map _result; try { _data.writeInterfaceToken(DESCRIPTOR); if (input == null) { _data.writeInt(-1); } else { _data.writeInt(input.size()); input.forEach((k, v) -> { _data.writeString(k); _data.writeIntArray(v); }); } boolean _status = mRemote.transact(Stub.TRANSACTION_repeatIntArrayMap, _data, _reply, 0); _reply.readException(); { int N = _reply.readInt(); _result = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = _reply.readString(); int[] v; v = _reply.createIntArray(); _result.put(k, v); }); } if (output != null) output.clear(); java.util.stream.IntStream.range(0, _reply.readInt()).forEach(i -> { String k = _reply.readString(); int[] v; v = _reply.createIntArray(); output.put(k, v); }); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.util.Map repeatBarMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.util.Map _result; try { _data.writeInterfaceToken(DESCRIPTOR); if (input == null) { _data.writeInt(-1); } else { _data.writeInt(input.size()); input.forEach((k, v) -> { _data.writeString(k); _data.writeTypedObject(v, 0); }); } boolean _status = mRemote.transact(Stub.TRANSACTION_repeatBarMap, _data, _reply, 0); _reply.readException(); { int N = _reply.readInt(); _result = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = _reply.readString(); android.aidl.tests.map.Bar v; v = _reply.readTypedObject(android.aidl.tests.map.Bar.CREATOR); _result.put(k, v); }); } if (output != null) output.clear(); java.util.stream.IntStream.range(0, _reply.readInt()).forEach(i -> { String k = _reply.readString(); android.aidl.tests.map.Bar v; v = _reply.readTypedObject(android.aidl.tests.map.Bar.CREATOR); output.put(k, v); }); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.util.Map repeatBarArrayMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.util.Map _result; try { _data.writeInterfaceToken(DESCRIPTOR); if (input == null) { _data.writeInt(-1); } else { _data.writeInt(input.size()); input.forEach((k, v) -> { _data.writeString(k); _data.writeTypedArray(v, 0); }); } boolean _status = mRemote.transact(Stub.TRANSACTION_repeatBarArrayMap, _data, _reply, 0); _reply.readException(); { int N = _reply.readInt(); _result = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = _reply.readString(); android.aidl.tests.map.Bar[] v; v = _reply.createTypedArray(android.aidl.tests.map.Bar.CREATOR); _result.put(k, v); }); } if (output != null) output.clear(); java.util.stream.IntStream.range(0, _reply.readInt()).forEach(i -> { String k = _reply.readString(); android.aidl.tests.map.Bar[] v; v = _reply.createTypedArray(android.aidl.tests.map.Bar.CREATOR); output.put(k, v); }); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.util.Map repeatStringMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.util.Map _result; try { _data.writeInterfaceToken(DESCRIPTOR); if (input == null) { _data.writeInt(-1); } else { _data.writeInt(input.size()); input.forEach((k, v) -> { _data.writeString(k); _data.writeString(v); }); } boolean _status = mRemote.transact(Stub.TRANSACTION_repeatStringMap, _data, _reply, 0); _reply.readException(); { int N = _reply.readInt(); _result = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = _reply.readString(); java.lang.String v; v = _reply.readString(); _result.put(k, v); }); } if (output != null) output.clear(); java.util.stream.IntStream.range(0, _reply.readInt()).forEach(i -> { String k = _reply.readString(); java.lang.String v; v = _reply.readString(); output.put(k, v); }); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.util.Map repeatStringArrayMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.util.Map _result; try { _data.writeInterfaceToken(DESCRIPTOR); if (input == null) { _data.writeInt(-1); } else { _data.writeInt(input.size()); input.forEach((k, v) -> { _data.writeString(k); _data.writeStringArray(v); }); } boolean _status = mRemote.transact(Stub.TRANSACTION_repeatStringArrayMap, _data, _reply, 0); _reply.readException(); { int N = _reply.readInt(); _result = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = _reply.readString(); java.lang.String[] v; v = _reply.createStringArray(); _result.put(k, v); }); } if (output != null) output.clear(); java.util.stream.IntStream.range(0, _reply.readInt()).forEach(i -> { String k = _reply.readString(); java.lang.String[] v; v = _reply.createStringArray(); output.put(k, v); }); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.util.Map repeatInterfaceMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.util.Map _result; try { _data.writeInterfaceToken(DESCRIPTOR); if (input == null) { _data.writeInt(-1); } else { _data.writeInt(input.size()); input.forEach((k, v) -> { _data.writeString(k); _data.writeStrongInterface(v); }); } boolean _status = mRemote.transact(Stub.TRANSACTION_repeatInterfaceMap, _data, _reply, 0); _reply.readException(); { int N = _reply.readInt(); _result = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = _reply.readString(); android.aidl.tests.map.IEmpty v; v = android.aidl.tests.map.IEmpty.Stub.asInterface(_reply.readStrongBinder()); _result.put(k, v); }); } if (output != null) output.clear(); java.util.stream.IntStream.range(0, _reply.readInt()).forEach(i -> { String k = _reply.readString(); android.aidl.tests.map.IEmpty v; v = android.aidl.tests.map.IEmpty.Stub.asInterface(_reply.readStrongBinder()); output.put(k, v); }); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.util.Map repeatIbinderMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.util.Map _result; try { _data.writeInterfaceToken(DESCRIPTOR); if (input == null) { _data.writeInt(-1); } else { _data.writeInt(input.size()); input.forEach((k, v) -> { _data.writeString(k); _data.writeStrongBinder(v); }); } boolean _status = mRemote.transact(Stub.TRANSACTION_repeatIbinderMap, _data, _reply, 0); _reply.readException(); { int N = _reply.readInt(); _result = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = _reply.readString(); android.os.IBinder v; v = _reply.readStrongBinder(); _result.put(k, v); }); } if (output != null) output.clear(); java.util.stream.IntStream.range(0, _reply.readInt()).forEach(i -> { String k = _reply.readString(); android.os.IBinder v; v = _reply.readStrongBinder(); output.put(k, v); }); } finally { _reply.recycle(); _data.recycle(); } return _result; } } static final int TRANSACTION_repeatIntEnumArrayMap = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); static final int TRANSACTION_repeatIntArrayMap = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1); static final int TRANSACTION_repeatBarMap = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2); static final int TRANSACTION_repeatBarArrayMap = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3); static final int TRANSACTION_repeatStringMap = (android.os.IBinder.FIRST_CALL_TRANSACTION + 4); static final int TRANSACTION_repeatStringArrayMap = (android.os.IBinder.FIRST_CALL_TRANSACTION + 5); static final int TRANSACTION_repeatInterfaceMap = (android.os.IBinder.FIRST_CALL_TRANSACTION + 6); static final int TRANSACTION_repeatIbinderMap = (android.os.IBinder.FIRST_CALL_TRANSACTION + 7); /** @hide */ public int getMaxTransactionId() { return 7; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.map.IMapTest"; public java.util.Map repeatIntEnumArrayMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException; public java.util.Map repeatIntArrayMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException; public java.util.Map repeatBarMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException; public java.util.Map repeatBarArrayMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException; public java.util.Map repeatStringMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException; public java.util.Map repeatStringArrayMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException; public java.util.Map repeatInterfaceMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException; public java.util.Map repeatIbinderMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException; } ./PaxHeaders.X/tests_golden_output_aidl-test-extras-java-source_gen_android_aidl_tests_map_IMapTest0100644 0000000 0000000 00000000034 15172120304 033167 xustar000000000 0000000 28 mtime=1776853188.3860000 tests/golden_output/aidl-test-extras-java-source/gen/android/aidl/tests/map/IMapTest.java.d0100644 0000000 0000000 00000000557 15172120304 031044 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/map/IMapTest.java : \ system/tools/aidl/tests/android/aidl/tests/map/IMapTest.aidl \ system/tools/aidl/tests/android/aidl/tests/map/Bar.aidl \ system/tools/aidl/tests/android/aidl/tests/map/IEmpty.aidl \ system/tools/aidl/tests/android/aidl/tests/map/IntEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-extras-java-source_gen_android_aidl_tests_map_IntEnum.0100644 0000000 0000000 00000000034 15172120304 033136 xustar000000000 0000000 28 mtime=1776853188.3860000 tests/golden_output/aidl-test-extras-java-source/gen/android/aidl/tests/map/IntEnum.java0100644 0000000 0000000 00000001226 15172120304 030505 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/map/IntEnum.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/map/IntEnum.aidl */ package android.aidl.tests.map; public @interface IntEnum { public static final int FOO = 1000; public static final int BAR = 2000; public static final int BAZ = 2001; } ./PaxHeaders.X/tests_golden_output_aidl-test-extras-java-source_gen_android_aidl_tests_map_IntEnum.0100644 0000000 0000000 00000000034 15172120304 033136 xustar000000000 0000000 28 mtime=1776853188.3860000 tests/golden_output/aidl-test-extras-java-source/gen/android/aidl/tests/map/IntEnum.java.d0100644 0000000 0000000 00000000262 15172120304 030726 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/map/IntEnum.java : \ system/tools/aidl/tests/android/aidl/tests/map/IntEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-extras-java-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 026734 xustar000000000 0000000 28 mtime=1776853188.3860000 tests/golden_output/aidl-test-extras-java-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 023726 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-cpp-source_0100644 0000000 0000000 00000000034 15172120304 025543 xustar000000000 0000000 28 mtime=1776853188.3860000 tests/golden_output/aidl-test-fixedsizearray-cpp-source/0040755 0000000 0000000 00000000000 15172120304 022630 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-cpp-source_gen_0100644 0000000 0000000 00000000034 15172120304 026374 xustar000000000 0000000 28 mtime=1776853188.3860000 tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/0040755 0000000 0000000 00000000000 15172120304 023401 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-cpp-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 030074 xustar000000000 0000000 28 mtime=1776853188.3860000 tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 025021 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-cpp-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 031065 xustar000000000 0000000 28 mtime=1776853188.3860000 tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 025732 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-cpp-source_gen_android_aidl_fixedsizear0100644 0000000 0000000 00000000034 15172120304 033323 xustar000000000 0000000 28 mtime=1776853188.3860000 tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/android/aidl/fixedsizearray/0040755 0000000 0000000 00000000000 15172120304 030763 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-cpp-source_gen_android_aidl_fixedsizear0100644 0000000 0000000 00000000227 15172120304 033327 xustar000000000 0000000 123 path=tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/android/aidl/fixedsizearray/FixedSizeArrayExample.cpp 28 mtime=1776853188.3870000 tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/android/aidl/fixedsizearray/FixedSizeArr0100644 0000000 0000000 00000167224 15172120304 033256 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-cpp-source/gen/staging/android/aidl/fixedsizearray/FixedSizeArrayExample.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/fixedsizearray/FixedSizeArrayExample.aidl */ #include namespace android { namespace aidl { namespace fixedsizearray { ::android::status_t FixedSizeArrayExample::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&int2x3); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&boolArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&byteArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&charArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&intArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&longArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&floatArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&doubleArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&stringArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&byteEnumArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&intEnumArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&longEnumArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&parcelableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&boolMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&byteMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&charMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&intMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&longMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&floatMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&doubleMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&stringMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&byteEnumMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&intEnumMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&longEnumMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&parcelableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&boolNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&byteNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&charNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&intNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&longNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&floatNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&doubleNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&stringNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&byteEnumNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&intEnumNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&longEnumNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&binderNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&pfdNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&parcelableNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&interfaceNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&boolNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&byteNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&charNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&intNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&longNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&floatNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&doubleNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&stringNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&byteEnumNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&intEnumNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&longEnumNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&binderNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&pfdNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&parcelableNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&interfaceNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t FixedSizeArrayExample::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeFixedArray(int2x3); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(boolArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(byteArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(charArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(intArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(longArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(floatArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(doubleArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(stringArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(byteEnumArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(intEnumArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(longEnumArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(parcelableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(boolMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(byteMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(charMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(intMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(longMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(floatMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(doubleMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(stringMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(byteEnumMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(intEnumMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(longEnumMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(parcelableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(boolNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(byteNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(charNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(intNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(longNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(floatNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(doubleNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(stringNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(byteEnumNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(intEnumNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(longEnumNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(binderNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(pfdNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(parcelableNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(interfaceNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(boolNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(byteNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(charNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(intNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(longNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(floatNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(doubleNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(stringNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(byteEnumNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(intEnumNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(longEnumNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(binderNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(pfdNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(parcelableNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(interfaceNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace fixedsizearray } // namespace aidl } // namespace android #include #include namespace android { namespace aidl { namespace fixedsizearray { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_NESTED_INTERFACE(FixedSizeArrayExample, RepeatFixedSizeArray, "android.aidl.fixedsizearray.FixedSizeArrayExample.IRepeatFixedSizeArray") } // namespace fixedsizearray } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace fixedsizearray { FixedSizeArrayExample::BpRepeatFixedSizeArray::BpRepeatFixedSizeArray(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } ::android::binder::Status FixedSizeArrayExample::BpRepeatFixedSizeArray::RepeatBytes(const std::array& input, std::array* repeated, std::array* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IRepeatFixedSizeArray::RepeatBytes::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeFixedArray(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(FixedSizeArrayExample::BnRepeatFixedSizeArray::TRANSACTION_RepeatBytes, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl()) [[unlikely]] { return IRepeatFixedSizeArray::getDefaultImpl()->RepeatBytes(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readFixedArray(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readFixedArray(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status FixedSizeArrayExample::BpRepeatFixedSizeArray::RepeatInts(const std::array& input, std::array* repeated, std::array* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IRepeatFixedSizeArray::RepeatInts::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeFixedArray(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(FixedSizeArrayExample::BnRepeatFixedSizeArray::TRANSACTION_RepeatInts, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl()) [[unlikely]] { return IRepeatFixedSizeArray::getDefaultImpl()->RepeatInts(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readFixedArray(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readFixedArray(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status FixedSizeArrayExample::BpRepeatFixedSizeArray::RepeatBinders(const std::array<::android::sp<::android::IBinder>, 3>& input, std::array<::android::sp<::android::IBinder>, 3>* repeated, std::array<::android::sp<::android::IBinder>, 3>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IRepeatFixedSizeArray::RepeatBinders::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeFixedArray(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(FixedSizeArrayExample::BnRepeatFixedSizeArray::TRANSACTION_RepeatBinders, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl()) [[unlikely]] { return IRepeatFixedSizeArray::getDefaultImpl()->RepeatBinders(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readFixedArray(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readFixedArray(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status FixedSizeArrayExample::BpRepeatFixedSizeArray::RepeatParcelables(const std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>& input, std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* repeated, std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IRepeatFixedSizeArray::RepeatParcelables::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeFixedArray(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(FixedSizeArrayExample::BnRepeatFixedSizeArray::TRANSACTION_RepeatParcelables, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl()) [[unlikely]] { return IRepeatFixedSizeArray::getDefaultImpl()->RepeatParcelables(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readFixedArray(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readFixedArray(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status FixedSizeArrayExample::BpRepeatFixedSizeArray::Repeat2dBytes(const std::array, 2>& input, std::array, 2>* repeated, std::array, 2>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IRepeatFixedSizeArray::Repeat2dBytes::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeFixedArray(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(FixedSizeArrayExample::BnRepeatFixedSizeArray::TRANSACTION_Repeat2dBytes, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl()) [[unlikely]] { return IRepeatFixedSizeArray::getDefaultImpl()->Repeat2dBytes(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readFixedArray(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readFixedArray(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status FixedSizeArrayExample::BpRepeatFixedSizeArray::Repeat2dInts(const std::array, 2>& input, std::array, 2>* repeated, std::array, 2>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IRepeatFixedSizeArray::Repeat2dInts::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeFixedArray(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(FixedSizeArrayExample::BnRepeatFixedSizeArray::TRANSACTION_Repeat2dInts, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl()) [[unlikely]] { return IRepeatFixedSizeArray::getDefaultImpl()->Repeat2dInts(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readFixedArray(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readFixedArray(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status FixedSizeArrayExample::BpRepeatFixedSizeArray::Repeat2dBinders(const std::array, 3>, 2>& input, std::array, 3>, 2>* repeated, std::array, 3>, 2>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IRepeatFixedSizeArray::Repeat2dBinders::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeFixedArray(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(FixedSizeArrayExample::BnRepeatFixedSizeArray::TRANSACTION_Repeat2dBinders, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl()) [[unlikely]] { return IRepeatFixedSizeArray::getDefaultImpl()->Repeat2dBinders(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readFixedArray(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readFixedArray(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status FixedSizeArrayExample::BpRepeatFixedSizeArray::Repeat2dParcelables(const std::array, 2>& input, std::array, 2>* repeated, std::array, 2>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IRepeatFixedSizeArray::Repeat2dParcelables::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeFixedArray(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(FixedSizeArrayExample::BnRepeatFixedSizeArray::TRANSACTION_Repeat2dParcelables, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl()) [[unlikely]] { return IRepeatFixedSizeArray::getDefaultImpl()->Repeat2dParcelables(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readFixedArray(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readFixedArray(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } } // namespace fixedsizearray } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace fixedsizearray { FixedSizeArrayExample::BnRepeatFixedSizeArray::BnRepeatFixedSizeArray() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t FixedSizeArrayExample::BnRepeatFixedSizeArray::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnRepeatFixedSizeArray::TRANSACTION_RepeatBytes: { std::array in_input; std::array out_repeated; std::array _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IRepeatFixedSizeArray::RepeatBytes::cppServer"); _aidl_ret_status = _aidl_data.readFixedArray(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatBytes(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeFixedArray(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeFixedArray(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnRepeatFixedSizeArray::TRANSACTION_RepeatInts: { std::array in_input; std::array out_repeated; std::array _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IRepeatFixedSizeArray::RepeatInts::cppServer"); _aidl_ret_status = _aidl_data.readFixedArray(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatInts(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeFixedArray(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeFixedArray(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnRepeatFixedSizeArray::TRANSACTION_RepeatBinders: { std::array<::android::sp<::android::IBinder>, 3> in_input; std::array<::android::sp<::android::IBinder>, 3> out_repeated; std::array<::android::sp<::android::IBinder>, 3> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IRepeatFixedSizeArray::RepeatBinders::cppServer"); _aidl_ret_status = _aidl_data.readFixedArray(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatBinders(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeFixedArray(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeFixedArray(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnRepeatFixedSizeArray::TRANSACTION_RepeatParcelables: { std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3> in_input; std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3> out_repeated; std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IRepeatFixedSizeArray::RepeatParcelables::cppServer"); _aidl_ret_status = _aidl_data.readFixedArray(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatParcelables(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeFixedArray(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeFixedArray(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnRepeatFixedSizeArray::TRANSACTION_Repeat2dBytes: { std::array, 2> in_input; std::array, 2> out_repeated; std::array, 2> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IRepeatFixedSizeArray::Repeat2dBytes::cppServer"); _aidl_ret_status = _aidl_data.readFixedArray(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(Repeat2dBytes(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeFixedArray(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeFixedArray(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnRepeatFixedSizeArray::TRANSACTION_Repeat2dInts: { std::array, 2> in_input; std::array, 2> out_repeated; std::array, 2> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IRepeatFixedSizeArray::Repeat2dInts::cppServer"); _aidl_ret_status = _aidl_data.readFixedArray(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(Repeat2dInts(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeFixedArray(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeFixedArray(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnRepeatFixedSizeArray::TRANSACTION_Repeat2dBinders: { std::array, 3>, 2> in_input; std::array, 3>, 2> out_repeated; std::array, 3>, 2> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IRepeatFixedSizeArray::Repeat2dBinders::cppServer"); _aidl_ret_status = _aidl_data.readFixedArray(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(Repeat2dBinders(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeFixedArray(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeFixedArray(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnRepeatFixedSizeArray::TRANSACTION_Repeat2dParcelables: { std::array, 2> in_input; std::array, 2> out_repeated; std::array, 2> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IRepeatFixedSizeArray::Repeat2dParcelables::cppServer"); _aidl_ret_status = _aidl_data.readFixedArray(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(Repeat2dParcelables(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeFixedArray(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeFixedArray(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } } // namespace fixedsizearray } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace fixedsizearray { ::android::status_t FixedSizeArrayExample::IntParcelable::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&value); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t FixedSizeArrayExample::IntParcelable::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeInt32(value); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace fixedsizearray } // namespace aidl } // namespace android #include #include namespace android { namespace aidl { namespace fixedsizearray { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_NESTED_INTERFACE(FixedSizeArrayExample, EmptyInterface, "android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface") } // namespace fixedsizearray } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace fixedsizearray { FixedSizeArrayExample::BpEmptyInterface::BpEmptyInterface(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } } // namespace fixedsizearray } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace fixedsizearray { FixedSizeArrayExample::BnEmptyInterface::BnEmptyInterface() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t FixedSizeArrayExample::BnEmptyInterface::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } } // namespace fixedsizearray } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-cpp-source_gen_android_aidl_fixedsizear0100644 0000000 0000000 00000000231 15172120304 033322 xustar000000000 0000000 125 path=tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/android/aidl/fixedsizearray/FixedSizeArrayExample.cpp.d 28 mtime=1776853188.3900000 tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/android/aidl/fixedsizearray/FixedSizeArr0100644 0000000 0000000 00000000336 15172120304 033244 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-cpp-source/gen/android/aidl/fixedsizearray/FixedSizeArrayExample.cpp : \ system/tools/aidl/tests/android/aidl/fixedsizearray/FixedSizeArrayExample.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-cpp-source_gen_include_0100644 0000000 0000000 00000000034 15172120304 030077 xustar000000000 0000000 28 mtime=1776853188.3900000 tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/include/0040755 0000000 0000000 00000000000 15172120304 025024 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-cpp-source_gen_include_android_0100644 0000000 0000000 00000000034 15172120304 031577 xustar000000000 0000000 28 mtime=1776853188.3900000 tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/include/android/0040755 0000000 0000000 00000000000 15172120304 026444 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-cpp-source_gen_include_android_aidl_0100644 0000000 0000000 00000000034 15172120304 032570 xustar000000000 0000000 28 mtime=1776853188.3900000 tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/include/android/aidl/0040755 0000000 0000000 00000000000 15172120304 027355 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-cpp-source_gen_include_android_aidl_fix0100644 0000000 0000000 00000000034 15172120304 033277 xustar000000000 0000000 28 mtime=1776853188.3900000 tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/include/android/aidl/fixedsizearray/0040755 0000000 0000000 00000000000 15172120304 032406 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-cpp-source_gen_include_android_aidl_fix0100644 0000000 0000000 00000000237 15172120304 033304 xustar000000000 0000000 131 path=tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/include/android/aidl/fixedsizearray/BnFixedSizeArrayExample.h 28 mtime=1776853188.3900000 tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/include/android/aidl/fixedsizearray/BnFi0100644 0000000 0000000 00000001273 15172120304 033147 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-cpp-source/gen/staging/android/aidl/fixedsizearray/FixedSizeArrayExample.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/fixedsizearray/FixedSizeArrayExample.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-cpp-source_gen_include_android_aidl_fix0100644 0000000 0000000 00000000237 15172120304 033304 xustar000000000 0000000 131 path=tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/include/android/aidl/fixedsizearray/BpFixedSizeArrayExample.h 28 mtime=1776853188.3900000 tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/include/android/aidl/fixedsizearray/BpFi0100644 0000000 0000000 00000001273 15172120304 033151 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-cpp-source/gen/staging/android/aidl/fixedsizearray/FixedSizeArrayExample.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/fixedsizearray/FixedSizeArrayExample.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-cpp-source_gen_include_android_aidl_fix0100644 0000000 0000000 00000000235 15172120304 033302 xustar000000000 0000000 129 path=tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/include/android/aidl/fixedsizearray/FixedSizeArrayExample.h 28 mtime=1776853188.3900000 tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/include/android/aidl/fixedsizearray/Fixe0100644 0000000 0000000 00000102430 15172120304 033221 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-cpp-source/gen/staging/android/aidl/fixedsizearray/FixedSizeArrayExample.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/fixedsizearray/FixedSizeArrayExample.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace android { namespace aidl { namespace fixedsizearray { class FixedSizeArrayExample : public ::android::Parcelable { public: class IntParcelable : public ::android::Parcelable { public: int32_t value = 0; inline bool operator==(const IntParcelable& _rhs) const { return std::tie(value) == std::tie(_rhs.value); } inline bool operator<(const IntParcelable& _rhs) const { return std::tie(value) < std::tie(_rhs.value); } inline bool operator!=(const IntParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const IntParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const IntParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const IntParcelable& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "IntParcelable{"; _aidl_os << "value: " << ::android::internal::ToString(value); _aidl_os << "}"; return _aidl_os.str(); } }; // class IntParcelable class IRepeatFixedSizeArrayDelegator; class IRepeatFixedSizeArray : public ::android::IInterface { public: typedef IRepeatFixedSizeArrayDelegator DefaultDelegator; DECLARE_META_INTERFACE(RepeatFixedSizeArray) virtual ::android::binder::Status RepeatBytes(const std::array& input, std::array* repeated, std::array* _aidl_return) = 0; virtual ::android::binder::Status RepeatInts(const std::array& input, std::array* repeated, std::array* _aidl_return) = 0; virtual ::android::binder::Status RepeatBinders(const std::array<::android::sp<::android::IBinder>, 3>& input, std::array<::android::sp<::android::IBinder>, 3>* repeated, std::array<::android::sp<::android::IBinder>, 3>* _aidl_return) = 0; virtual ::android::binder::Status RepeatParcelables(const std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>& input, std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* repeated, std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* _aidl_return) = 0; virtual ::android::binder::Status Repeat2dBytes(const std::array, 2>& input, std::array, 2>* repeated, std::array, 2>* _aidl_return) = 0; virtual ::android::binder::Status Repeat2dInts(const std::array, 2>& input, std::array, 2>* repeated, std::array, 2>* _aidl_return) = 0; virtual ::android::binder::Status Repeat2dBinders(const std::array, 3>, 2>& input, std::array, 3>, 2>* repeated, std::array, 3>, 2>* _aidl_return) = 0; virtual ::android::binder::Status Repeat2dParcelables(const std::array, 2>& input, std::array, 2>* repeated, std::array, 2>* _aidl_return) = 0; }; // class IRepeatFixedSizeArray class IRepeatFixedSizeArrayDefault : public IRepeatFixedSizeArray { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status RepeatBytes(const std::array& /*input*/, std::array* /*repeated*/, std::array* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatInts(const std::array& /*input*/, std::array* /*repeated*/, std::array* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatBinders(const std::array<::android::sp<::android::IBinder>, 3>& /*input*/, std::array<::android::sp<::android::IBinder>, 3>* /*repeated*/, std::array<::android::sp<::android::IBinder>, 3>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatParcelables(const std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>& /*input*/, std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* /*repeated*/, std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status Repeat2dBytes(const std::array, 2>& /*input*/, std::array, 2>* /*repeated*/, std::array, 2>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status Repeat2dInts(const std::array, 2>& /*input*/, std::array, 2>* /*repeated*/, std::array, 2>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status Repeat2dBinders(const std::array, 3>, 2>& /*input*/, std::array, 3>, 2>* /*repeated*/, std::array, 3>, 2>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status Repeat2dParcelables(const std::array, 2>& /*input*/, std::array, 2>* /*repeated*/, std::array, 2>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } }; // class IRepeatFixedSizeArrayDefault class BpRepeatFixedSizeArray : public ::android::BpInterface { public: explicit BpRepeatFixedSizeArray(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpRepeatFixedSizeArray() = default; ::android::binder::Status RepeatBytes(const std::array& input, std::array* repeated, std::array* _aidl_return) override; ::android::binder::Status RepeatInts(const std::array& input, std::array* repeated, std::array* _aidl_return) override; ::android::binder::Status RepeatBinders(const std::array<::android::sp<::android::IBinder>, 3>& input, std::array<::android::sp<::android::IBinder>, 3>* repeated, std::array<::android::sp<::android::IBinder>, 3>* _aidl_return) override; ::android::binder::Status RepeatParcelables(const std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>& input, std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* repeated, std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* _aidl_return) override; ::android::binder::Status Repeat2dBytes(const std::array, 2>& input, std::array, 2>* repeated, std::array, 2>* _aidl_return) override; ::android::binder::Status Repeat2dInts(const std::array, 2>& input, std::array, 2>* repeated, std::array, 2>* _aidl_return) override; ::android::binder::Status Repeat2dBinders(const std::array, 3>, 2>& input, std::array, 3>, 2>* repeated, std::array, 3>, 2>* _aidl_return) override; ::android::binder::Status Repeat2dParcelables(const std::array, 2>& input, std::array, 2>* repeated, std::array, 2>* _aidl_return) override; }; // class BpRepeatFixedSizeArray class BnRepeatFixedSizeArray : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_RepeatBytes = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_RepeatInts = ::android::IBinder::FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_RepeatBinders = ::android::IBinder::FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_RepeatParcelables = ::android::IBinder::FIRST_CALL_TRANSACTION + 3; static constexpr uint32_t TRANSACTION_Repeat2dBytes = ::android::IBinder::FIRST_CALL_TRANSACTION + 4; static constexpr uint32_t TRANSACTION_Repeat2dInts = ::android::IBinder::FIRST_CALL_TRANSACTION + 5; static constexpr uint32_t TRANSACTION_Repeat2dBinders = ::android::IBinder::FIRST_CALL_TRANSACTION + 6; static constexpr uint32_t TRANSACTION_Repeat2dParcelables = ::android::IBinder::FIRST_CALL_TRANSACTION + 7; explicit BnRepeatFixedSizeArray(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnRepeatFixedSizeArray class IRepeatFixedSizeArrayDelegator : public BnRepeatFixedSizeArray { public: explicit IRepeatFixedSizeArrayDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status RepeatBytes(const std::array& input, std::array* repeated, std::array* _aidl_return) override { return _aidl_delegate->RepeatBytes(input, repeated, _aidl_return); } ::android::binder::Status RepeatInts(const std::array& input, std::array* repeated, std::array* _aidl_return) override { return _aidl_delegate->RepeatInts(input, repeated, _aidl_return); } ::android::binder::Status RepeatBinders(const std::array<::android::sp<::android::IBinder>, 3>& input, std::array<::android::sp<::android::IBinder>, 3>* repeated, std::array<::android::sp<::android::IBinder>, 3>* _aidl_return) override { return _aidl_delegate->RepeatBinders(input, repeated, _aidl_return); } ::android::binder::Status RepeatParcelables(const std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>& input, std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* repeated, std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* _aidl_return) override { return _aidl_delegate->RepeatParcelables(input, repeated, _aidl_return); } ::android::binder::Status Repeat2dBytes(const std::array, 2>& input, std::array, 2>* repeated, std::array, 2>* _aidl_return) override { return _aidl_delegate->Repeat2dBytes(input, repeated, _aidl_return); } ::android::binder::Status Repeat2dInts(const std::array, 2>& input, std::array, 2>* repeated, std::array, 2>* _aidl_return) override { return _aidl_delegate->Repeat2dInts(input, repeated, _aidl_return); } ::android::binder::Status Repeat2dBinders(const std::array, 3>, 2>& input, std::array, 3>, 2>* repeated, std::array, 3>, 2>* _aidl_return) override { return _aidl_delegate->Repeat2dBinders(input, repeated, _aidl_return); } ::android::binder::Status Repeat2dParcelables(const std::array, 2>& input, std::array, 2>* repeated, std::array, 2>* _aidl_return) override { return _aidl_delegate->Repeat2dParcelables(input, repeated, _aidl_return); } private: ::android::sp _aidl_delegate; }; // class IRepeatFixedSizeArrayDelegator enum class ByteEnum : int8_t { A = 0, }; enum class IntEnum : int32_t { A = 0, }; enum class LongEnum : int64_t { A = 0L, }; class IEmptyInterfaceDelegator; class IEmptyInterface : public ::android::IInterface { public: typedef IEmptyInterfaceDelegator DefaultDelegator; DECLARE_META_INTERFACE(EmptyInterface) }; // class IEmptyInterface class IEmptyInterfaceDefault : public IEmptyInterface { public: ::android::IBinder* onAsBinder() override { return nullptr; } }; // class IEmptyInterfaceDefault class BpEmptyInterface : public ::android::BpInterface { public: explicit BpEmptyInterface(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpEmptyInterface() = default; }; // class BpEmptyInterface class BnEmptyInterface : public ::android::BnInterface { public: explicit BnEmptyInterface(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnEmptyInterface class IEmptyInterfaceDelegator : public BnEmptyInterface { public: explicit IEmptyInterfaceDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } private: ::android::sp _aidl_delegate; }; // class IEmptyInterfaceDelegator std::array, 2> int2x3 = {{{{1, 2, 3}}, {{4, 5, 6}}}}; std::array boolArray = {{}}; std::array byteArray = {{}}; std::array charArray = {{}}; std::array intArray = {{}}; std::array longArray = {{}}; std::array floatArray = {{}}; std::array doubleArray = {{}}; std::array<::std::string, 2> stringArray = {{"hello", "world"}}; std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::ByteEnum, 2> byteEnumArray = {{}}; std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntEnum, 2> intEnumArray = {{}}; std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::LongEnum, 2> longEnumArray = {{}}; std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 2> parcelableArray = {{}}; std::array, 2> boolMatrix = {{}}; std::array, 2> byteMatrix = {{}}; std::array, 2> charMatrix = {{}}; std::array, 2> intMatrix = {{}}; std::array, 2> longMatrix = {{}}; std::array, 2> floatMatrix = {{}}; std::array, 2> doubleMatrix = {{}}; std::array, 2> stringMatrix = {{{{"hello", "world"}}, {{"Ciao", "mondo"}}}}; std::array, 2> byteEnumMatrix = {{}}; std::array, 2> intEnumMatrix = {{}}; std::array, 2> longEnumMatrix = {{}}; std::array, 2> parcelableMatrix = {{}}; ::std::optional> boolNullableArray; ::std::optional> byteNullableArray; ::std::optional> charNullableArray; ::std::optional> intNullableArray; ::std::optional> longNullableArray; ::std::optional> floatNullableArray; ::std::optional> doubleNullableArray; ::std::optional, 2>> stringNullableArray = {{{"hello", "world"}}}; ::std::optional> byteEnumNullableArray; ::std::optional> intEnumNullableArray; ::std::optional> longEnumNullableArray; ::std::optional, 2>> binderNullableArray; ::std::optional, 2>> pfdNullableArray; ::std::optional, 2>> parcelableNullableArray; ::std::optional, 2>> interfaceNullableArray; ::std::optional, 2>> boolNullableMatrix; ::std::optional, 2>> byteNullableMatrix; ::std::optional, 2>> charNullableMatrix; ::std::optional, 2>> intNullableMatrix; ::std::optional, 2>> longNullableMatrix; ::std::optional, 2>> floatNullableMatrix; ::std::optional, 2>> doubleNullableMatrix; ::std::optional, 2>, 2>> stringNullableMatrix = {{{{{"hello", "world"}}, {{"Ciao", "mondo"}}}}}; ::std::optional, 2>> byteEnumNullableMatrix; ::std::optional, 2>> intEnumNullableMatrix; ::std::optional, 2>> longEnumNullableMatrix; ::std::optional, 2>, 2>> binderNullableMatrix; ::std::optional, 2>, 2>> pfdNullableMatrix; ::std::optional, 2>, 2>> parcelableNullableMatrix; ::std::optional, 2>, 2>> interfaceNullableMatrix; inline bool operator==(const FixedSizeArrayExample& _rhs) const { return std::tie(int2x3, boolArray, byteArray, charArray, intArray, longArray, floatArray, doubleArray, stringArray, byteEnumArray, intEnumArray, longEnumArray, parcelableArray, boolMatrix, byteMatrix, charMatrix, intMatrix, longMatrix, floatMatrix, doubleMatrix, stringMatrix, byteEnumMatrix, intEnumMatrix, longEnumMatrix, parcelableMatrix, boolNullableArray, byteNullableArray, charNullableArray, intNullableArray, longNullableArray, floatNullableArray, doubleNullableArray, stringNullableArray, byteEnumNullableArray, intEnumNullableArray, longEnumNullableArray, binderNullableArray, pfdNullableArray, parcelableNullableArray, interfaceNullableArray, boolNullableMatrix, byteNullableMatrix, charNullableMatrix, intNullableMatrix, longNullableMatrix, floatNullableMatrix, doubleNullableMatrix, stringNullableMatrix, byteEnumNullableMatrix, intEnumNullableMatrix, longEnumNullableMatrix, binderNullableMatrix, pfdNullableMatrix, parcelableNullableMatrix, interfaceNullableMatrix) == std::tie(_rhs.int2x3, _rhs.boolArray, _rhs.byteArray, _rhs.charArray, _rhs.intArray, _rhs.longArray, _rhs.floatArray, _rhs.doubleArray, _rhs.stringArray, _rhs.byteEnumArray, _rhs.intEnumArray, _rhs.longEnumArray, _rhs.parcelableArray, _rhs.boolMatrix, _rhs.byteMatrix, _rhs.charMatrix, _rhs.intMatrix, _rhs.longMatrix, _rhs.floatMatrix, _rhs.doubleMatrix, _rhs.stringMatrix, _rhs.byteEnumMatrix, _rhs.intEnumMatrix, _rhs.longEnumMatrix, _rhs.parcelableMatrix, _rhs.boolNullableArray, _rhs.byteNullableArray, _rhs.charNullableArray, _rhs.intNullableArray, _rhs.longNullableArray, _rhs.floatNullableArray, _rhs.doubleNullableArray, _rhs.stringNullableArray, _rhs.byteEnumNullableArray, _rhs.intEnumNullableArray, _rhs.longEnumNullableArray, _rhs.binderNullableArray, _rhs.pfdNullableArray, _rhs.parcelableNullableArray, _rhs.interfaceNullableArray, _rhs.boolNullableMatrix, _rhs.byteNullableMatrix, _rhs.charNullableMatrix, _rhs.intNullableMatrix, _rhs.longNullableMatrix, _rhs.floatNullableMatrix, _rhs.doubleNullableMatrix, _rhs.stringNullableMatrix, _rhs.byteEnumNullableMatrix, _rhs.intEnumNullableMatrix, _rhs.longEnumNullableMatrix, _rhs.binderNullableMatrix, _rhs.pfdNullableMatrix, _rhs.parcelableNullableMatrix, _rhs.interfaceNullableMatrix); } inline bool operator<(const FixedSizeArrayExample& _rhs) const { return std::tie(int2x3, boolArray, byteArray, charArray, intArray, longArray, floatArray, doubleArray, stringArray, byteEnumArray, intEnumArray, longEnumArray, parcelableArray, boolMatrix, byteMatrix, charMatrix, intMatrix, longMatrix, floatMatrix, doubleMatrix, stringMatrix, byteEnumMatrix, intEnumMatrix, longEnumMatrix, parcelableMatrix, boolNullableArray, byteNullableArray, charNullableArray, intNullableArray, longNullableArray, floatNullableArray, doubleNullableArray, stringNullableArray, byteEnumNullableArray, intEnumNullableArray, longEnumNullableArray, binderNullableArray, pfdNullableArray, parcelableNullableArray, interfaceNullableArray, boolNullableMatrix, byteNullableMatrix, charNullableMatrix, intNullableMatrix, longNullableMatrix, floatNullableMatrix, doubleNullableMatrix, stringNullableMatrix, byteEnumNullableMatrix, intEnumNullableMatrix, longEnumNullableMatrix, binderNullableMatrix, pfdNullableMatrix, parcelableNullableMatrix, interfaceNullableMatrix) < std::tie(_rhs.int2x3, _rhs.boolArray, _rhs.byteArray, _rhs.charArray, _rhs.intArray, _rhs.longArray, _rhs.floatArray, _rhs.doubleArray, _rhs.stringArray, _rhs.byteEnumArray, _rhs.intEnumArray, _rhs.longEnumArray, _rhs.parcelableArray, _rhs.boolMatrix, _rhs.byteMatrix, _rhs.charMatrix, _rhs.intMatrix, _rhs.longMatrix, _rhs.floatMatrix, _rhs.doubleMatrix, _rhs.stringMatrix, _rhs.byteEnumMatrix, _rhs.intEnumMatrix, _rhs.longEnumMatrix, _rhs.parcelableMatrix, _rhs.boolNullableArray, _rhs.byteNullableArray, _rhs.charNullableArray, _rhs.intNullableArray, _rhs.longNullableArray, _rhs.floatNullableArray, _rhs.doubleNullableArray, _rhs.stringNullableArray, _rhs.byteEnumNullableArray, _rhs.intEnumNullableArray, _rhs.longEnumNullableArray, _rhs.binderNullableArray, _rhs.pfdNullableArray, _rhs.parcelableNullableArray, _rhs.interfaceNullableArray, _rhs.boolNullableMatrix, _rhs.byteNullableMatrix, _rhs.charNullableMatrix, _rhs.intNullableMatrix, _rhs.longNullableMatrix, _rhs.floatNullableMatrix, _rhs.doubleNullableMatrix, _rhs.stringNullableMatrix, _rhs.byteEnumNullableMatrix, _rhs.intEnumNullableMatrix, _rhs.longEnumNullableMatrix, _rhs.binderNullableMatrix, _rhs.pfdNullableMatrix, _rhs.parcelableNullableMatrix, _rhs.interfaceNullableMatrix); } inline bool operator!=(const FixedSizeArrayExample& _rhs) const { return !(*this == _rhs); } inline bool operator>(const FixedSizeArrayExample& _rhs) const { return _rhs < *this; } inline bool operator>=(const FixedSizeArrayExample& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const FixedSizeArrayExample& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.fixedsizearray.FixedSizeArrayExample"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "FixedSizeArrayExample{"; _aidl_os << "int2x3: " << ::android::internal::ToString(int2x3); _aidl_os << ", boolArray: " << ::android::internal::ToString(boolArray); _aidl_os << ", byteArray: " << ::android::internal::ToString(byteArray); _aidl_os << ", charArray: " << ::android::internal::ToString(charArray); _aidl_os << ", intArray: " << ::android::internal::ToString(intArray); _aidl_os << ", longArray: " << ::android::internal::ToString(longArray); _aidl_os << ", floatArray: " << ::android::internal::ToString(floatArray); _aidl_os << ", doubleArray: " << ::android::internal::ToString(doubleArray); _aidl_os << ", stringArray: " << ::android::internal::ToString(stringArray); _aidl_os << ", byteEnumArray: " << ::android::internal::ToString(byteEnumArray); _aidl_os << ", intEnumArray: " << ::android::internal::ToString(intEnumArray); _aidl_os << ", longEnumArray: " << ::android::internal::ToString(longEnumArray); _aidl_os << ", parcelableArray: " << ::android::internal::ToString(parcelableArray); _aidl_os << ", boolMatrix: " << ::android::internal::ToString(boolMatrix); _aidl_os << ", byteMatrix: " << ::android::internal::ToString(byteMatrix); _aidl_os << ", charMatrix: " << ::android::internal::ToString(charMatrix); _aidl_os << ", intMatrix: " << ::android::internal::ToString(intMatrix); _aidl_os << ", longMatrix: " << ::android::internal::ToString(longMatrix); _aidl_os << ", floatMatrix: " << ::android::internal::ToString(floatMatrix); _aidl_os << ", doubleMatrix: " << ::android::internal::ToString(doubleMatrix); _aidl_os << ", stringMatrix: " << ::android::internal::ToString(stringMatrix); _aidl_os << ", byteEnumMatrix: " << ::android::internal::ToString(byteEnumMatrix); _aidl_os << ", intEnumMatrix: " << ::android::internal::ToString(intEnumMatrix); _aidl_os << ", longEnumMatrix: " << ::android::internal::ToString(longEnumMatrix); _aidl_os << ", parcelableMatrix: " << ::android::internal::ToString(parcelableMatrix); _aidl_os << ", boolNullableArray: " << ::android::internal::ToString(boolNullableArray); _aidl_os << ", byteNullableArray: " << ::android::internal::ToString(byteNullableArray); _aidl_os << ", charNullableArray: " << ::android::internal::ToString(charNullableArray); _aidl_os << ", intNullableArray: " << ::android::internal::ToString(intNullableArray); _aidl_os << ", longNullableArray: " << ::android::internal::ToString(longNullableArray); _aidl_os << ", floatNullableArray: " << ::android::internal::ToString(floatNullableArray); _aidl_os << ", doubleNullableArray: " << ::android::internal::ToString(doubleNullableArray); _aidl_os << ", stringNullableArray: " << ::android::internal::ToString(stringNullableArray); _aidl_os << ", byteEnumNullableArray: " << ::android::internal::ToString(byteEnumNullableArray); _aidl_os << ", intEnumNullableArray: " << ::android::internal::ToString(intEnumNullableArray); _aidl_os << ", longEnumNullableArray: " << ::android::internal::ToString(longEnumNullableArray); _aidl_os << ", binderNullableArray: " << ::android::internal::ToString(binderNullableArray); _aidl_os << ", pfdNullableArray: " << ::android::internal::ToString(pfdNullableArray); _aidl_os << ", parcelableNullableArray: " << ::android::internal::ToString(parcelableNullableArray); _aidl_os << ", interfaceNullableArray: " << ::android::internal::ToString(interfaceNullableArray); _aidl_os << ", boolNullableMatrix: " << ::android::internal::ToString(boolNullableMatrix); _aidl_os << ", byteNullableMatrix: " << ::android::internal::ToString(byteNullableMatrix); _aidl_os << ", charNullableMatrix: " << ::android::internal::ToString(charNullableMatrix); _aidl_os << ", intNullableMatrix: " << ::android::internal::ToString(intNullableMatrix); _aidl_os << ", longNullableMatrix: " << ::android::internal::ToString(longNullableMatrix); _aidl_os << ", floatNullableMatrix: " << ::android::internal::ToString(floatNullableMatrix); _aidl_os << ", doubleNullableMatrix: " << ::android::internal::ToString(doubleNullableMatrix); _aidl_os << ", stringNullableMatrix: " << ::android::internal::ToString(stringNullableMatrix); _aidl_os << ", byteEnumNullableMatrix: " << ::android::internal::ToString(byteEnumNullableMatrix); _aidl_os << ", intEnumNullableMatrix: " << ::android::internal::ToString(intEnumNullableMatrix); _aidl_os << ", longEnumNullableMatrix: " << ::android::internal::ToString(longEnumNullableMatrix); _aidl_os << ", binderNullableMatrix: " << ::android::internal::ToString(binderNullableMatrix); _aidl_os << ", pfdNullableMatrix: " << ::android::internal::ToString(pfdNullableMatrix); _aidl_os << ", parcelableNullableMatrix: " << ::android::internal::ToString(parcelableNullableMatrix); _aidl_os << ", interfaceNullableMatrix: " << ::android::internal::ToString(interfaceNullableMatrix); _aidl_os << "}"; return _aidl_os.str(); } }; // class FixedSizeArrayExample } // namespace fixedsizearray } // namespace aidl } // namespace android namespace android { namespace aidl { namespace fixedsizearray { [[nodiscard]] static inline std::string toString(FixedSizeArrayExample::ByteEnum val) { switch(val) { case FixedSizeArrayExample::ByteEnum::A: return "A"; default: return std::to_string(static_cast(val)); } } } // namespace fixedsizearray } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::ByteEnum, 1> enum_values<::android::aidl::fixedsizearray::FixedSizeArrayExample::ByteEnum> = { ::android::aidl::fixedsizearray::FixedSizeArrayExample::ByteEnum::A, }; #pragma clang diagnostic pop } // namespace internal } // namespace android namespace android { namespace aidl { namespace fixedsizearray { [[nodiscard]] static inline std::string toString(FixedSizeArrayExample::IntEnum val) { switch(val) { case FixedSizeArrayExample::IntEnum::A: return "A"; default: return std::to_string(static_cast(val)); } } } // namespace fixedsizearray } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntEnum, 1> enum_values<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntEnum> = { ::android::aidl::fixedsizearray::FixedSizeArrayExample::IntEnum::A, }; #pragma clang diagnostic pop } // namespace internal } // namespace android namespace android { namespace aidl { namespace fixedsizearray { [[nodiscard]] static inline std::string toString(FixedSizeArrayExample::LongEnum val) { switch(val) { case FixedSizeArrayExample::LongEnum::A: return "A"; default: return std::to_string(static_cast(val)); } } } // namespace fixedsizearray } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::LongEnum, 1> enum_values<::android::aidl::fixedsizearray::FixedSizeArrayExample::LongEnum> = { ::android::aidl::fixedsizearray::FixedSizeArrayExample::LongEnum::A, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-cpp-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 030320 xustar000000000 0000000 28 mtime=1776853188.3910000 tests/golden_output/aidl-test-fixedsizearray-cpp-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 025312 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-java-source_0100644 0000000 0000000 00000000034 15172120304 025702 xustar000000000 0000000 28 mtime=1776853188.3910000 tests/golden_output/aidl-test-fixedsizearray-java-source/0040755 0000000 0000000 00000000000 15172120304 022767 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-java-source_gen_0100644 0000000 0000000 00000000034 15172120304 026533 xustar000000000 0000000 28 mtime=1776853188.3910000 tests/golden_output/aidl-test-fixedsizearray-java-source/gen/0040755 0000000 0000000 00000000000 15172120304 023540 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-java-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 030233 xustar000000000 0000000 28 mtime=1776853188.3910000 tests/golden_output/aidl-test-fixedsizearray-java-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 025160 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-java-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 031224 xustar000000000 0000000 28 mtime=1776853188.3910000 tests/golden_output/aidl-test-fixedsizearray-java-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 026071 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-java-source_gen_android_aidl_fixedsizea0100644 0000000 0000000 00000000034 15172120304 033300 xustar000000000 0000000 28 mtime=1776853188.3910000 tests/golden_output/aidl-test-fixedsizearray-java-source/gen/android/aidl/fixedsizearray/0040755 0000000 0000000 00000000000 15172120304 031122 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-java-source_gen_android_aidl_fixedsizea0100644 0000000 0000000 00000000231 15172120304 033277 xustar000000000 0000000 125 path=tests/golden_output/aidl-test-fixedsizearray-java-source/gen/android/aidl/fixedsizearray/FixedSizeArrayExample.java 28 mtime=1776853188.3910000 tests/golden_output/aidl-test-fixedsizearray-java-source/gen/android/aidl/fixedsizearray/FixedSizeAr0100644 0000000 0000000 00000140660 15172120304 033226 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-java-source/gen/android/aidl/fixedsizearray/FixedSizeArrayExample.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/fixedsizearray/FixedSizeArrayExample.aidl */ package android.aidl.fixedsizearray; public class FixedSizeArrayExample implements android.os.Parcelable { // to see if NxM array works public int[][] int2x3 = {{1, 2, 3}, {4, 5, 6}}; public boolean[] boolArray; public byte[] byteArray; public char[] charArray; public int[] intArray; public long[] longArray; public float[] floatArray; public double[] doubleArray; public java.lang.String[] stringArray = {"hello", "world"}; public byte[] byteEnumArray; public int[] intEnumArray; public long[] longEnumArray; public android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[] parcelableArray; // Following fields are not test-friendly because they should be initialized as non-null. // IBinder[2] binderArray; // ParcelFileDescriptor[2] pfdArray; // IEmptyInterface[2] interfaceArray; public boolean[][] boolMatrix; public byte[][] byteMatrix; public char[][] charMatrix; public int[][] intMatrix; public long[][] longMatrix; public float[][] floatMatrix; public double[][] doubleMatrix; public java.lang.String[][] stringMatrix = {{"hello", "world"}, {"Ciao", "mondo"}}; public byte[][] byteEnumMatrix; public int[][] intEnumMatrix; public long[][] longEnumMatrix; public android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][] parcelableMatrix; // Following fields are not test-friendly because they should be initialized as non-null. // ParcelFileDescriptor[2][2] pfdMatrix; // IBinder[2][2] binderMatrix; // IEmptyInterface[2][2] interfaceMatrix; public boolean[] boolNullableArray; public byte[] byteNullableArray; public char[] charNullableArray; public int[] intNullableArray; public long[] longNullableArray; public float[] floatNullableArray; public double[] doubleNullableArray; public java.lang.String[] stringNullableArray = {"hello", "world"}; public byte[] byteEnumNullableArray; public int[] intEnumNullableArray; public long[] longEnumNullableArray; public android.os.IBinder[] binderNullableArray; public android.os.ParcelFileDescriptor[] pfdNullableArray; public android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[] parcelableNullableArray; public android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface[] interfaceNullableArray; public boolean[][] boolNullableMatrix; public byte[][] byteNullableMatrix; public char[][] charNullableMatrix; public int[][] intNullableMatrix; public long[][] longNullableMatrix; public float[][] floatNullableMatrix; public double[][] doubleNullableMatrix; public java.lang.String[][] stringNullableMatrix = {{"hello", "world"}, {"Ciao", "mondo"}}; public byte[][] byteEnumNullableMatrix; public int[][] intEnumNullableMatrix; public long[][] longEnumNullableMatrix; public android.os.IBinder[][] binderNullableMatrix; public android.os.ParcelFileDescriptor[][] pfdNullableMatrix; public android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][] parcelableNullableMatrix; public android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface[][] interfaceNullableMatrix; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public FixedSizeArrayExample createFromParcel(android.os.Parcel _aidl_source) { FixedSizeArrayExample _aidl_out = new FixedSizeArrayExample(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public FixedSizeArrayExample[] newArray(int _aidl_size) { return new FixedSizeArrayExample[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeFixedArray(int2x3, _aidl_flag, 2, 3); _aidl_parcel.writeFixedArray(boolArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(byteArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(charArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(intArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(longArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(floatArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(doubleArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(stringArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(byteEnumArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(intEnumArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(longEnumArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(parcelableArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(boolMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(byteMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(charMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(intMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(longMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(floatMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(doubleMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(stringMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(byteEnumMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(intEnumMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(longEnumMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(parcelableMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(boolNullableArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(byteNullableArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(charNullableArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(intNullableArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(longNullableArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(floatNullableArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(doubleNullableArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(stringNullableArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(byteEnumNullableArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(intEnumNullableArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(longEnumNullableArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(binderNullableArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(pfdNullableArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(parcelableNullableArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(interfaceNullableArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(boolNullableMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(byteNullableMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(charNullableMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(intNullableMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(longNullableMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(floatNullableMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(doubleNullableMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(stringNullableMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(byteEnumNullableMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(intEnumNullableMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(longEnumNullableMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(binderNullableMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(pfdNullableMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(parcelableNullableMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(interfaceNullableMatrix, _aidl_flag, 2, 2); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; int2x3 = _aidl_parcel.createFixedArray(int[][].class, 2, 3); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; boolArray = _aidl_parcel.createFixedArray(boolean[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; byteArray = _aidl_parcel.createFixedArray(byte[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; charArray = _aidl_parcel.createFixedArray(char[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; intArray = _aidl_parcel.createFixedArray(int[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; longArray = _aidl_parcel.createFixedArray(long[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; floatArray = _aidl_parcel.createFixedArray(float[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; doubleArray = _aidl_parcel.createFixedArray(double[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; stringArray = _aidl_parcel.createFixedArray(java.lang.String[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; byteEnumArray = _aidl_parcel.createFixedArray(byte[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; intEnumArray = _aidl_parcel.createFixedArray(int[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; longEnumArray = _aidl_parcel.createFixedArray(long[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; parcelableArray = _aidl_parcel.createFixedArray(android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[].class, android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable.CREATOR, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; boolMatrix = _aidl_parcel.createFixedArray(boolean[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; byteMatrix = _aidl_parcel.createFixedArray(byte[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; charMatrix = _aidl_parcel.createFixedArray(char[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; intMatrix = _aidl_parcel.createFixedArray(int[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; longMatrix = _aidl_parcel.createFixedArray(long[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; floatMatrix = _aidl_parcel.createFixedArray(float[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; doubleMatrix = _aidl_parcel.createFixedArray(double[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; stringMatrix = _aidl_parcel.createFixedArray(java.lang.String[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; byteEnumMatrix = _aidl_parcel.createFixedArray(byte[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; intEnumMatrix = _aidl_parcel.createFixedArray(int[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; longEnumMatrix = _aidl_parcel.createFixedArray(long[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; parcelableMatrix = _aidl_parcel.createFixedArray(android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][].class, android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable.CREATOR, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; boolNullableArray = _aidl_parcel.createFixedArray(boolean[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; byteNullableArray = _aidl_parcel.createFixedArray(byte[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; charNullableArray = _aidl_parcel.createFixedArray(char[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; intNullableArray = _aidl_parcel.createFixedArray(int[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; longNullableArray = _aidl_parcel.createFixedArray(long[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; floatNullableArray = _aidl_parcel.createFixedArray(float[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; doubleNullableArray = _aidl_parcel.createFixedArray(double[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; stringNullableArray = _aidl_parcel.createFixedArray(java.lang.String[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; byteEnumNullableArray = _aidl_parcel.createFixedArray(byte[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; intEnumNullableArray = _aidl_parcel.createFixedArray(int[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; longEnumNullableArray = _aidl_parcel.createFixedArray(long[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; binderNullableArray = _aidl_parcel.createFixedArray(android.os.IBinder[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; pfdNullableArray = _aidl_parcel.createFixedArray(android.os.ParcelFileDescriptor[].class, android.os.ParcelFileDescriptor.CREATOR, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; parcelableNullableArray = _aidl_parcel.createFixedArray(android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[].class, android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable.CREATOR, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; interfaceNullableArray = _aidl_parcel.createFixedArray(android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface[].class, android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface.Stub::asInterface, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; boolNullableMatrix = _aidl_parcel.createFixedArray(boolean[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; byteNullableMatrix = _aidl_parcel.createFixedArray(byte[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; charNullableMatrix = _aidl_parcel.createFixedArray(char[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; intNullableMatrix = _aidl_parcel.createFixedArray(int[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; longNullableMatrix = _aidl_parcel.createFixedArray(long[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; floatNullableMatrix = _aidl_parcel.createFixedArray(float[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; doubleNullableMatrix = _aidl_parcel.createFixedArray(double[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; stringNullableMatrix = _aidl_parcel.createFixedArray(java.lang.String[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; byteEnumNullableMatrix = _aidl_parcel.createFixedArray(byte[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; intEnumNullableMatrix = _aidl_parcel.createFixedArray(int[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; longEnumNullableMatrix = _aidl_parcel.createFixedArray(long[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; binderNullableMatrix = _aidl_parcel.createFixedArray(android.os.IBinder[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; pfdNullableMatrix = _aidl_parcel.createFixedArray(android.os.ParcelFileDescriptor[][].class, android.os.ParcelFileDescriptor.CREATOR, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; parcelableNullableMatrix = _aidl_parcel.createFixedArray(android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][].class, android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable.CREATOR, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; interfaceNullableMatrix = _aidl_parcel.createFixedArray(android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface[][].class, android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface.Stub::asInterface, 2, 2); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public String toString() { java.util.StringJoiner _aidl_sj = new java.util.StringJoiner(", ", "{", "}"); _aidl_sj.add("int2x3: " + (java.util.Arrays.deepToString(int2x3))); _aidl_sj.add("boolArray: " + (java.util.Arrays.toString(boolArray))); _aidl_sj.add("byteArray: " + (java.util.Arrays.toString(byteArray))); _aidl_sj.add("charArray: " + (java.util.Arrays.toString(charArray))); _aidl_sj.add("intArray: " + (java.util.Arrays.toString(intArray))); _aidl_sj.add("longArray: " + (java.util.Arrays.toString(longArray))); _aidl_sj.add("floatArray: " + (java.util.Arrays.toString(floatArray))); _aidl_sj.add("doubleArray: " + (java.util.Arrays.toString(doubleArray))); _aidl_sj.add("stringArray: " + (java.util.Arrays.toString(stringArray))); _aidl_sj.add("byteEnumArray: " + (java.util.Arrays.toString(byteEnumArray))); _aidl_sj.add("intEnumArray: " + (java.util.Arrays.toString(intEnumArray))); _aidl_sj.add("longEnumArray: " + (java.util.Arrays.toString(longEnumArray))); _aidl_sj.add("parcelableArray: " + (java.util.Arrays.toString(parcelableArray))); _aidl_sj.add("boolMatrix: " + (java.util.Arrays.deepToString(boolMatrix))); _aidl_sj.add("byteMatrix: " + (java.util.Arrays.deepToString(byteMatrix))); _aidl_sj.add("charMatrix: " + (java.util.Arrays.deepToString(charMatrix))); _aidl_sj.add("intMatrix: " + (java.util.Arrays.deepToString(intMatrix))); _aidl_sj.add("longMatrix: " + (java.util.Arrays.deepToString(longMatrix))); _aidl_sj.add("floatMatrix: " + (java.util.Arrays.deepToString(floatMatrix))); _aidl_sj.add("doubleMatrix: " + (java.util.Arrays.deepToString(doubleMatrix))); _aidl_sj.add("stringMatrix: " + (java.util.Arrays.deepToString(stringMatrix))); _aidl_sj.add("byteEnumMatrix: " + (java.util.Arrays.deepToString(byteEnumMatrix))); _aidl_sj.add("intEnumMatrix: " + (java.util.Arrays.deepToString(intEnumMatrix))); _aidl_sj.add("longEnumMatrix: " + (java.util.Arrays.deepToString(longEnumMatrix))); _aidl_sj.add("parcelableMatrix: " + (java.util.Arrays.deepToString(parcelableMatrix))); _aidl_sj.add("boolNullableArray: " + (java.util.Arrays.toString(boolNullableArray))); _aidl_sj.add("byteNullableArray: " + (java.util.Arrays.toString(byteNullableArray))); _aidl_sj.add("charNullableArray: " + (java.util.Arrays.toString(charNullableArray))); _aidl_sj.add("intNullableArray: " + (java.util.Arrays.toString(intNullableArray))); _aidl_sj.add("longNullableArray: " + (java.util.Arrays.toString(longNullableArray))); _aidl_sj.add("floatNullableArray: " + (java.util.Arrays.toString(floatNullableArray))); _aidl_sj.add("doubleNullableArray: " + (java.util.Arrays.toString(doubleNullableArray))); _aidl_sj.add("stringNullableArray: " + (java.util.Arrays.toString(stringNullableArray))); _aidl_sj.add("byteEnumNullableArray: " + (java.util.Arrays.toString(byteEnumNullableArray))); _aidl_sj.add("intEnumNullableArray: " + (java.util.Arrays.toString(intEnumNullableArray))); _aidl_sj.add("longEnumNullableArray: " + (java.util.Arrays.toString(longEnumNullableArray))); _aidl_sj.add("binderNullableArray: " + (java.util.Arrays.toString(binderNullableArray))); _aidl_sj.add("pfdNullableArray: " + (java.util.Arrays.toString(pfdNullableArray))); _aidl_sj.add("parcelableNullableArray: " + (java.util.Arrays.toString(parcelableNullableArray))); _aidl_sj.add("interfaceNullableArray: " + (java.util.Arrays.toString(interfaceNullableArray))); _aidl_sj.add("boolNullableMatrix: " + (java.util.Arrays.deepToString(boolNullableMatrix))); _aidl_sj.add("byteNullableMatrix: " + (java.util.Arrays.deepToString(byteNullableMatrix))); _aidl_sj.add("charNullableMatrix: " + (java.util.Arrays.deepToString(charNullableMatrix))); _aidl_sj.add("intNullableMatrix: " + (java.util.Arrays.deepToString(intNullableMatrix))); _aidl_sj.add("longNullableMatrix: " + (java.util.Arrays.deepToString(longNullableMatrix))); _aidl_sj.add("floatNullableMatrix: " + (java.util.Arrays.deepToString(floatNullableMatrix))); _aidl_sj.add("doubleNullableMatrix: " + (java.util.Arrays.deepToString(doubleNullableMatrix))); _aidl_sj.add("stringNullableMatrix: " + (java.util.Arrays.deepToString(stringNullableMatrix))); _aidl_sj.add("byteEnumNullableMatrix: " + (java.util.Arrays.deepToString(byteEnumNullableMatrix))); _aidl_sj.add("intEnumNullableMatrix: " + (java.util.Arrays.deepToString(intEnumNullableMatrix))); _aidl_sj.add("longEnumNullableMatrix: " + (java.util.Arrays.deepToString(longEnumNullableMatrix))); _aidl_sj.add("binderNullableMatrix: " + (java.util.Arrays.deepToString(binderNullableMatrix))); _aidl_sj.add("pfdNullableMatrix: " + (java.util.Arrays.deepToString(pfdNullableMatrix))); _aidl_sj.add("parcelableNullableMatrix: " + (java.util.Arrays.deepToString(parcelableNullableMatrix))); _aidl_sj.add("interfaceNullableMatrix: " + (java.util.Arrays.deepToString(interfaceNullableMatrix))); return "FixedSizeArrayExample" + _aidl_sj.toString() ; } @Override public int describeContents() { int _mask = 0; _mask |= describeContents(parcelableArray); _mask |= describeContents(parcelableMatrix); _mask |= describeContents(pfdNullableArray); _mask |= describeContents(parcelableNullableArray); _mask |= describeContents(pfdNullableMatrix); _mask |= describeContents(parcelableNullableMatrix); return _mask; } private int describeContents(Object _v) { if (_v == null) return 0; if (_v instanceof Object[]) { int _mask = 0; for (Object o : (Object[]) _v) { _mask |= describeContents(o); } return _mask; } if (_v instanceof android.os.Parcelable) { return ((android.os.Parcelable) _v).describeContents(); } return 0; } public interface IRepeatFixedSizeArray extends android.os.IInterface { /** Default implementation for IRepeatFixedSizeArray. */ public static class Default implements android.aidl.fixedsizearray.FixedSizeArrayExample.IRepeatFixedSizeArray { @Override public byte[] RepeatBytes(byte[] input, byte[] repeated) throws android.os.RemoteException { return null; } @Override public int[] RepeatInts(int[] input, int[] repeated) throws android.os.RemoteException { return null; } @Override public android.os.IBinder[] RepeatBinders(android.os.IBinder[] input, android.os.IBinder[] repeated) throws android.os.RemoteException { return null; } @Override public android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[] RepeatParcelables(android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[] input, android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[] repeated) throws android.os.RemoteException { return null; } @Override public byte[][] Repeat2dBytes(byte[][] input, byte[][] repeated) throws android.os.RemoteException { return null; } @Override public int[][] Repeat2dInts(int[][] input, int[][] repeated) throws android.os.RemoteException { return null; } @Override public android.os.IBinder[][] Repeat2dBinders(android.os.IBinder[][] input, android.os.IBinder[][] repeated) throws android.os.RemoteException { return null; } @Override public android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][] Repeat2dParcelables(android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][] input, android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][] repeated) throws android.os.RemoteException { return null; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.fixedsizearray.FixedSizeArrayExample.IRepeatFixedSizeArray { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.fixedsizearray.FixedSizeArrayExample.IRepeatFixedSizeArray interface, * generating a proxy if needed. */ public static android.aidl.fixedsizearray.FixedSizeArrayExample.IRepeatFixedSizeArray asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.fixedsizearray.FixedSizeArrayExample.IRepeatFixedSizeArray))) { return ((android.aidl.fixedsizearray.FixedSizeArrayExample.IRepeatFixedSizeArray)iin); } return new android.aidl.fixedsizearray.FixedSizeArrayExample.IRepeatFixedSizeArray.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_RepeatBytes: { byte[] _arg0; _arg0 = data.createFixedArray(byte[].class, 3); byte[] _arg1; _arg1 = new byte[3]; data.enforceNoDataAvail(); byte[] _result = this.RepeatBytes(_arg0, _arg1); reply.writeNoException(); reply.writeFixedArray(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE, 3); reply.writeFixedArray(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE, 3); break; } case TRANSACTION_RepeatInts: { int[] _arg0; _arg0 = data.createFixedArray(int[].class, 3); int[] _arg1; _arg1 = new int[3]; data.enforceNoDataAvail(); int[] _result = this.RepeatInts(_arg0, _arg1); reply.writeNoException(); reply.writeFixedArray(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE, 3); reply.writeFixedArray(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE, 3); break; } case TRANSACTION_RepeatBinders: { android.os.IBinder[] _arg0; _arg0 = data.createFixedArray(android.os.IBinder[].class, 3); android.os.IBinder[] _arg1; _arg1 = new android.os.IBinder[3]; data.enforceNoDataAvail(); android.os.IBinder[] _result = this.RepeatBinders(_arg0, _arg1); reply.writeNoException(); reply.writeFixedArray(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE, 3); reply.writeFixedArray(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE, 3); break; } case TRANSACTION_RepeatParcelables: { android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[] _arg0; _arg0 = data.createFixedArray(android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[].class, android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable.CREATOR, 3); android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[] _arg1; _arg1 = new android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[3]; data.enforceNoDataAvail(); android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[] _result = this.RepeatParcelables(_arg0, _arg1); reply.writeNoException(); reply.writeFixedArray(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE, 3); reply.writeFixedArray(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE, 3); break; } case TRANSACTION_Repeat2dBytes: { byte[][] _arg0; _arg0 = data.createFixedArray(byte[][].class, 2, 3); byte[][] _arg1; _arg1 = new byte[2][3]; data.enforceNoDataAvail(); byte[][] _result = this.Repeat2dBytes(_arg0, _arg1); reply.writeNoException(); reply.writeFixedArray(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE, 2, 3); reply.writeFixedArray(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE, 2, 3); break; } case TRANSACTION_Repeat2dInts: { int[][] _arg0; _arg0 = data.createFixedArray(int[][].class, 2, 3); int[][] _arg1; _arg1 = new int[2][3]; data.enforceNoDataAvail(); int[][] _result = this.Repeat2dInts(_arg0, _arg1); reply.writeNoException(); reply.writeFixedArray(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE, 2, 3); reply.writeFixedArray(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE, 2, 3); break; } case TRANSACTION_Repeat2dBinders: { android.os.IBinder[][] _arg0; _arg0 = data.createFixedArray(android.os.IBinder[][].class, 2, 3); android.os.IBinder[][] _arg1; _arg1 = new android.os.IBinder[2][3]; data.enforceNoDataAvail(); android.os.IBinder[][] _result = this.Repeat2dBinders(_arg0, _arg1); reply.writeNoException(); reply.writeFixedArray(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE, 2, 3); reply.writeFixedArray(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE, 2, 3); break; } case TRANSACTION_Repeat2dParcelables: { android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][] _arg0; _arg0 = data.createFixedArray(android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][].class, android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable.CREATOR, 2, 3); android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][] _arg1; _arg1 = new android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[2][3]; data.enforceNoDataAvail(); android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][] _result = this.Repeat2dParcelables(_arg0, _arg1); reply.writeNoException(); reply.writeFixedArray(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE, 2, 3); reply.writeFixedArray(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE, 2, 3); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.fixedsizearray.FixedSizeArrayExample.IRepeatFixedSizeArray { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public byte[] RepeatBytes(byte[] input, byte[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); byte[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeFixedArray(input, 0, 3); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatBytes, _data, _reply, 0); _reply.readException(); _result = _reply.createFixedArray(byte[].class, 3); _reply.readFixedArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int[] RepeatInts(int[] input, int[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); int[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeFixedArray(input, 0, 3); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatInts, _data, _reply, 0); _reply.readException(); _result = _reply.createFixedArray(int[].class, 3); _reply.readFixedArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.os.IBinder[] RepeatBinders(android.os.IBinder[] input, android.os.IBinder[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.os.IBinder[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeFixedArray(input, 0, 3); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatBinders, _data, _reply, 0); _reply.readException(); _result = _reply.createFixedArray(android.os.IBinder[].class, 3); _reply.readFixedArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[] RepeatParcelables(android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[] input, android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeFixedArray(input, 0, 3); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatParcelables, _data, _reply, 0); _reply.readException(); _result = _reply.createFixedArray(android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[].class, android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable.CREATOR, 3); _reply.readFixedArray(repeated, android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public byte[][] Repeat2dBytes(byte[][] input, byte[][] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); byte[][] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeFixedArray(input, 0, 2, 3); boolean _status = mRemote.transact(Stub.TRANSACTION_Repeat2dBytes, _data, _reply, 0); _reply.readException(); _result = _reply.createFixedArray(byte[][].class, 2, 3); _reply.readFixedArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int[][] Repeat2dInts(int[][] input, int[][] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); int[][] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeFixedArray(input, 0, 2, 3); boolean _status = mRemote.transact(Stub.TRANSACTION_Repeat2dInts, _data, _reply, 0); _reply.readException(); _result = _reply.createFixedArray(int[][].class, 2, 3); _reply.readFixedArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.os.IBinder[][] Repeat2dBinders(android.os.IBinder[][] input, android.os.IBinder[][] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.os.IBinder[][] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeFixedArray(input, 0, 2, 3); boolean _status = mRemote.transact(Stub.TRANSACTION_Repeat2dBinders, _data, _reply, 0); _reply.readException(); _result = _reply.createFixedArray(android.os.IBinder[][].class, 2, 3); _reply.readFixedArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][] Repeat2dParcelables(android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][] input, android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeFixedArray(input, 0, 2, 3); boolean _status = mRemote.transact(Stub.TRANSACTION_Repeat2dParcelables, _data, _reply, 0); _reply.readException(); _result = _reply.createFixedArray(android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][].class, android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable.CREATOR, 2, 3); _reply.readFixedArray(repeated, android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } } static final int TRANSACTION_RepeatBytes = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); static final int TRANSACTION_RepeatInts = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1); static final int TRANSACTION_RepeatBinders = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2); static final int TRANSACTION_RepeatParcelables = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3); static final int TRANSACTION_Repeat2dBytes = (android.os.IBinder.FIRST_CALL_TRANSACTION + 4); static final int TRANSACTION_Repeat2dInts = (android.os.IBinder.FIRST_CALL_TRANSACTION + 5); static final int TRANSACTION_Repeat2dBinders = (android.os.IBinder.FIRST_CALL_TRANSACTION + 6); static final int TRANSACTION_Repeat2dParcelables = (android.os.IBinder.FIRST_CALL_TRANSACTION + 7); } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.fixedsizearray.FixedSizeArrayExample.IRepeatFixedSizeArray"; public byte[] RepeatBytes(byte[] input, byte[] repeated) throws android.os.RemoteException; public int[] RepeatInts(int[] input, int[] repeated) throws android.os.RemoteException; public android.os.IBinder[] RepeatBinders(android.os.IBinder[] input, android.os.IBinder[] repeated) throws android.os.RemoteException; public android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[] RepeatParcelables(android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[] input, android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[] repeated) throws android.os.RemoteException; public byte[][] Repeat2dBytes(byte[][] input, byte[][] repeated) throws android.os.RemoteException; public int[][] Repeat2dInts(int[][] input, int[][] repeated) throws android.os.RemoteException; public android.os.IBinder[][] Repeat2dBinders(android.os.IBinder[][] input, android.os.IBinder[][] repeated) throws android.os.RemoteException; public android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][] Repeat2dParcelables(android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][] input, android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][] repeated) throws android.os.RemoteException; } public static @interface ByteEnum { public static final byte A = 0; } public static @interface IntEnum { public static final int A = 0; } public static @interface LongEnum { public static final long A = 0L; } public static class IntParcelable implements android.os.Parcelable { public int value = 0; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public IntParcelable createFromParcel(android.os.Parcel _aidl_source) { IntParcelable _aidl_out = new IntParcelable(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public IntParcelable[] newArray(int _aidl_size) { return new IntParcelable[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(value); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; value = _aidl_parcel.readInt(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public boolean equals(Object other) { if (this == other) return true; if (other == null) return false; if (!(other instanceof IntParcelable)) return false; IntParcelable that = (IntParcelable)other; if (!java.util.Objects.deepEquals(value, that.value)) return false; return true; } @Override public int hashCode() { return java.util.Arrays.deepHashCode(java.util.Arrays.asList(value).toArray()); } @Override public int describeContents() { int _mask = 0; return _mask; } } public interface IEmptyInterface extends android.os.IInterface { /** Default implementation for IEmptyInterface. */ public static class Default implements android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface { @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface interface, * generating a proxy if needed. */ public static android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface))) { return ((android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface)iin); } return new android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { default: { return super.onTransact(code, data, reply, flags); } } } private static class Proxy implements android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface"; } } ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-java-source_gen_android_aidl_fixedsizea0100644 0000000 0000000 00000000233 15172120304 033301 xustar000000000 0000000 127 path=tests/golden_output/aidl-test-fixedsizearray-java-source/gen/android/aidl/fixedsizearray/FixedSizeArrayExample.java.d 28 mtime=1776853188.3920000 tests/golden_output/aidl-test-fixedsizearray-java-source/gen/android/aidl/fixedsizearray/FixedSizeAr0100644 0000000 0000000 00000000340 15172120304 033214 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-java-source/gen/android/aidl/fixedsizearray/FixedSizeArrayExample.java : \ system/tools/aidl/tests/android/aidl/fixedsizearray/FixedSizeArrayExample.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-java-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 030457 xustar000000000 0000000 28 mtime=1776853188.3920000 tests/golden_output/aidl-test-fixedsizearray-java-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 025451 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-ndk-source_0100644 0000000 0000000 00000000034 15172120304 025535 xustar000000000 0000000 28 mtime=1776853188.3920000 tests/golden_output/aidl-test-fixedsizearray-ndk-source/0040755 0000000 0000000 00000000000 15172120304 022622 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-ndk-source_gen_0100644 0000000 0000000 00000000034 15172120304 026366 xustar000000000 0000000 28 mtime=1776853188.3920000 tests/golden_output/aidl-test-fixedsizearray-ndk-source/gen/0040755 0000000 0000000 00000000000 15172120304 023373 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-ndk-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 030066 xustar000000000 0000000 28 mtime=1776853188.3920000 tests/golden_output/aidl-test-fixedsizearray-ndk-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 025013 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-ndk-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 031057 xustar000000000 0000000 28 mtime=1776853188.3920000 tests/golden_output/aidl-test-fixedsizearray-ndk-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 025724 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-ndk-source_gen_android_aidl_fixedsizear0100644 0000000 0000000 00000000034 15172120304 033315 xustar000000000 0000000 28 mtime=1776853188.3920000 tests/golden_output/aidl-test-fixedsizearray-ndk-source/gen/android/aidl/fixedsizearray/0040755 0000000 0000000 00000000000 15172120304 030755 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-ndk-source_gen_android_aidl_fixedsizear0100644 0000000 0000000 00000000227 15172120304 033321 xustar000000000 0000000 123 path=tests/golden_output/aidl-test-fixedsizearray-ndk-source/gen/android/aidl/fixedsizearray/FixedSizeArrayExample.cpp 28 mtime=1776853188.3950000 tests/golden_output/aidl-test-fixedsizearray-ndk-source/gen/android/aidl/fixedsizearray/FixedSizeArr0100644 0000000 0000000 00000202147 15172120304 033242 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-ndk-source/gen/staging/android/aidl/fixedsizearray/FixedSizeArrayExample.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/fixedsizearray/FixedSizeArrayExample.aidl */ #include "aidl/android/aidl/fixedsizearray/FixedSizeArrayExample.h" #include namespace aidl { namespace android { namespace aidl { namespace fixedsizearray { const char* FixedSizeArrayExample::descriptor = "android.aidl.fixedsizearray.FixedSizeArrayExample"; binder_status_t FixedSizeArrayExample::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &int2x3); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &boolArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &byteArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &charArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &intArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &longArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &floatArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &doubleArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &stringArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &byteEnumArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &intEnumArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &longEnumArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &parcelableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &boolMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &byteMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &charMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &intMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &longMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &floatMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &doubleMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &stringMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &byteEnumMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &intEnumMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &longEnumMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &parcelableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &boolNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &byteNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &charNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &intNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &longNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &floatNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &doubleNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &stringNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &byteEnumNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &intEnumNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &longEnumNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &binderNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &pfdNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &parcelableNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &interfaceNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &boolNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &byteNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &charNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &intNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &longNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &floatNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &doubleNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &stringNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &byteEnumNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &intEnumNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &longEnumNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &binderNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &pfdNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &parcelableNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &interfaceNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t FixedSizeArrayExample::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, int2x3); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, boolArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, byteArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, charArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, intArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, longArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, floatArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, doubleArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, stringArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, byteEnumArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, intEnumArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, longEnumArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, parcelableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, boolMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, byteMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, charMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, intMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, longMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, floatMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, doubleMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, stringMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, byteEnumMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, intEnumMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, longEnumMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, parcelableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, boolNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, byteNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, charNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, intNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, longNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, floatNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, doubleNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, stringNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, byteEnumNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, intEnumNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, longEnumNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, binderNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, pfdNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, parcelableNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, interfaceNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, boolNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, byteNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, charNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, intNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, longNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, floatNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, doubleNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, stringNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, byteEnumNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, intEnumNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, longEnumNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, binderNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, pfdNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, parcelableNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, interfaceNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace fixedsizearray } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace fixedsizearray { static binder_status_t _aidl_android_aidl_fixedsizearray_FixedSizeArrayExample_IRepeatFixedSizeArray_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*RepeatBytes*/): { std::array in_input; std::array out_repeated; std::array _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatBytes(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 1 /*RepeatInts*/): { std::array in_input; std::array out_repeated; std::array _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatInts(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 2 /*RepeatBinders*/): { std::array<::ndk::SpAIBinder, 3> in_input; std::array<::ndk::SpAIBinder, 3> out_repeated; std::array<::ndk::SpAIBinder, 3> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatBinders(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 3 /*RepeatParcelables*/): { std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3> in_input; std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3> out_repeated; std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatParcelables(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 4 /*Repeat2dBytes*/): { std::array, 2> in_input; std::array, 2> out_repeated; std::array, 2> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->Repeat2dBytes(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 5 /*Repeat2dInts*/): { std::array, 2> in_input; std::array, 2> out_repeated; std::array, 2> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->Repeat2dInts(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 6 /*Repeat2dBinders*/): { std::array, 2> in_input; std::array, 2> out_repeated; std::array, 2> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->Repeat2dBinders(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 7 /*Repeat2dParcelables*/): { std::array, 2> in_input; std::array, 2> out_repeated; std::array, 2> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->Repeat2dParcelables(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_fixedsizearray_FixedSizeArrayExample_IRepeatFixedSizeArray_clazz = ::ndk::ICInterface::defineClass(FixedSizeArrayExample::IRepeatFixedSizeArray::descriptor, _aidl_android_aidl_fixedsizearray_FixedSizeArrayExample_IRepeatFixedSizeArray_onTransact); FixedSizeArrayExample::BpRepeatFixedSizeArray::BpRepeatFixedSizeArray(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} FixedSizeArrayExample::BpRepeatFixedSizeArray::~BpRepeatFixedSizeArray() {} ::ndk::ScopedAStatus FixedSizeArrayExample::BpRepeatFixedSizeArray::RepeatBytes(const std::array& in_input, std::array* out_repeated, std::array* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*RepeatBytes*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl()) { _aidl_status = IRepeatFixedSizeArray::getDefaultImpl()->RepeatBytes(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus FixedSizeArrayExample::BpRepeatFixedSizeArray::RepeatInts(const std::array& in_input, std::array* out_repeated, std::array* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 1 /*RepeatInts*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl()) { _aidl_status = IRepeatFixedSizeArray::getDefaultImpl()->RepeatInts(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus FixedSizeArrayExample::BpRepeatFixedSizeArray::RepeatBinders(const std::array<::ndk::SpAIBinder, 3>& in_input, std::array<::ndk::SpAIBinder, 3>* out_repeated, std::array<::ndk::SpAIBinder, 3>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 2 /*RepeatBinders*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl()) { _aidl_status = IRepeatFixedSizeArray::getDefaultImpl()->RepeatBinders(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus FixedSizeArrayExample::BpRepeatFixedSizeArray::RepeatParcelables(const std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>& in_input, std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* out_repeated, std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 3 /*RepeatParcelables*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl()) { _aidl_status = IRepeatFixedSizeArray::getDefaultImpl()->RepeatParcelables(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus FixedSizeArrayExample::BpRepeatFixedSizeArray::Repeat2dBytes(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 4 /*Repeat2dBytes*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl()) { _aidl_status = IRepeatFixedSizeArray::getDefaultImpl()->Repeat2dBytes(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus FixedSizeArrayExample::BpRepeatFixedSizeArray::Repeat2dInts(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 5 /*Repeat2dInts*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl()) { _aidl_status = IRepeatFixedSizeArray::getDefaultImpl()->Repeat2dInts(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus FixedSizeArrayExample::BpRepeatFixedSizeArray::Repeat2dBinders(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 6 /*Repeat2dBinders*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl()) { _aidl_status = IRepeatFixedSizeArray::getDefaultImpl()->Repeat2dBinders(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus FixedSizeArrayExample::BpRepeatFixedSizeArray::Repeat2dParcelables(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 7 /*Repeat2dParcelables*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl()) { _aidl_status = IRepeatFixedSizeArray::getDefaultImpl()->Repeat2dParcelables(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } // Source for BnRepeatFixedSizeArray FixedSizeArrayExample::BnRepeatFixedSizeArray::BnRepeatFixedSizeArray() {} FixedSizeArrayExample::BnRepeatFixedSizeArray::~BnRepeatFixedSizeArray() {} ::ndk::SpAIBinder FixedSizeArrayExample::BnRepeatFixedSizeArray::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_fixedsizearray_FixedSizeArrayExample_IRepeatFixedSizeArray_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for IRepeatFixedSizeArray const char* FixedSizeArrayExample::IRepeatFixedSizeArray::descriptor = "android.aidl.fixedsizearray.FixedSizeArrayExample.IRepeatFixedSizeArray"; FixedSizeArrayExample::IRepeatFixedSizeArray::IRepeatFixedSizeArray() {} FixedSizeArrayExample::IRepeatFixedSizeArray::~IRepeatFixedSizeArray() {} std::shared_ptr FixedSizeArrayExample::IRepeatFixedSizeArray::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_fixedsizearray_FixedSizeArrayExample_IRepeatFixedSizeArray_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t FixedSizeArrayExample::IRepeatFixedSizeArray::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t FixedSizeArrayExample::IRepeatFixedSizeArray::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = IRepeatFixedSizeArray::fromBinder(binder); return STATUS_OK; } bool FixedSizeArrayExample::IRepeatFixedSizeArray::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!IRepeatFixedSizeArray::default_impl); if (impl) { IRepeatFixedSizeArray::default_impl = impl; return true; } return false; } const std::shared_ptr& FixedSizeArrayExample::IRepeatFixedSizeArray::getDefaultImpl() { return IRepeatFixedSizeArray::default_impl; } std::shared_ptr FixedSizeArrayExample::IRepeatFixedSizeArray::default_impl = nullptr; ::ndk::ScopedAStatus FixedSizeArrayExample::IRepeatFixedSizeArrayDefault::RepeatBytes(const std::array& /*in_input*/, std::array* /*out_repeated*/, std::array* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus FixedSizeArrayExample::IRepeatFixedSizeArrayDefault::RepeatInts(const std::array& /*in_input*/, std::array* /*out_repeated*/, std::array* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus FixedSizeArrayExample::IRepeatFixedSizeArrayDefault::RepeatBinders(const std::array<::ndk::SpAIBinder, 3>& /*in_input*/, std::array<::ndk::SpAIBinder, 3>* /*out_repeated*/, std::array<::ndk::SpAIBinder, 3>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus FixedSizeArrayExample::IRepeatFixedSizeArrayDefault::RepeatParcelables(const std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>& /*in_input*/, std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* /*out_repeated*/, std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus FixedSizeArrayExample::IRepeatFixedSizeArrayDefault::Repeat2dBytes(const std::array, 2>& /*in_input*/, std::array, 2>* /*out_repeated*/, std::array, 2>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus FixedSizeArrayExample::IRepeatFixedSizeArrayDefault::Repeat2dInts(const std::array, 2>& /*in_input*/, std::array, 2>* /*out_repeated*/, std::array, 2>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus FixedSizeArrayExample::IRepeatFixedSizeArrayDefault::Repeat2dBinders(const std::array, 2>& /*in_input*/, std::array, 2>* /*out_repeated*/, std::array, 2>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus FixedSizeArrayExample::IRepeatFixedSizeArrayDefault::Repeat2dParcelables(const std::array, 2>& /*in_input*/, std::array, 2>* /*out_repeated*/, std::array, 2>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::SpAIBinder FixedSizeArrayExample::IRepeatFixedSizeArrayDefault::asBinder() { return ::ndk::SpAIBinder(); } bool FixedSizeArrayExample::IRepeatFixedSizeArrayDefault::isRemote() { return false; } } // namespace fixedsizearray } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace fixedsizearray { const char* FixedSizeArrayExample::IntParcelable::descriptor = "android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable"; binder_status_t FixedSizeArrayExample::IntParcelable::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &value); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t FixedSizeArrayExample::IntParcelable::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, value); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace fixedsizearray } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace fixedsizearray { static binder_status_t _aidl_android_aidl_fixedsizearray_FixedSizeArrayExample_IEmptyInterface_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; (void)_aidl_binder; (void)_aidl_code; return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_fixedsizearray_FixedSizeArrayExample_IEmptyInterface_clazz = ::ndk::ICInterface::defineClass(FixedSizeArrayExample::IEmptyInterface::descriptor, _aidl_android_aidl_fixedsizearray_FixedSizeArrayExample_IEmptyInterface_onTransact); FixedSizeArrayExample::BpEmptyInterface::BpEmptyInterface(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} FixedSizeArrayExample::BpEmptyInterface::~BpEmptyInterface() {} // Source for BnEmptyInterface FixedSizeArrayExample::BnEmptyInterface::BnEmptyInterface() {} FixedSizeArrayExample::BnEmptyInterface::~BnEmptyInterface() {} ::ndk::SpAIBinder FixedSizeArrayExample::BnEmptyInterface::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_fixedsizearray_FixedSizeArrayExample_IEmptyInterface_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for IEmptyInterface const char* FixedSizeArrayExample::IEmptyInterface::descriptor = "android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface"; FixedSizeArrayExample::IEmptyInterface::IEmptyInterface() {} FixedSizeArrayExample::IEmptyInterface::~IEmptyInterface() {} std::shared_ptr FixedSizeArrayExample::IEmptyInterface::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_fixedsizearray_FixedSizeArrayExample_IEmptyInterface_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t FixedSizeArrayExample::IEmptyInterface::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t FixedSizeArrayExample::IEmptyInterface::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = IEmptyInterface::fromBinder(binder); return STATUS_OK; } bool FixedSizeArrayExample::IEmptyInterface::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!IEmptyInterface::default_impl); if (impl) { IEmptyInterface::default_impl = impl; return true; } return false; } const std::shared_ptr& FixedSizeArrayExample::IEmptyInterface::getDefaultImpl() { return IEmptyInterface::default_impl; } std::shared_ptr FixedSizeArrayExample::IEmptyInterface::default_impl = nullptr; ::ndk::SpAIBinder FixedSizeArrayExample::IEmptyInterfaceDefault::asBinder() { return ::ndk::SpAIBinder(); } bool FixedSizeArrayExample::IEmptyInterfaceDefault::isRemote() { return false; } } // namespace fixedsizearray } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-ndk-source_gen_android_aidl_fixedsizear0100644 0000000 0000000 00000000231 15172120304 033314 xustar000000000 0000000 125 path=tests/golden_output/aidl-test-fixedsizearray-ndk-source/gen/android/aidl/fixedsizearray/FixedSizeArrayExample.cpp.d 28 mtime=1776853188.3960000 tests/golden_output/aidl-test-fixedsizearray-ndk-source/gen/android/aidl/fixedsizearray/FixedSizeArr0100644 0000000 0000000 00000000336 15172120304 033236 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-ndk-source/gen/android/aidl/fixedsizearray/FixedSizeArrayExample.cpp : \ system/tools/aidl/tests/android/aidl/fixedsizearray/FixedSizeArrayExample.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-ndk-source_gen_include_0100644 0000000 0000000 00000000034 15172120304 030071 xustar000000000 0000000 28 mtime=1776853188.3960000 tests/golden_output/aidl-test-fixedsizearray-ndk-source/gen/include/0040755 0000000 0000000 00000000000 15172120304 025016 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-ndk-source_gen_include_aidl_0100644 0000000 0000000 00000000034 15172120304 031062 xustar000000000 0000000 28 mtime=1776853188.3960000 tests/golden_output/aidl-test-fixedsizearray-ndk-source/gen/include/aidl/0040755 0000000 0000000 00000000000 15172120304 025727 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-ndk-source_gen_include_aidl_android_0100644 0000000 0000000 00000000034 15172120304 032562 xustar000000000 0000000 28 mtime=1776853188.3960000 tests/golden_output/aidl-test-fixedsizearray-ndk-source/gen/include/aidl/android/0040755 0000000 0000000 00000000000 15172120304 027347 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-ndk-source_gen_include_aidl_android_aid0100644 0000000 0000000 00000000034 15172120304 033240 xustar000000000 0000000 28 mtime=1776853188.3960000 tests/golden_output/aidl-test-fixedsizearray-ndk-source/gen/include/aidl/android/aidl/0040755 0000000 0000000 00000000000 15172120304 030260 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-ndk-source_gen_include_aidl_android_aid0100644 0000000 0000000 00000000213 15172120304 033237 xustar000000000 0000000 111 path=tests/golden_output/aidl-test-fixedsizearray-ndk-source/gen/include/aidl/android/aidl/fixedsizearray/ 28 mtime=1776853188.3960000 tests/golden_output/aidl-test-fixedsizearray-ndk-source/gen/include/aidl/android/aidl/fixedsizearray0040755 0000000 0000000 00000000000 15172120304 033232 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-ndk-source_gen_include_aidl_android_aid0100644 0000000 0000000 00000000244 15172120304 033243 xustar000000000 0000000 136 path=tests/golden_output/aidl-test-fixedsizearray-ndk-source/gen/include/aidl/android/aidl/fixedsizearray/BnFixedSizeArrayExample.h 28 mtime=1776853188.3960000 tests/golden_output/aidl-test-fixedsizearray-ndk-source/gen/include/aidl/android/aidl/fixedsizearray0100644 0000000 0000000 00000001273 15172120304 033234 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-ndk-source/gen/staging/android/aidl/fixedsizearray/FixedSizeArrayExample.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/fixedsizearray/FixedSizeArrayExample.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-ndk-source_gen_include_aidl_android_aid0100644 0000000 0000000 00000000244 15172120304 033243 xustar000000000 0000000 136 path=tests/golden_output/aidl-test-fixedsizearray-ndk-source/gen/include/aidl/android/aidl/fixedsizearray/BpFixedSizeArrayExample.h 28 mtime=1776853188.3960000 tests/golden_output/aidl-test-fixedsizearray-ndk-source/gen/include/aidl/android/aidl/fixedsizearray0100644 0000000 0000000 00000001273 15172120304 033234 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-ndk-source/gen/staging/android/aidl/fixedsizearray/FixedSizeArrayExample.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/fixedsizearray/FixedSizeArrayExample.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-ndk-source_gen_include_aidl_android_aid0100644 0000000 0000000 00000000242 15172120304 033241 xustar000000000 0000000 134 path=tests/golden_output/aidl-test-fixedsizearray-ndk-source/gen/include/aidl/android/aidl/fixedsizearray/FixedSizeArrayExample.h 28 mtime=1776853188.3970000 tests/golden_output/aidl-test-fixedsizearray-ndk-source/gen/include/aidl/android/aidl/fixedsizearray0100644 0000000 0000000 00000072535 15172120304 033245 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-ndk-source/gen/staging/android/aidl/fixedsizearray/FixedSizeArrayExample.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/fixedsizearray/FixedSizeArrayExample.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace fixedsizearray { class FixedSizeArrayExample { public: typedef std::false_type fixed_size; static const char* descriptor; class IntParcelable { public: typedef std::false_type fixed_size; static const char* descriptor; int32_t value = 0; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const IntParcelable& _rhs) const { return std::tie(value) == std::tie(_rhs.value); } inline bool operator<(const IntParcelable& _rhs) const { return std::tie(value) < std::tie(_rhs.value); } inline bool operator!=(const IntParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const IntParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const IntParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const IntParcelable& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "IntParcelable{"; _aidl_os << "value: " << ::android::internal::ToString(value); _aidl_os << "}"; return _aidl_os.str(); } }; class IRepeatFixedSizeArrayDelegator; class IRepeatFixedSizeArray : public ::ndk::ICInterface { public: typedef IRepeatFixedSizeArrayDelegator DefaultDelegator; static const char* descriptor; IRepeatFixedSizeArray(); virtual ~IRepeatFixedSizeArray(); static constexpr uint32_t TRANSACTION_RepeatBytes = FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_RepeatInts = FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_RepeatBinders = FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_RepeatParcelables = FIRST_CALL_TRANSACTION + 3; static constexpr uint32_t TRANSACTION_Repeat2dBytes = FIRST_CALL_TRANSACTION + 4; static constexpr uint32_t TRANSACTION_Repeat2dInts = FIRST_CALL_TRANSACTION + 5; static constexpr uint32_t TRANSACTION_Repeat2dBinders = FIRST_CALL_TRANSACTION + 6; static constexpr uint32_t TRANSACTION_Repeat2dParcelables = FIRST_CALL_TRANSACTION + 7; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus RepeatBytes(const std::array& in_input, std::array* out_repeated, std::array* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatInts(const std::array& in_input, std::array* out_repeated, std::array* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatBinders(const std::array<::ndk::SpAIBinder, 3>& in_input, std::array<::ndk::SpAIBinder, 3>* out_repeated, std::array<::ndk::SpAIBinder, 3>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatParcelables(const std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>& in_input, std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* out_repeated, std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus Repeat2dBytes(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus Repeat2dInts(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus Repeat2dBinders(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus Repeat2dParcelables(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) = 0; private: static std::shared_ptr default_impl; }; class IRepeatFixedSizeArrayDefault : public IRepeatFixedSizeArray { public: ::ndk::ScopedAStatus RepeatBytes(const std::array& in_input, std::array* out_repeated, std::array* _aidl_return) override; ::ndk::ScopedAStatus RepeatInts(const std::array& in_input, std::array* out_repeated, std::array* _aidl_return) override; ::ndk::ScopedAStatus RepeatBinders(const std::array<::ndk::SpAIBinder, 3>& in_input, std::array<::ndk::SpAIBinder, 3>* out_repeated, std::array<::ndk::SpAIBinder, 3>* _aidl_return) override; ::ndk::ScopedAStatus RepeatParcelables(const std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>& in_input, std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* out_repeated, std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* _aidl_return) override; ::ndk::ScopedAStatus Repeat2dBytes(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) override; ::ndk::ScopedAStatus Repeat2dInts(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) override; ::ndk::ScopedAStatus Repeat2dBinders(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) override; ::ndk::ScopedAStatus Repeat2dParcelables(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; class BpRepeatFixedSizeArray : public ::ndk::BpCInterface { public: explicit BpRepeatFixedSizeArray(const ::ndk::SpAIBinder& binder); virtual ~BpRepeatFixedSizeArray(); ::ndk::ScopedAStatus RepeatBytes(const std::array& in_input, std::array* out_repeated, std::array* _aidl_return) override; ::ndk::ScopedAStatus RepeatInts(const std::array& in_input, std::array* out_repeated, std::array* _aidl_return) override; ::ndk::ScopedAStatus RepeatBinders(const std::array<::ndk::SpAIBinder, 3>& in_input, std::array<::ndk::SpAIBinder, 3>* out_repeated, std::array<::ndk::SpAIBinder, 3>* _aidl_return) override; ::ndk::ScopedAStatus RepeatParcelables(const std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>& in_input, std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* out_repeated, std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* _aidl_return) override; ::ndk::ScopedAStatus Repeat2dBytes(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) override; ::ndk::ScopedAStatus Repeat2dInts(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) override; ::ndk::ScopedAStatus Repeat2dBinders(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) override; ::ndk::ScopedAStatus Repeat2dParcelables(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) override; }; class BnRepeatFixedSizeArray : public ::ndk::BnCInterface { public: BnRepeatFixedSizeArray(); virtual ~BnRepeatFixedSizeArray(); protected: ::ndk::SpAIBinder createBinder() override; private: }; enum class ByteEnum : int8_t { A = 0, }; enum class IntEnum : int32_t { A = 0, }; enum class LongEnum : int64_t { A = 0L, }; class IEmptyInterfaceDelegator; class IEmptyInterface : public ::ndk::ICInterface { public: typedef IEmptyInterfaceDelegator DefaultDelegator; static const char* descriptor; IEmptyInterface(); virtual ~IEmptyInterface(); static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); private: static std::shared_ptr default_impl; }; class IEmptyInterfaceDefault : public IEmptyInterface { public: ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; class BpEmptyInterface : public ::ndk::BpCInterface { public: explicit BpEmptyInterface(const ::ndk::SpAIBinder& binder); virtual ~BpEmptyInterface(); }; class BnEmptyInterface : public ::ndk::BnCInterface { public: BnEmptyInterface(); virtual ~BnEmptyInterface(); protected: ::ndk::SpAIBinder createBinder() override; private: }; std::array, 2> int2x3 = {{{{1, 2, 3}}, {{4, 5, 6}}}}; std::array boolArray = {{}}; std::array byteArray = {{}}; std::array charArray = {{}}; std::array intArray = {{}}; std::array longArray = {{}}; std::array floatArray = {{}}; std::array doubleArray = {{}}; std::array stringArray = {{"hello", "world"}}; std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::ByteEnum, 2> byteEnumArray = {{}}; std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntEnum, 2> intEnumArray = {{}}; std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::LongEnum, 2> longEnumArray = {{}}; std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 2> parcelableArray = {{}}; std::array, 2> boolMatrix = {{}}; std::array, 2> byteMatrix = {{}}; std::array, 2> charMatrix = {{}}; std::array, 2> intMatrix = {{}}; std::array, 2> longMatrix = {{}}; std::array, 2> floatMatrix = {{}}; std::array, 2> doubleMatrix = {{}}; std::array, 2> stringMatrix = {{{{"hello", "world"}}, {{"Ciao", "mondo"}}}}; std::array, 2> byteEnumMatrix = {{}}; std::array, 2> intEnumMatrix = {{}}; std::array, 2> longEnumMatrix = {{}}; std::array, 2> parcelableMatrix = {{}}; std::optional> boolNullableArray; std::optional> byteNullableArray; std::optional> charNullableArray; std::optional> intNullableArray; std::optional> longNullableArray; std::optional> floatNullableArray; std::optional> doubleNullableArray; std::optional, 2>> stringNullableArray = {{{"hello", "world"}}}; std::optional> byteEnumNullableArray; std::optional> intEnumNullableArray; std::optional> longEnumNullableArray; std::optional> binderNullableArray; std::optional> pfdNullableArray; std::optional, 2>> parcelableNullableArray; std::optional, 2>> interfaceNullableArray; std::optional, 2>> boolNullableMatrix; std::optional, 2>> byteNullableMatrix; std::optional, 2>> charNullableMatrix; std::optional, 2>> intNullableMatrix; std::optional, 2>> longNullableMatrix; std::optional, 2>> floatNullableMatrix; std::optional, 2>> doubleNullableMatrix; std::optional, 2>, 2>> stringNullableMatrix = {{{{{"hello", "world"}}, {{"Ciao", "mondo"}}}}}; std::optional, 2>> byteEnumNullableMatrix; std::optional, 2>> intEnumNullableMatrix; std::optional, 2>> longEnumNullableMatrix; std::optional, 2>> binderNullableMatrix; std::optional, 2>> pfdNullableMatrix; std::optional, 2>, 2>> parcelableNullableMatrix; std::optional, 2>, 2>> interfaceNullableMatrix; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const FixedSizeArrayExample& _rhs) const { return std::tie(int2x3, boolArray, byteArray, charArray, intArray, longArray, floatArray, doubleArray, stringArray, byteEnumArray, intEnumArray, longEnumArray, parcelableArray, boolMatrix, byteMatrix, charMatrix, intMatrix, longMatrix, floatMatrix, doubleMatrix, stringMatrix, byteEnumMatrix, intEnumMatrix, longEnumMatrix, parcelableMatrix, boolNullableArray, byteNullableArray, charNullableArray, intNullableArray, longNullableArray, floatNullableArray, doubleNullableArray, stringNullableArray, byteEnumNullableArray, intEnumNullableArray, longEnumNullableArray, binderNullableArray, pfdNullableArray, parcelableNullableArray, interfaceNullableArray, boolNullableMatrix, byteNullableMatrix, charNullableMatrix, intNullableMatrix, longNullableMatrix, floatNullableMatrix, doubleNullableMatrix, stringNullableMatrix, byteEnumNullableMatrix, intEnumNullableMatrix, longEnumNullableMatrix, binderNullableMatrix, pfdNullableMatrix, parcelableNullableMatrix, interfaceNullableMatrix) == std::tie(_rhs.int2x3, _rhs.boolArray, _rhs.byteArray, _rhs.charArray, _rhs.intArray, _rhs.longArray, _rhs.floatArray, _rhs.doubleArray, _rhs.stringArray, _rhs.byteEnumArray, _rhs.intEnumArray, _rhs.longEnumArray, _rhs.parcelableArray, _rhs.boolMatrix, _rhs.byteMatrix, _rhs.charMatrix, _rhs.intMatrix, _rhs.longMatrix, _rhs.floatMatrix, _rhs.doubleMatrix, _rhs.stringMatrix, _rhs.byteEnumMatrix, _rhs.intEnumMatrix, _rhs.longEnumMatrix, _rhs.parcelableMatrix, _rhs.boolNullableArray, _rhs.byteNullableArray, _rhs.charNullableArray, _rhs.intNullableArray, _rhs.longNullableArray, _rhs.floatNullableArray, _rhs.doubleNullableArray, _rhs.stringNullableArray, _rhs.byteEnumNullableArray, _rhs.intEnumNullableArray, _rhs.longEnumNullableArray, _rhs.binderNullableArray, _rhs.pfdNullableArray, _rhs.parcelableNullableArray, _rhs.interfaceNullableArray, _rhs.boolNullableMatrix, _rhs.byteNullableMatrix, _rhs.charNullableMatrix, _rhs.intNullableMatrix, _rhs.longNullableMatrix, _rhs.floatNullableMatrix, _rhs.doubleNullableMatrix, _rhs.stringNullableMatrix, _rhs.byteEnumNullableMatrix, _rhs.intEnumNullableMatrix, _rhs.longEnumNullableMatrix, _rhs.binderNullableMatrix, _rhs.pfdNullableMatrix, _rhs.parcelableNullableMatrix, _rhs.interfaceNullableMatrix); } inline bool operator<(const FixedSizeArrayExample& _rhs) const { return std::tie(int2x3, boolArray, byteArray, charArray, intArray, longArray, floatArray, doubleArray, stringArray, byteEnumArray, intEnumArray, longEnumArray, parcelableArray, boolMatrix, byteMatrix, charMatrix, intMatrix, longMatrix, floatMatrix, doubleMatrix, stringMatrix, byteEnumMatrix, intEnumMatrix, longEnumMatrix, parcelableMatrix, boolNullableArray, byteNullableArray, charNullableArray, intNullableArray, longNullableArray, floatNullableArray, doubleNullableArray, stringNullableArray, byteEnumNullableArray, intEnumNullableArray, longEnumNullableArray, binderNullableArray, pfdNullableArray, parcelableNullableArray, interfaceNullableArray, boolNullableMatrix, byteNullableMatrix, charNullableMatrix, intNullableMatrix, longNullableMatrix, floatNullableMatrix, doubleNullableMatrix, stringNullableMatrix, byteEnumNullableMatrix, intEnumNullableMatrix, longEnumNullableMatrix, binderNullableMatrix, pfdNullableMatrix, parcelableNullableMatrix, interfaceNullableMatrix) < std::tie(_rhs.int2x3, _rhs.boolArray, _rhs.byteArray, _rhs.charArray, _rhs.intArray, _rhs.longArray, _rhs.floatArray, _rhs.doubleArray, _rhs.stringArray, _rhs.byteEnumArray, _rhs.intEnumArray, _rhs.longEnumArray, _rhs.parcelableArray, _rhs.boolMatrix, _rhs.byteMatrix, _rhs.charMatrix, _rhs.intMatrix, _rhs.longMatrix, _rhs.floatMatrix, _rhs.doubleMatrix, _rhs.stringMatrix, _rhs.byteEnumMatrix, _rhs.intEnumMatrix, _rhs.longEnumMatrix, _rhs.parcelableMatrix, _rhs.boolNullableArray, _rhs.byteNullableArray, _rhs.charNullableArray, _rhs.intNullableArray, _rhs.longNullableArray, _rhs.floatNullableArray, _rhs.doubleNullableArray, _rhs.stringNullableArray, _rhs.byteEnumNullableArray, _rhs.intEnumNullableArray, _rhs.longEnumNullableArray, _rhs.binderNullableArray, _rhs.pfdNullableArray, _rhs.parcelableNullableArray, _rhs.interfaceNullableArray, _rhs.boolNullableMatrix, _rhs.byteNullableMatrix, _rhs.charNullableMatrix, _rhs.intNullableMatrix, _rhs.longNullableMatrix, _rhs.floatNullableMatrix, _rhs.doubleNullableMatrix, _rhs.stringNullableMatrix, _rhs.byteEnumNullableMatrix, _rhs.intEnumNullableMatrix, _rhs.longEnumNullableMatrix, _rhs.binderNullableMatrix, _rhs.pfdNullableMatrix, _rhs.parcelableNullableMatrix, _rhs.interfaceNullableMatrix); } inline bool operator!=(const FixedSizeArrayExample& _rhs) const { return !(*this == _rhs); } inline bool operator>(const FixedSizeArrayExample& _rhs) const { return _rhs < *this; } inline bool operator>=(const FixedSizeArrayExample& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const FixedSizeArrayExample& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "FixedSizeArrayExample{"; _aidl_os << "int2x3: " << ::android::internal::ToString(int2x3); _aidl_os << ", boolArray: " << ::android::internal::ToString(boolArray); _aidl_os << ", byteArray: " << ::android::internal::ToString(byteArray); _aidl_os << ", charArray: " << ::android::internal::ToString(charArray); _aidl_os << ", intArray: " << ::android::internal::ToString(intArray); _aidl_os << ", longArray: " << ::android::internal::ToString(longArray); _aidl_os << ", floatArray: " << ::android::internal::ToString(floatArray); _aidl_os << ", doubleArray: " << ::android::internal::ToString(doubleArray); _aidl_os << ", stringArray: " << ::android::internal::ToString(stringArray); _aidl_os << ", byteEnumArray: " << ::android::internal::ToString(byteEnumArray); _aidl_os << ", intEnumArray: " << ::android::internal::ToString(intEnumArray); _aidl_os << ", longEnumArray: " << ::android::internal::ToString(longEnumArray); _aidl_os << ", parcelableArray: " << ::android::internal::ToString(parcelableArray); _aidl_os << ", boolMatrix: " << ::android::internal::ToString(boolMatrix); _aidl_os << ", byteMatrix: " << ::android::internal::ToString(byteMatrix); _aidl_os << ", charMatrix: " << ::android::internal::ToString(charMatrix); _aidl_os << ", intMatrix: " << ::android::internal::ToString(intMatrix); _aidl_os << ", longMatrix: " << ::android::internal::ToString(longMatrix); _aidl_os << ", floatMatrix: " << ::android::internal::ToString(floatMatrix); _aidl_os << ", doubleMatrix: " << ::android::internal::ToString(doubleMatrix); _aidl_os << ", stringMatrix: " << ::android::internal::ToString(stringMatrix); _aidl_os << ", byteEnumMatrix: " << ::android::internal::ToString(byteEnumMatrix); _aidl_os << ", intEnumMatrix: " << ::android::internal::ToString(intEnumMatrix); _aidl_os << ", longEnumMatrix: " << ::android::internal::ToString(longEnumMatrix); _aidl_os << ", parcelableMatrix: " << ::android::internal::ToString(parcelableMatrix); _aidl_os << ", boolNullableArray: " << ::android::internal::ToString(boolNullableArray); _aidl_os << ", byteNullableArray: " << ::android::internal::ToString(byteNullableArray); _aidl_os << ", charNullableArray: " << ::android::internal::ToString(charNullableArray); _aidl_os << ", intNullableArray: " << ::android::internal::ToString(intNullableArray); _aidl_os << ", longNullableArray: " << ::android::internal::ToString(longNullableArray); _aidl_os << ", floatNullableArray: " << ::android::internal::ToString(floatNullableArray); _aidl_os << ", doubleNullableArray: " << ::android::internal::ToString(doubleNullableArray); _aidl_os << ", stringNullableArray: " << ::android::internal::ToString(stringNullableArray); _aidl_os << ", byteEnumNullableArray: " << ::android::internal::ToString(byteEnumNullableArray); _aidl_os << ", intEnumNullableArray: " << ::android::internal::ToString(intEnumNullableArray); _aidl_os << ", longEnumNullableArray: " << ::android::internal::ToString(longEnumNullableArray); _aidl_os << ", binderNullableArray: " << ::android::internal::ToString(binderNullableArray); _aidl_os << ", pfdNullableArray: " << ::android::internal::ToString(pfdNullableArray); _aidl_os << ", parcelableNullableArray: " << ::android::internal::ToString(parcelableNullableArray); _aidl_os << ", interfaceNullableArray: " << ::android::internal::ToString(interfaceNullableArray); _aidl_os << ", boolNullableMatrix: " << ::android::internal::ToString(boolNullableMatrix); _aidl_os << ", byteNullableMatrix: " << ::android::internal::ToString(byteNullableMatrix); _aidl_os << ", charNullableMatrix: " << ::android::internal::ToString(charNullableMatrix); _aidl_os << ", intNullableMatrix: " << ::android::internal::ToString(intNullableMatrix); _aidl_os << ", longNullableMatrix: " << ::android::internal::ToString(longNullableMatrix); _aidl_os << ", floatNullableMatrix: " << ::android::internal::ToString(floatNullableMatrix); _aidl_os << ", doubleNullableMatrix: " << ::android::internal::ToString(doubleNullableMatrix); _aidl_os << ", stringNullableMatrix: " << ::android::internal::ToString(stringNullableMatrix); _aidl_os << ", byteEnumNullableMatrix: " << ::android::internal::ToString(byteEnumNullableMatrix); _aidl_os << ", intEnumNullableMatrix: " << ::android::internal::ToString(intEnumNullableMatrix); _aidl_os << ", longEnumNullableMatrix: " << ::android::internal::ToString(longEnumNullableMatrix); _aidl_os << ", binderNullableMatrix: " << ::android::internal::ToString(binderNullableMatrix); _aidl_os << ", pfdNullableMatrix: " << ::android::internal::ToString(pfdNullableMatrix); _aidl_os << ", parcelableNullableMatrix: " << ::android::internal::ToString(parcelableNullableMatrix); _aidl_os << ", interfaceNullableMatrix: " << ::android::internal::ToString(interfaceNullableMatrix); _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace fixedsizearray } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace fixedsizearray { [[nodiscard]] static inline std::string toString(FixedSizeArrayExample::ByteEnum val) { switch(val) { case FixedSizeArrayExample::ByteEnum::A: return "A"; default: return std::to_string(static_cast(val)); } } } // namespace fixedsizearray } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::ByteEnum::A, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk namespace aidl { namespace android { namespace aidl { namespace fixedsizearray { [[nodiscard]] static inline std::string toString(FixedSizeArrayExample::IntEnum val) { switch(val) { case FixedSizeArrayExample::IntEnum::A: return "A"; default: return std::to_string(static_cast(val)); } } } // namespace fixedsizearray } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntEnum::A, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk namespace aidl { namespace android { namespace aidl { namespace fixedsizearray { [[nodiscard]] static inline std::string toString(FixedSizeArrayExample::LongEnum val) { switch(val) { case FixedSizeArrayExample::LongEnum::A: return "A"; default: return std::to_string(static_cast(val)); } } } // namespace fixedsizearray } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::LongEnum::A, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-ndk-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 030312 xustar000000000 0000000 28 mtime=1776853188.3970000 tests/golden_output/aidl-test-fixedsizearray-ndk-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 025304 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-rust-source_0100644 0000000 0000000 00000000034 15172120304 025756 xustar000000000 0000000 28 mtime=1776853188.3970000 tests/golden_output/aidl-test-fixedsizearray-rust-source/0040755 0000000 0000000 00000000000 15172120304 023043 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-rust-source_gen_0100644 0000000 0000000 00000000034 15172120304 026607 xustar000000000 0000000 28 mtime=1776853188.3970000 tests/golden_output/aidl-test-fixedsizearray-rust-source/gen/0040755 0000000 0000000 00000000000 15172120304 023614 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-rust-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 030307 xustar000000000 0000000 28 mtime=1776853188.3970000 tests/golden_output/aidl-test-fixedsizearray-rust-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 025234 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-rust-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 031300 xustar000000000 0000000 28 mtime=1776853188.3970000 tests/golden_output/aidl-test-fixedsizearray-rust-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 026145 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-rust-source_gen_android_aidl_fixedsizea0100644 0000000 0000000 00000000034 15172120304 033354 xustar000000000 0000000 28 mtime=1776853188.3970000 tests/golden_output/aidl-test-fixedsizearray-rust-source/gen/android/aidl/fixedsizearray/0040755 0000000 0000000 00000000000 15172120304 031176 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-rust-source_gen_android_aidl_fixedsizea0100644 0000000 0000000 00000000227 15172120304 033360 xustar000000000 0000000 123 path=tests/golden_output/aidl-test-fixedsizearray-rust-source/gen/android/aidl/fixedsizearray/FixedSizeArrayExample.rs 28 mtime=1776853188.3970000 tests/golden_output/aidl-test-fixedsizearray-rust-source/gen/android/aidl/fixedsizearray/FixedSizeAr0100644 0000000 0000000 00000175730 15172120304 033310 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-rust-source/gen/android/aidl/fixedsizearray/FixedSizeArrayExample.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/fixedsizearray/FixedSizeArrayExample.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug, PartialEq)] pub struct r#FixedSizeArrayExample { pub r#int2x3: [[i32; 3]; 2], pub r#boolArray: [bool; 2], pub r#byteArray: [u8; 2], pub r#charArray: [u16; 2], pub r#intArray: [i32; 2], pub r#longArray: [i64; 2], pub r#floatArray: [f32; 2], pub r#doubleArray: [f64; 2], pub r#stringArray: [String; 2], pub r#byteEnumArray: [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_8_ByteEnum; 2], pub r#intEnumArray: [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_7_IntEnum; 2], pub r#longEnumArray: [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_8_LongEnum; 2], pub r#parcelableArray: [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 2], pub r#boolMatrix: [[bool; 2]; 2], pub r#byteMatrix: [[u8; 2]; 2], pub r#charMatrix: [[u16; 2]; 2], pub r#intMatrix: [[i32; 2]; 2], pub r#longMatrix: [[i64; 2]; 2], pub r#floatMatrix: [[f32; 2]; 2], pub r#doubleMatrix: [[f64; 2]; 2], pub r#stringMatrix: [[String; 2]; 2], pub r#byteEnumMatrix: [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_8_ByteEnum; 2]; 2], pub r#intEnumMatrix: [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_7_IntEnum; 2]; 2], pub r#longEnumMatrix: [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_8_LongEnum; 2]; 2], pub r#parcelableMatrix: [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 2]; 2], pub r#boolNullableArray: Option<[bool; 2]>, pub r#byteNullableArray: Option<[u8; 2]>, pub r#charNullableArray: Option<[u16; 2]>, pub r#intNullableArray: Option<[i32; 2]>, pub r#longNullableArray: Option<[i64; 2]>, pub r#floatNullableArray: Option<[f32; 2]>, pub r#doubleNullableArray: Option<[f64; 2]>, pub r#stringNullableArray: Option<[Option; 2]>, pub r#byteEnumNullableArray: Option<[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_8_ByteEnum; 2]>, pub r#intEnumNullableArray: Option<[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_7_IntEnum; 2]>, pub r#longEnumNullableArray: Option<[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_8_LongEnum; 2]>, pub r#binderNullableArray: Option<[Option; 2]>, pub r#pfdNullableArray: Option<[Option; 2]>, pub r#parcelableNullableArray: Option<[Option; 2]>, pub r#interfaceNullableArray: Option<[Option>; 2]>, pub r#boolNullableMatrix: Option<[[bool; 2]; 2]>, pub r#byteNullableMatrix: Option<[[u8; 2]; 2]>, pub r#charNullableMatrix: Option<[[u16; 2]; 2]>, pub r#intNullableMatrix: Option<[[i32; 2]; 2]>, pub r#longNullableMatrix: Option<[[i64; 2]; 2]>, pub r#floatNullableMatrix: Option<[[f32; 2]; 2]>, pub r#doubleNullableMatrix: Option<[[f64; 2]; 2]>, pub r#stringNullableMatrix: Option<[[Option; 2]; 2]>, pub r#byteEnumNullableMatrix: Option<[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_8_ByteEnum; 2]; 2]>, pub r#intEnumNullableMatrix: Option<[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_7_IntEnum; 2]; 2]>, pub r#longEnumNullableMatrix: Option<[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_8_LongEnum; 2]; 2]>, pub r#binderNullableMatrix: Option<[[Option; 2]; 2]>, pub r#pfdNullableMatrix: Option<[[Option; 2]; 2]>, pub r#parcelableNullableMatrix: Option<[[Option; 2]; 2]>, pub r#interfaceNullableMatrix: Option<[[Option>; 2]; 2]>, } impl Default for r#FixedSizeArrayExample { fn default() -> Self { Self { r#int2x3: [[1, 2, 3], [4, 5, 6]], r#boolArray: [Default::default(), Default::default()], r#byteArray: [Default::default(), Default::default()], r#charArray: [Default::default(), Default::default()], r#intArray: [Default::default(), Default::default()], r#longArray: [Default::default(), Default::default()], r#floatArray: [Default::default(), Default::default()], r#doubleArray: [Default::default(), Default::default()], r#stringArray: ["hello".into(), "world".into()], r#byteEnumArray: [Default::default(), Default::default()], r#intEnumArray: [Default::default(), Default::default()], r#longEnumArray: [Default::default(), Default::default()], r#parcelableArray: [Default::default(), Default::default()], r#boolMatrix: [[Default::default(), Default::default()], [Default::default(), Default::default()]], r#byteMatrix: [[Default::default(), Default::default()], [Default::default(), Default::default()]], r#charMatrix: [[Default::default(), Default::default()], [Default::default(), Default::default()]], r#intMatrix: [[Default::default(), Default::default()], [Default::default(), Default::default()]], r#longMatrix: [[Default::default(), Default::default()], [Default::default(), Default::default()]], r#floatMatrix: [[Default::default(), Default::default()], [Default::default(), Default::default()]], r#doubleMatrix: [[Default::default(), Default::default()], [Default::default(), Default::default()]], r#stringMatrix: [["hello".into(), "world".into()], ["Ciao".into(), "mondo".into()]], r#byteEnumMatrix: [[Default::default(), Default::default()], [Default::default(), Default::default()]], r#intEnumMatrix: [[Default::default(), Default::default()], [Default::default(), Default::default()]], r#longEnumMatrix: [[Default::default(), Default::default()], [Default::default(), Default::default()]], r#parcelableMatrix: [[Default::default(), Default::default()], [Default::default(), Default::default()]], r#boolNullableArray: Default::default(), r#byteNullableArray: Default::default(), r#charNullableArray: Default::default(), r#intNullableArray: Default::default(), r#longNullableArray: Default::default(), r#floatNullableArray: Default::default(), r#doubleNullableArray: Default::default(), r#stringNullableArray: Some([Some("hello".into()), Some("world".into())]), r#byteEnumNullableArray: Default::default(), r#intEnumNullableArray: Default::default(), r#longEnumNullableArray: Default::default(), r#binderNullableArray: Default::default(), r#pfdNullableArray: Default::default(), r#parcelableNullableArray: Default::default(), r#interfaceNullableArray: Default::default(), r#boolNullableMatrix: Default::default(), r#byteNullableMatrix: Default::default(), r#charNullableMatrix: Default::default(), r#intNullableMatrix: Default::default(), r#longNullableMatrix: Default::default(), r#floatNullableMatrix: Default::default(), r#doubleNullableMatrix: Default::default(), r#stringNullableMatrix: Some([[Some("hello".into()), Some("world".into())], [Some("Ciao".into()), Some("mondo".into())]]), r#byteEnumNullableMatrix: Default::default(), r#intEnumNullableMatrix: Default::default(), r#longEnumNullableMatrix: Default::default(), r#binderNullableMatrix: Default::default(), r#pfdNullableMatrix: Default::default(), r#parcelableNullableMatrix: Default::default(), r#interfaceNullableMatrix: Default::default(), } } } impl binder::Parcelable for r#FixedSizeArrayExample { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#int2x3)?; subparcel.write(&self.r#boolArray)?; subparcel.write(&self.r#byteArray)?; subparcel.write(&self.r#charArray)?; subparcel.write(&self.r#intArray)?; subparcel.write(&self.r#longArray)?; subparcel.write(&self.r#floatArray)?; subparcel.write(&self.r#doubleArray)?; subparcel.write(&self.r#stringArray)?; subparcel.write(&self.r#byteEnumArray)?; subparcel.write(&self.r#intEnumArray)?; subparcel.write(&self.r#longEnumArray)?; subparcel.write(&self.r#parcelableArray)?; subparcel.write(&self.r#boolMatrix)?; subparcel.write(&self.r#byteMatrix)?; subparcel.write(&self.r#charMatrix)?; subparcel.write(&self.r#intMatrix)?; subparcel.write(&self.r#longMatrix)?; subparcel.write(&self.r#floatMatrix)?; subparcel.write(&self.r#doubleMatrix)?; subparcel.write(&self.r#stringMatrix)?; subparcel.write(&self.r#byteEnumMatrix)?; subparcel.write(&self.r#intEnumMatrix)?; subparcel.write(&self.r#longEnumMatrix)?; subparcel.write(&self.r#parcelableMatrix)?; subparcel.write(&self.r#boolNullableArray)?; subparcel.write(&self.r#byteNullableArray)?; subparcel.write(&self.r#charNullableArray)?; subparcel.write(&self.r#intNullableArray)?; subparcel.write(&self.r#longNullableArray)?; subparcel.write(&self.r#floatNullableArray)?; subparcel.write(&self.r#doubleNullableArray)?; subparcel.write(&self.r#stringNullableArray)?; subparcel.write(&self.r#byteEnumNullableArray)?; subparcel.write(&self.r#intEnumNullableArray)?; subparcel.write(&self.r#longEnumNullableArray)?; subparcel.write(&self.r#binderNullableArray)?; subparcel.write(&self.r#pfdNullableArray)?; subparcel.write(&self.r#parcelableNullableArray)?; subparcel.write(&self.r#interfaceNullableArray)?; subparcel.write(&self.r#boolNullableMatrix)?; subparcel.write(&self.r#byteNullableMatrix)?; subparcel.write(&self.r#charNullableMatrix)?; subparcel.write(&self.r#intNullableMatrix)?; subparcel.write(&self.r#longNullableMatrix)?; subparcel.write(&self.r#floatNullableMatrix)?; subparcel.write(&self.r#doubleNullableMatrix)?; subparcel.write(&self.r#stringNullableMatrix)?; subparcel.write(&self.r#byteEnumNullableMatrix)?; subparcel.write(&self.r#intEnumNullableMatrix)?; subparcel.write(&self.r#longEnumNullableMatrix)?; subparcel.write(&self.r#binderNullableMatrix)?; subparcel.write(&self.r#pfdNullableMatrix)?; subparcel.write(&self.r#parcelableNullableMatrix)?; subparcel.write(&self.r#interfaceNullableMatrix)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#int2x3 = subparcel.read()?; } if subparcel.has_more_data() { self.r#boolArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#byteArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#charArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#intArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#longArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#floatArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#doubleArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#stringArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#byteEnumArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#intEnumArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#longEnumArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#parcelableArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#boolMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#byteMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#charMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#intMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#longMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#floatMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#doubleMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#stringMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#byteEnumMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#intEnumMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#longEnumMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#parcelableMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#boolNullableArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#byteNullableArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#charNullableArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#intNullableArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#longNullableArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#floatNullableArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#doubleNullableArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#stringNullableArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#byteEnumNullableArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#intEnumNullableArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#longEnumNullableArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#binderNullableArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#pfdNullableArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#parcelableNullableArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#interfaceNullableArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#boolNullableMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#byteNullableMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#charNullableMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#intNullableMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#longNullableMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#floatNullableMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#doubleNullableMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#stringNullableMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#byteEnumNullableMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#intEnumNullableMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#longEnumNullableMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#binderNullableMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#pfdNullableMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#parcelableNullableMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#interfaceNullableMatrix = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#FixedSizeArrayExample); binder::impl_deserialize_for_parcelable!(r#FixedSizeArrayExample); impl binder::binder_impl::ParcelableMetadata for r#FixedSizeArrayExample { fn get_descriptor() -> &'static str { "android.aidl.fixedsizearray.FixedSizeArrayExample" } } pub mod r#IRepeatFixedSizeArray { #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { IRepeatFixedSizeArray["android.aidl.fixedsizearray.FixedSizeArrayExample.IRepeatFixedSizeArray"] { native: BnRepeatFixedSizeArray(on_transact), proxy: BpRepeatFixedSizeArray { }, async: IRepeatFixedSizeArrayAsync, } } pub trait IRepeatFixedSizeArray: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.fixedsizearray.FixedSizeArrayExample.IRepeatFixedSizeArray" } fn r#RepeatBytes(&self, _arg_input: &[u8; 3], _arg_repeated: &mut [u8; 3]) -> binder::Result<[u8; 3]>; fn r#RepeatInts(&self, _arg_input: &[i32; 3], _arg_repeated: &mut [i32; 3]) -> binder::Result<[i32; 3]>; fn r#RepeatBinders(&self, _arg_input: &[binder::SpIBinder; 3], _arg_repeated: &mut [Option; 3]) -> binder::Result<[binder::SpIBinder; 3]>; fn r#RepeatParcelables(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3], _arg_repeated: &mut [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]) -> binder::Result<[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]>; fn r#Repeat2dBytes(&self, _arg_input: &[[u8; 3]; 2], _arg_repeated: &mut [[u8; 3]; 2]) -> binder::Result<[[u8; 3]; 2]>; fn r#Repeat2dInts(&self, _arg_input: &[[i32; 3]; 2], _arg_repeated: &mut [[i32; 3]; 2]) -> binder::Result<[[i32; 3]; 2]>; fn r#Repeat2dBinders(&self, _arg_input: &[[binder::SpIBinder; 3]; 2], _arg_repeated: &mut [[Option; 3]; 2]) -> binder::Result<[[binder::SpIBinder; 3]; 2]>; fn r#Repeat2dParcelables(&self, _arg_input: &[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2], _arg_repeated: &mut [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]) -> binder::Result<[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]>; fn getDefaultImpl() -> IRepeatFixedSizeArrayDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: IRepeatFixedSizeArrayDefaultRef) -> IRepeatFixedSizeArrayDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait IRepeatFixedSizeArrayAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.fixedsizearray.FixedSizeArrayExample.IRepeatFixedSizeArray" } fn r#RepeatBytes<'a>(&'a self, _arg_input: &'a [u8; 3], _arg_repeated: &'a mut [u8; 3]) -> binder::BoxFuture<'a, binder::Result<[u8; 3]>>; fn r#RepeatInts<'a>(&'a self, _arg_input: &'a [i32; 3], _arg_repeated: &'a mut [i32; 3]) -> binder::BoxFuture<'a, binder::Result<[i32; 3]>>; fn r#RepeatBinders<'a>(&'a self, _arg_input: &'a [binder::SpIBinder; 3], _arg_repeated: &'a mut [Option; 3]) -> binder::BoxFuture<'a, binder::Result<[binder::SpIBinder; 3]>>; fn r#RepeatParcelables<'a>(&'a self, _arg_input: &'a [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3], _arg_repeated: &'a mut [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]) -> binder::BoxFuture<'a, binder::Result<[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]>>; fn r#Repeat2dBytes<'a>(&'a self, _arg_input: &'a [[u8; 3]; 2], _arg_repeated: &'a mut [[u8; 3]; 2]) -> binder::BoxFuture<'a, binder::Result<[[u8; 3]; 2]>>; fn r#Repeat2dInts<'a>(&'a self, _arg_input: &'a [[i32; 3]; 2], _arg_repeated: &'a mut [[i32; 3]; 2]) -> binder::BoxFuture<'a, binder::Result<[[i32; 3]; 2]>>; fn r#Repeat2dBinders<'a>(&'a self, _arg_input: &'a [[binder::SpIBinder; 3]; 2], _arg_repeated: &'a mut [[Option; 3]; 2]) -> binder::BoxFuture<'a, binder::Result<[[binder::SpIBinder; 3]; 2]>>; fn r#Repeat2dParcelables<'a>(&'a self, _arg_input: &'a [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2], _arg_repeated: &'a mut [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]) -> binder::BoxFuture<'a, binder::Result<[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]>>; } #[::async_trait::async_trait] pub trait IRepeatFixedSizeArrayAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.fixedsizearray.FixedSizeArrayExample.IRepeatFixedSizeArray" } async fn r#RepeatBytes(&self, _arg_input: &[u8; 3], _arg_repeated: &mut [u8; 3]) -> binder::Result<[u8; 3]>; async fn r#RepeatInts(&self, _arg_input: &[i32; 3], _arg_repeated: &mut [i32; 3]) -> binder::Result<[i32; 3]>; async fn r#RepeatBinders(&self, _arg_input: &[binder::SpIBinder; 3], _arg_repeated: &mut [Option; 3]) -> binder::Result<[binder::SpIBinder; 3]>; async fn r#RepeatParcelables(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3], _arg_repeated: &mut [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]) -> binder::Result<[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]>; async fn r#Repeat2dBytes(&self, _arg_input: &[[u8; 3]; 2], _arg_repeated: &mut [[u8; 3]; 2]) -> binder::Result<[[u8; 3]; 2]>; async fn r#Repeat2dInts(&self, _arg_input: &[[i32; 3]; 2], _arg_repeated: &mut [[i32; 3]; 2]) -> binder::Result<[[i32; 3]; 2]>; async fn r#Repeat2dBinders(&self, _arg_input: &[[binder::SpIBinder; 3]; 2], _arg_repeated: &mut [[Option; 3]; 2]) -> binder::Result<[[binder::SpIBinder; 3]; 2]>; async fn r#Repeat2dParcelables(&self, _arg_input: &[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2], _arg_repeated: &mut [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]) -> binder::Result<[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]>; } impl BnRepeatFixedSizeArray { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: IRepeatFixedSizeArrayAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl IRepeatFixedSizeArray for Wrapper where T: IRepeatFixedSizeArrayAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#RepeatBytes(&self, _arg_input: &[u8; 3], _arg_repeated: &mut [u8; 3]) -> binder::Result<[u8; 3]> { self._rt.block_on(self._inner.r#RepeatBytes(_arg_input, _arg_repeated)) } fn r#RepeatInts(&self, _arg_input: &[i32; 3], _arg_repeated: &mut [i32; 3]) -> binder::Result<[i32; 3]> { self._rt.block_on(self._inner.r#RepeatInts(_arg_input, _arg_repeated)) } fn r#RepeatBinders(&self, _arg_input: &[binder::SpIBinder; 3], _arg_repeated: &mut [Option; 3]) -> binder::Result<[binder::SpIBinder; 3]> { self._rt.block_on(self._inner.r#RepeatBinders(_arg_input, _arg_repeated)) } fn r#RepeatParcelables(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3], _arg_repeated: &mut [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]) -> binder::Result<[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]> { self._rt.block_on(self._inner.r#RepeatParcelables(_arg_input, _arg_repeated)) } fn r#Repeat2dBytes(&self, _arg_input: &[[u8; 3]; 2], _arg_repeated: &mut [[u8; 3]; 2]) -> binder::Result<[[u8; 3]; 2]> { self._rt.block_on(self._inner.r#Repeat2dBytes(_arg_input, _arg_repeated)) } fn r#Repeat2dInts(&self, _arg_input: &[[i32; 3]; 2], _arg_repeated: &mut [[i32; 3]; 2]) -> binder::Result<[[i32; 3]; 2]> { self._rt.block_on(self._inner.r#Repeat2dInts(_arg_input, _arg_repeated)) } fn r#Repeat2dBinders(&self, _arg_input: &[[binder::SpIBinder; 3]; 2], _arg_repeated: &mut [[Option; 3]; 2]) -> binder::Result<[[binder::SpIBinder; 3]; 2]> { self._rt.block_on(self._inner.r#Repeat2dBinders(_arg_input, _arg_repeated)) } fn r#Repeat2dParcelables(&self, _arg_input: &[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2], _arg_repeated: &mut [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]) -> binder::Result<[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]> { self._rt.block_on(self._inner.r#Repeat2dParcelables(_arg_input, _arg_repeated)) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait IRepeatFixedSizeArrayDefault: Send + Sync { fn r#RepeatBytes(&self, _arg_input: &[u8; 3], _arg_repeated: &mut [u8; 3]) -> binder::Result<[u8; 3]> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatInts(&self, _arg_input: &[i32; 3], _arg_repeated: &mut [i32; 3]) -> binder::Result<[i32; 3]> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatBinders(&self, _arg_input: &[binder::SpIBinder; 3], _arg_repeated: &mut [Option; 3]) -> binder::Result<[binder::SpIBinder; 3]> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatParcelables(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3], _arg_repeated: &mut [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]) -> binder::Result<[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#Repeat2dBytes(&self, _arg_input: &[[u8; 3]; 2], _arg_repeated: &mut [[u8; 3]; 2]) -> binder::Result<[[u8; 3]; 2]> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#Repeat2dInts(&self, _arg_input: &[[i32; 3]; 2], _arg_repeated: &mut [[i32; 3]; 2]) -> binder::Result<[[i32; 3]; 2]> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#Repeat2dBinders(&self, _arg_input: &[[binder::SpIBinder; 3]; 2], _arg_repeated: &mut [[Option; 3]; 2]) -> binder::Result<[[binder::SpIBinder; 3]; 2]> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#Repeat2dParcelables(&self, _arg_input: &[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2], _arg_repeated: &mut [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]) -> binder::Result<[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#RepeatBytes: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; pub const r#RepeatInts: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 1; pub const r#RepeatBinders: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 2; pub const r#RepeatParcelables: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 3; pub const r#Repeat2dBytes: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 4; pub const r#Repeat2dInts: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 5; pub const r#Repeat2dBinders: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 6; pub const r#Repeat2dParcelables: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 7; } pub type IRepeatFixedSizeArrayDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); impl BpRepeatFixedSizeArray { fn build_parcel_RepeatBytes(&self, _arg_input: &[u8; 3], _arg_repeated: &mut [u8; 3]) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_RepeatBytes(&self, _arg_input: &[u8; 3], _arg_repeated: &mut [u8; 3], _aidl_reply: std::result::Result) -> binder::Result<[u8; 3]> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatBytes(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: [u8; 3] = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_RepeatInts(&self, _arg_input: &[i32; 3], _arg_repeated: &mut [i32; 3]) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_RepeatInts(&self, _arg_input: &[i32; 3], _arg_repeated: &mut [i32; 3], _aidl_reply: std::result::Result) -> binder::Result<[i32; 3]> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatInts(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: [i32; 3] = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_RepeatBinders(&self, _arg_input: &[binder::SpIBinder; 3], _arg_repeated: &mut [Option; 3]) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_RepeatBinders(&self, _arg_input: &[binder::SpIBinder; 3], _arg_repeated: &mut [Option; 3], _aidl_reply: std::result::Result) -> binder::Result<[binder::SpIBinder; 3]> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatBinders(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: [binder::SpIBinder; 3] = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_RepeatParcelables(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3], _arg_repeated: &mut [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_RepeatParcelables(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3], _arg_repeated: &mut [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3], _aidl_reply: std::result::Result) -> binder::Result<[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatParcelables(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3] = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_Repeat2dBytes(&self, _arg_input: &[[u8; 3]; 2], _arg_repeated: &mut [[u8; 3]; 2]) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_Repeat2dBytes(&self, _arg_input: &[[u8; 3]; 2], _arg_repeated: &mut [[u8; 3]; 2], _aidl_reply: std::result::Result) -> binder::Result<[[u8; 3]; 2]> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#Repeat2dBytes(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: [[u8; 3]; 2] = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_Repeat2dInts(&self, _arg_input: &[[i32; 3]; 2], _arg_repeated: &mut [[i32; 3]; 2]) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_Repeat2dInts(&self, _arg_input: &[[i32; 3]; 2], _arg_repeated: &mut [[i32; 3]; 2], _aidl_reply: std::result::Result) -> binder::Result<[[i32; 3]; 2]> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#Repeat2dInts(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: [[i32; 3]; 2] = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_Repeat2dBinders(&self, _arg_input: &[[binder::SpIBinder; 3]; 2], _arg_repeated: &mut [[Option; 3]; 2]) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_Repeat2dBinders(&self, _arg_input: &[[binder::SpIBinder; 3]; 2], _arg_repeated: &mut [[Option; 3]; 2], _aidl_reply: std::result::Result) -> binder::Result<[[binder::SpIBinder; 3]; 2]> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#Repeat2dBinders(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: [[binder::SpIBinder; 3]; 2] = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_Repeat2dParcelables(&self, _arg_input: &[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2], _arg_repeated: &mut [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_Repeat2dParcelables(&self, _arg_input: &[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2], _arg_repeated: &mut [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2], _aidl_reply: std::result::Result) -> binder::Result<[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#Repeat2dParcelables(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2] = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } } impl IRepeatFixedSizeArray for BpRepeatFixedSizeArray { fn r#RepeatBytes(&self, _arg_input: &[u8; 3], _arg_repeated: &mut [u8; 3]) -> binder::Result<[u8; 3]> { let _aidl_data = self.build_parcel_RepeatBytes(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatBytes, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatBytes(_arg_input, _arg_repeated, _aidl_reply) } fn r#RepeatInts(&self, _arg_input: &[i32; 3], _arg_repeated: &mut [i32; 3]) -> binder::Result<[i32; 3]> { let _aidl_data = self.build_parcel_RepeatInts(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatInts, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatInts(_arg_input, _arg_repeated, _aidl_reply) } fn r#RepeatBinders(&self, _arg_input: &[binder::SpIBinder; 3], _arg_repeated: &mut [Option; 3]) -> binder::Result<[binder::SpIBinder; 3]> { let _aidl_data = self.build_parcel_RepeatBinders(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatBinders, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatBinders(_arg_input, _arg_repeated, _aidl_reply) } fn r#RepeatParcelables(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3], _arg_repeated: &mut [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]) -> binder::Result<[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]> { let _aidl_data = self.build_parcel_RepeatParcelables(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatParcelables, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatParcelables(_arg_input, _arg_repeated, _aidl_reply) } fn r#Repeat2dBytes(&self, _arg_input: &[[u8; 3]; 2], _arg_repeated: &mut [[u8; 3]; 2]) -> binder::Result<[[u8; 3]; 2]> { let _aidl_data = self.build_parcel_Repeat2dBytes(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#Repeat2dBytes, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_Repeat2dBytes(_arg_input, _arg_repeated, _aidl_reply) } fn r#Repeat2dInts(&self, _arg_input: &[[i32; 3]; 2], _arg_repeated: &mut [[i32; 3]; 2]) -> binder::Result<[[i32; 3]; 2]> { let _aidl_data = self.build_parcel_Repeat2dInts(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#Repeat2dInts, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_Repeat2dInts(_arg_input, _arg_repeated, _aidl_reply) } fn r#Repeat2dBinders(&self, _arg_input: &[[binder::SpIBinder; 3]; 2], _arg_repeated: &mut [[Option; 3]; 2]) -> binder::Result<[[binder::SpIBinder; 3]; 2]> { let _aidl_data = self.build_parcel_Repeat2dBinders(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#Repeat2dBinders, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_Repeat2dBinders(_arg_input, _arg_repeated, _aidl_reply) } fn r#Repeat2dParcelables(&self, _arg_input: &[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2], _arg_repeated: &mut [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]) -> binder::Result<[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]> { let _aidl_data = self.build_parcel_Repeat2dParcelables(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#Repeat2dParcelables, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_Repeat2dParcelables(_arg_input, _arg_repeated, _aidl_reply) } } impl IRepeatFixedSizeArrayAsync

for BpRepeatFixedSizeArray { fn r#RepeatBytes<'a>(&'a self, _arg_input: &'a [u8; 3], _arg_repeated: &'a mut [u8; 3]) -> binder::BoxFuture<'a, binder::Result<[u8; 3]>> { let _aidl_data = match self.build_parcel_RepeatBytes(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatBytes, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatBytes(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#RepeatInts<'a>(&'a self, _arg_input: &'a [i32; 3], _arg_repeated: &'a mut [i32; 3]) -> binder::BoxFuture<'a, binder::Result<[i32; 3]>> { let _aidl_data = match self.build_parcel_RepeatInts(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatInts, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatInts(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#RepeatBinders<'a>(&'a self, _arg_input: &'a [binder::SpIBinder; 3], _arg_repeated: &'a mut [Option; 3]) -> binder::BoxFuture<'a, binder::Result<[binder::SpIBinder; 3]>> { let _aidl_data = match self.build_parcel_RepeatBinders(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatBinders, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatBinders(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#RepeatParcelables<'a>(&'a self, _arg_input: &'a [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3], _arg_repeated: &'a mut [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]) -> binder::BoxFuture<'a, binder::Result<[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]>> { let _aidl_data = match self.build_parcel_RepeatParcelables(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatParcelables, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatParcelables(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#Repeat2dBytes<'a>(&'a self, _arg_input: &'a [[u8; 3]; 2], _arg_repeated: &'a mut [[u8; 3]; 2]) -> binder::BoxFuture<'a, binder::Result<[[u8; 3]; 2]>> { let _aidl_data = match self.build_parcel_Repeat2dBytes(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#Repeat2dBytes, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_Repeat2dBytes(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#Repeat2dInts<'a>(&'a self, _arg_input: &'a [[i32; 3]; 2], _arg_repeated: &'a mut [[i32; 3]; 2]) -> binder::BoxFuture<'a, binder::Result<[[i32; 3]; 2]>> { let _aidl_data = match self.build_parcel_Repeat2dInts(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#Repeat2dInts, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_Repeat2dInts(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#Repeat2dBinders<'a>(&'a self, _arg_input: &'a [[binder::SpIBinder; 3]; 2], _arg_repeated: &'a mut [[Option; 3]; 2]) -> binder::BoxFuture<'a, binder::Result<[[binder::SpIBinder; 3]; 2]>> { let _aidl_data = match self.build_parcel_Repeat2dBinders(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#Repeat2dBinders, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_Repeat2dBinders(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#Repeat2dParcelables<'a>(&'a self, _arg_input: &'a [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2], _arg_repeated: &'a mut [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]) -> binder::BoxFuture<'a, binder::Result<[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]>> { let _aidl_data = match self.build_parcel_Repeat2dParcelables(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#Repeat2dParcelables, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_Repeat2dParcelables(_arg_input, _arg_repeated, _aidl_reply) } ) } } impl IRepeatFixedSizeArray for binder::binder_impl::Binder { fn r#RepeatBytes(&self, _arg_input: &[u8; 3], _arg_repeated: &mut [u8; 3]) -> binder::Result<[u8; 3]> { self.0.r#RepeatBytes(_arg_input, _arg_repeated) } fn r#RepeatInts(&self, _arg_input: &[i32; 3], _arg_repeated: &mut [i32; 3]) -> binder::Result<[i32; 3]> { self.0.r#RepeatInts(_arg_input, _arg_repeated) } fn r#RepeatBinders(&self, _arg_input: &[binder::SpIBinder; 3], _arg_repeated: &mut [Option; 3]) -> binder::Result<[binder::SpIBinder; 3]> { self.0.r#RepeatBinders(_arg_input, _arg_repeated) } fn r#RepeatParcelables(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3], _arg_repeated: &mut [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]) -> binder::Result<[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]> { self.0.r#RepeatParcelables(_arg_input, _arg_repeated) } fn r#Repeat2dBytes(&self, _arg_input: &[[u8; 3]; 2], _arg_repeated: &mut [[u8; 3]; 2]) -> binder::Result<[[u8; 3]; 2]> { self.0.r#Repeat2dBytes(_arg_input, _arg_repeated) } fn r#Repeat2dInts(&self, _arg_input: &[[i32; 3]; 2], _arg_repeated: &mut [[i32; 3]; 2]) -> binder::Result<[[i32; 3]; 2]> { self.0.r#Repeat2dInts(_arg_input, _arg_repeated) } fn r#Repeat2dBinders(&self, _arg_input: &[[binder::SpIBinder; 3]; 2], _arg_repeated: &mut [[Option; 3]; 2]) -> binder::Result<[[binder::SpIBinder; 3]; 2]> { self.0.r#Repeat2dBinders(_arg_input, _arg_repeated) } fn r#Repeat2dParcelables(&self, _arg_input: &[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2], _arg_repeated: &mut [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]) -> binder::Result<[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]> { self.0.r#Repeat2dParcelables(_arg_input, _arg_repeated) } } fn on_transact(_aidl_service: &dyn IRepeatFixedSizeArray, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#RepeatBytes => { let _arg_input: [u8; 3] = _aidl_data.read()?; let mut _arg_repeated: [u8; 3] = Default::default(); let _aidl_return = _aidl_service.r#RepeatBytes(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatInts => { let _arg_input: [i32; 3] = _aidl_data.read()?; let mut _arg_repeated: [i32; 3] = Default::default(); let _aidl_return = _aidl_service.r#RepeatInts(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatBinders => { let _arg_input: [binder::SpIBinder; 3] = _aidl_data.read()?; let mut _arg_repeated: [Option; 3] = Default::default(); let _aidl_return = _aidl_service.r#RepeatBinders(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatParcelables => { let _arg_input: [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3] = _aidl_data.read()?; let mut _arg_repeated: [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3] = Default::default(); let _aidl_return = _aidl_service.r#RepeatParcelables(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#Repeat2dBytes => { let _arg_input: [[u8; 3]; 2] = _aidl_data.read()?; let mut _arg_repeated: [[u8; 3]; 2] = Default::default(); let _aidl_return = _aidl_service.r#Repeat2dBytes(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#Repeat2dInts => { let _arg_input: [[i32; 3]; 2] = _aidl_data.read()?; let mut _arg_repeated: [[i32; 3]; 2] = Default::default(); let _aidl_return = _aidl_service.r#Repeat2dInts(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#Repeat2dBinders => { let _arg_input: [[binder::SpIBinder; 3]; 2] = _aidl_data.read()?; let mut _arg_repeated: [[Option; 3]; 2] = Default::default(); let _aidl_return = _aidl_service.r#Repeat2dBinders(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#Repeat2dParcelables => { let _arg_input: [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2] = _aidl_data.read()?; let mut _arg_repeated: [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2] = Default::default(); let _aidl_return = _aidl_service.r#Repeat2dParcelables(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } } pub mod r#ByteEnum { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#ByteEnum : [i8; 1] { r#A = 0, } } } pub mod r#IntEnum { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#IntEnum : [i32; 1] { r#A = 0, } } } pub mod r#LongEnum { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#LongEnum : [i64; 1] { r#A = 0, } } } pub mod r#IntParcelable { #[derive(Debug, Clone, Copy, PartialEq)] pub struct r#IntParcelable { pub r#value: i32, } impl Default for r#IntParcelable { fn default() -> Self { Self { r#value: 0, } } } impl binder::Parcelable for r#IntParcelable { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#value)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#value = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#IntParcelable); binder::impl_deserialize_for_parcelable!(r#IntParcelable); impl binder::binder_impl::ParcelableMetadata for r#IntParcelable { fn get_descriptor() -> &'static str { "android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable" } } } pub mod r#IEmptyInterface { #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { IEmptyInterface["android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface"] { native: BnEmptyInterface(on_transact), proxy: BpEmptyInterface { }, async: IEmptyInterfaceAsync, } } pub trait IEmptyInterface: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface" } fn getDefaultImpl() -> IEmptyInterfaceDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: IEmptyInterfaceDefaultRef) -> IEmptyInterfaceDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait IEmptyInterfaceAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface" } } #[::async_trait::async_trait] pub trait IEmptyInterfaceAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface" } } impl BnEmptyInterface { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: IEmptyInterfaceAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl IEmptyInterface for Wrapper where T: IEmptyInterfaceAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait IEmptyInterfaceDefault: Send + Sync { } pub mod transactions { } pub type IEmptyInterfaceDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); impl BpEmptyInterface { } impl IEmptyInterface for BpEmptyInterface { } impl IEmptyInterfaceAsync

for BpEmptyInterface { } impl IEmptyInterface for binder::binder_impl::Binder { } fn on_transact(_aidl_service: &dyn IEmptyInterface, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } } pub(crate) mod mangled { pub use super::r#FixedSizeArrayExample as _7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample; pub use super::r#IRepeatFixedSizeArray::r#IRepeatFixedSizeArray as _7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_21_IRepeatFixedSizeArray; pub use super::r#ByteEnum::r#ByteEnum as _7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_8_ByteEnum; pub use super::r#IntEnum::r#IntEnum as _7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_7_IntEnum; pub use super::r#LongEnum::r#LongEnum as _7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_8_LongEnum; pub use super::r#IntParcelable::r#IntParcelable as _7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; pub use super::r#IEmptyInterface::r#IEmptyInterface as _7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_15_IEmptyInterface; } ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-rust-source_gen_android_aidl_fixedsizea0100644 0000000 0000000 00000000231 15172120304 033353 xustar000000000 0000000 125 path=tests/golden_output/aidl-test-fixedsizearray-rust-source/gen/android/aidl/fixedsizearray/FixedSizeArrayExample.rs.d 28 mtime=1776853188.3980000 tests/golden_output/aidl-test-fixedsizearray-rust-source/gen/android/aidl/fixedsizearray/FixedSizeAr0100644 0000000 0000000 00000000336 15172120304 033275 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-rust-source/gen/android/aidl/fixedsizearray/FixedSizeArrayExample.rs : \ system/tools/aidl/tests/android/aidl/fixedsizearray/FixedSizeArrayExample.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-fixedsizearray-rust-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 030533 xustar000000000 0000000 28 mtime=1776853188.3990000 tests/golden_output/aidl-test-fixedsizearray-rust-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 025525 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_0100644 0000000 0000000 00000000034 15172120304 026275 xustar000000000 0000000 28 mtime=1776853188.3990000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/0040755 0000000 0000000 00000000000 15172120304 023362 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_0100644 0000000 0000000 00000000034 15172120304 027126 xustar000000000 0000000 28 mtime=1776853188.3990000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/0040755 0000000 0000000 00000000000 15172120304 024133 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 030626 xustar000000000 0000000 28 mtime=1776853188.3990000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 025553 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 031617 xustar000000000 0000000 28 mtime=1776853188.3990000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 026464 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_0100644 0000000 0000000 00000000034 15172120304 033041 xustar000000000 0000000 28 mtime=1776853188.3990000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/0040755 0000000 0000000 00000000000 15172120304 027626 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_A0100644 0000000 0000000 00000000216 15172120304 033144 xustar000000000 0000000 114 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ArrayOfInterfaces.cpp 28 mtime=1776853188.3990000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ArrayOfInterfaces0100644 0000000 0000000 00000001322 15172120304 033113 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/ArrayOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ArrayOfInterfaces.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_A0100644 0000000 0000000 00000000220 15172120304 033137 xustar000000000 0000000 116 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ArrayOfInterfaces.cpp.d 28 mtime=1776853188.3990000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ArrayOfInterfaces0100644 0000000 0000000 00000000310 15172120304 033107 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ArrayOfInterfaces.cpp : \ system/tools/aidl/tests/android/aidl/tests/ArrayOfInterfaces.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_B0100644 0000000 0000000 00000000034 15172120304 033143 xustar000000000 0000000 28 mtime=1776853188.3990000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/BackendType.cpp0100644 0000000 0000000 00000001306 15172120304 032520 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/BackendType.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/BackendType.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_B0100644 0000000 0000000 00000000212 15172120304 033141 xustar000000000 0000000 110 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/BackendType.cpp.d 28 mtime=1776853188.3990000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/BackendType.cpp.d0100644 0000000 0000000 00000000274 15172120304 032745 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/BackendType.cpp : \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_B0100644 0000000 0000000 00000000034 15172120304 033143 xustar000000000 0000000 28 mtime=1776853188.3990000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ByteEnum.cpp0100644 0000000 0000000 00000001300 15172120304 032051 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/ByteEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_B0100644 0000000 0000000 00000000034 15172120304 033143 xustar000000000 0000000 28 mtime=1776853188.3990000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ByteEnum.cpp.d0100644 0000000 0000000 00000000266 15172120304 032305 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ByteEnum.cpp : \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_C0100644 0000000 0000000 00000000217 15172120304 033147 xustar000000000 0000000 115 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/CircularParcelable.cpp 28 mtime=1776853188.3990000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/CircularParcelabl0100644 0000000 0000000 00000001324 15172120304 033120 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/CircularParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_C0100644 0000000 0000000 00000000221 15172120304 033142 xustar000000000 0000000 117 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/CircularParcelable.cpp.d 28 mtime=1776853188.3990000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/CircularParcelabl0100644 0000000 0000000 00000002244 15172120304 033122 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/CircularParcelable.cpp : \ system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ITestService.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl \ system/tools/aidl/tests/android/aidl/tests/SimpleParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl \ system/tools/aidl/tests/android/aidl/tests/ICircular.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_C0100644 0000000 0000000 00000000223 15172120304 033144 xustar000000000 0000000 119 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ConstantExpressionEnum.cpp 28 mtime=1776853188.3990000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ConstantExpressio0100644 0000000 0000000 00000001334 15172120304 033242 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/ConstantExpressionEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_C0100644 0000000 0000000 00000000225 15172120304 033146 xustar000000000 0000000 121 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ConstantExpressionEnum.cpp.d 28 mtime=1776853188.3990000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ConstantExpressio0100644 0000000 0000000 00000000322 15172120304 033236 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ConstantExpressionEnum.cpp : \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_D0100644 0000000 0000000 00000000213 15172120304 033144 xustar000000000 0000000 111 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/DeprecatedEnum.cpp 28 mtime=1776853188.3990000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/DeprecatedEnum.cp0100644 0000000 0000000 00000001314 15172120304 033033 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/DeprecatedEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedEnum.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_D0100644 0000000 0000000 00000000215 15172120304 033146 xustar000000000 0000000 113 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/DeprecatedEnum.cpp.d 28 mtime=1776853188.3990000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/DeprecatedEnum.cp0100644 0000000 0000000 00000000302 15172120304 033027 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/DeprecatedEnum.cpp : \ system/tools/aidl/tests/android/aidl/tests/DeprecatedEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_D0100644 0000000 0000000 00000000221 15172120304 033143 xustar000000000 0000000 117 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/DeprecatedParcelable.cpp 28 mtime=1776853188.3990000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/DeprecatedParcela0100644 0000000 0000000 00000001330 15172120304 033073 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/DeprecatedParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedParcelable.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_D0100644 0000000 0000000 00000000223 15172120304 033145 xustar000000000 0000000 119 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/DeprecatedParcelable.cpp.d 28 mtime=1776853188.3990000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/DeprecatedParcela0100644 0000000 0000000 00000000316 15172120304 033076 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/DeprecatedParcelable.cpp : \ system/tools/aidl/tests/android/aidl/tests/DeprecatedParcelable.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_F0100644 0000000 0000000 00000000034 15172120304 033147 xustar000000000 0000000 28 mtime=1776853188.3990000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/FixedSize.cpp0100644 0000000 0000000 00000001302 15172120304 032215 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/FixedSize.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/FixedSize.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_F0100644 0000000 0000000 00000000034 15172120304 033147 xustar000000000 0000000 28 mtime=1776853188.3990000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/FixedSize.cpp.d0100644 0000000 0000000 00000000365 15172120304 032447 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/FixedSize.cpp : \ system/tools/aidl/tests/android/aidl/tests/FixedSize.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_G0100644 0000000 0000000 00000000230 15172120304 033146 xustar000000000 0000000 124 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/GenericStructuredParcelable.cpp 28 mtime=1776853188.3990000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/GenericStructured0100644 0000000 0000000 00000001346 15172120304 033213 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/GenericStructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_G0100644 0000000 0000000 00000000232 15172120304 033150 xustar000000000 0000000 126 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/GenericStructuredParcelable.cpp.d 28 mtime=1776853188.3990000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/GenericStructured0100644 0000000 0000000 00000000334 15172120304 033207 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/GenericStructuredParcelable.cpp : \ system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_I0100644 0000000 0000000 00000000034 15172120304 033152 xustar000000000 0000000 28 mtime=1776853188.3990000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ICircular.cpp0100644 0000000 0000000 00000005235 15172120304 032211 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/ICircular.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ICircular.aidl */ #include #include #include #include namespace { android::status_t analyzeICircular(uint32_t _aidl_code, const android::Parcel& _aidl_data, const android::Parcel& _aidl_reply) { android::status_t _aidl_ret_status; switch(_aidl_code) { case ::android::IBinder::FIRST_CALL_TRANSACTION + 0: { std::cout << "ICircular.GetTestService()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ICircular")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::sp<::android::aidl::tests::ITestService> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readNullableStrongBinder(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails } while(false); std::cout << " arguments: " << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; default: { std::cout << " Transaction code " << _aidl_code << " not known." << std::endl; _aidl_ret_status = android::UNKNOWN_TRANSACTION; } } return _aidl_ret_status; // To prevent unused variable warnings (void)_aidl_ret_status; (void)_aidl_data; (void)_aidl_reply; } } // namespace #include using android::aidl::Analyzer; __attribute__((constructor)) static void addAnalyzer() { Analyzer::installAnalyzer(std::make_unique("android.aidl.tests.ICircular", "ICircular", &analyzeICircular)); } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_I0100644 0000000 0000000 00000000034 15172120304 033152 xustar000000000 0000000 28 mtime=1776853188.4000000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ICircular.cpp.d0100644 0000000 0000000 00000002233 15172120304 032426 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ICircular.cpp : \ system/tools/aidl/tests/android/aidl/tests/ICircular.aidl \ system/tools/aidl/tests/android/aidl/tests/ITestService.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl \ system/tools/aidl/tests/android/aidl/tests/SimpleParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl \ system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_I0100644 0000000 0000000 00000000034 15172120304 033152 xustar000000000 0000000 28 mtime=1776853188.4000000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/IDeprecated.cpp0100644 0000000 0000000 00000002756 15172120304 032512 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/IDeprecated.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IDeprecated.aidl */ #include #include #include #include namespace { android::status_t analyzeIDeprecated(uint32_t _aidl_code, const android::Parcel& _aidl_data, const android::Parcel& _aidl_reply) { android::status_t _aidl_ret_status; switch(_aidl_code) { default: { std::cout << " Transaction code " << _aidl_code << " not known." << std::endl; _aidl_ret_status = android::UNKNOWN_TRANSACTION; } } return _aidl_ret_status; // To prevent unused variable warnings (void)_aidl_ret_status; (void)_aidl_data; (void)_aidl_reply; } } // namespace #include using android::aidl::Analyzer; __attribute__((constructor)) static void addAnalyzer() { Analyzer::installAnalyzer(std::make_unique("android.aidl.tests.IDeprecated", "IDeprecated", &analyzeIDeprecated)); } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_I0100644 0000000 0000000 00000000212 15172120304 033150 xustar000000000 0000000 110 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/IDeprecated.cpp.d 28 mtime=1776853188.4000000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/IDeprecated.cpp.d0100644 0000000 0000000 00000000274 15172120304 032725 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/IDeprecated.cpp : \ system/tools/aidl/tests/android/aidl/tests/IDeprecated.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_I0100644 0000000 0000000 00000000213 15172120304 033151 xustar000000000 0000000 111 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/INamedCallback.cpp 28 mtime=1776853188.4000000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/INamedCallback.cp0100644 0000000 0000000 00000005227 15172120304 032727 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/INamedCallback.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl */ #include #include #include #include namespace { android::status_t analyzeINamedCallback(uint32_t _aidl_code, const android::Parcel& _aidl_data, const android::Parcel& _aidl_reply) { android::status_t _aidl_ret_status; switch(_aidl_code) { case ::android::IBinder::FIRST_CALL_TRANSACTION + 0: { std::cout << "INamedCallback.GetName()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.INamedCallback")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::String16 _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readString16(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails } while(false); std::cout << " arguments: " << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; default: { std::cout << " Transaction code " << _aidl_code << " not known." << std::endl; _aidl_ret_status = android::UNKNOWN_TRANSACTION; } } return _aidl_ret_status; // To prevent unused variable warnings (void)_aidl_ret_status; (void)_aidl_data; (void)_aidl_reply; } } // namespace #include using android::aidl::Analyzer; __attribute__((constructor)) static void addAnalyzer() { Analyzer::installAnalyzer(std::make_unique("android.aidl.tests.INamedCallback", "INamedCallback", &analyzeINamedCallback)); } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_I0100644 0000000 0000000 00000000215 15172120304 033153 xustar000000000 0000000 113 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/INamedCallback.cpp.d 28 mtime=1776853188.4000000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/INamedCallback.cp0100644 0000000 0000000 00000000302 15172120304 032714 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/INamedCallback.cpp : \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_I0100644 0000000 0000000 00000000034 15172120304 033152 xustar000000000 0000000 28 mtime=1776853188.4000000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/INewName.cpp0100644 0000000 0000000 00000005142 15172120304 031774 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/INewName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INewName.aidl */ #include #include #include #include namespace { android::status_t analyzeINewName(uint32_t _aidl_code, const android::Parcel& _aidl_data, const android::Parcel& _aidl_reply) { android::status_t _aidl_ret_status; switch(_aidl_code) { case ::android::IBinder::FIRST_CALL_TRANSACTION + 0: { std::cout << "INewName.RealName()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.IOldName")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::String16 _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readString16(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails } while(false); std::cout << " arguments: " << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; default: { std::cout << " Transaction code " << _aidl_code << " not known." << std::endl; _aidl_ret_status = android::UNKNOWN_TRANSACTION; } } return _aidl_ret_status; // To prevent unused variable warnings (void)_aidl_ret_status; (void)_aidl_data; (void)_aidl_reply; } } // namespace #include using android::aidl::Analyzer; __attribute__((constructor)) static void addAnalyzer() { Analyzer::installAnalyzer(std::make_unique("android.aidl.tests.INewName", "INewName", &analyzeINewName)); } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_I0100644 0000000 0000000 00000000034 15172120304 033152 xustar000000000 0000000 28 mtime=1776853188.4000000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/INewName.cpp.d0100644 0000000 0000000 00000000266 15172120304 032220 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/INewName.cpp : \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_I0100644 0000000 0000000 00000000034 15172120304 033152 xustar000000000 0000000 28 mtime=1776853188.4000000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/IOldName.cpp0100644 0000000 0000000 00000005142 15172120304 031761 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/IOldName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IOldName.aidl */ #include #include #include #include namespace { android::status_t analyzeIOldName(uint32_t _aidl_code, const android::Parcel& _aidl_data, const android::Parcel& _aidl_reply) { android::status_t _aidl_ret_status; switch(_aidl_code) { case ::android::IBinder::FIRST_CALL_TRANSACTION + 0: { std::cout << "IOldName.RealName()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.IOldName")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::String16 _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readString16(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails } while(false); std::cout << " arguments: " << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; default: { std::cout << " Transaction code " << _aidl_code << " not known." << std::endl; _aidl_ret_status = android::UNKNOWN_TRANSACTION; } } return _aidl_ret_status; // To prevent unused variable warnings (void)_aidl_ret_status; (void)_aidl_data; (void)_aidl_reply; } } // namespace #include using android::aidl::Analyzer; __attribute__((constructor)) static void addAnalyzer() { Analyzer::installAnalyzer(std::make_unique("android.aidl.tests.IOldName", "IOldName", &analyzeIOldName)); } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_I0100644 0000000 0000000 00000000034 15172120304 033152 xustar000000000 0000000 28 mtime=1776853188.4000000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/IOldName.cpp.d0100644 0000000 0000000 00000000266 15172120304 032205 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/IOldName.cpp : \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_I0100644 0000000 0000000 00000000034 15172120304 033152 xustar000000000 0000000 28 mtime=1776853188.4000000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ITestService.cpp0100644 0000000 0000000 00000375431 15172120304 032715 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/ITestService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ITestService.aidl */ #include #include #include #include namespace { android::status_t analyzeITestService(uint32_t _aidl_code, const android::Parcel& _aidl_data, const android::Parcel& _aidl_reply) { android::status_t _aidl_ret_status; switch(_aidl_code) { case ::android::IBinder::FIRST_CALL_TRANSACTION + 0: { std::cout << "ITestService.UnimplementedMethod()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } int32_t in_arg; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); int32_t _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readInt32(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readInt32(&in_arg); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument arg from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " arg: " << ::android::internal::ToString(in_arg) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 1: { std::cout << "ITestService.Deprecated()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); do { // Single-pass loop to break if argument reading fails } while(false); std::cout << " arguments: " << std::endl; std::cout << " return: void" << std::endl; } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 2: { std::cout << "ITestService.TestOneway()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); do { // Single-pass loop to break if argument reading fails } while(false); std::cout << " arguments: " << std::endl; std::cout << " return: void" << std::endl; } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 3: { std::cout << "ITestService.RepeatBoolean()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } bool in_token; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); bool _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readBool(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readBool(&in_token); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument token from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " token: " << ::android::internal::ToString(in_token) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 4: { std::cout << "ITestService.RepeatByte()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } int8_t in_token; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); int8_t _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readByte(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readByte(&in_token); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument token from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " token: " << ::android::internal::ToString(in_token) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 5: { std::cout << "ITestService.RepeatChar()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } char16_t in_token; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); char16_t _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readChar(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readChar(&in_token); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument token from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " token: " << ::android::internal::ToString(in_token) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 6: { std::cout << "ITestService.RepeatInt()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } int32_t in_token; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); int32_t _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readInt32(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readInt32(&in_token); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument token from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " token: " << ::android::internal::ToString(in_token) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 7: { std::cout << "ITestService.RepeatLong()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } int64_t in_token; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); int64_t _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readInt64(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readInt64(&in_token); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument token from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " token: " << ::android::internal::ToString(in_token) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 8: { std::cout << "ITestService.RepeatFloat()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } float in_token; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); float _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readFloat(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readFloat(&in_token); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument token from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " token: " << ::android::internal::ToString(in_token) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 9: { std::cout << "ITestService.RepeatDouble()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } double in_token; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); double _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readDouble(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readDouble(&in_token); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument token from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " token: " << ::android::internal::ToString(in_token) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 10: { std::cout << "ITestService.RepeatString()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::String16 in_token; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::String16 _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readString16(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readString16(&in_token); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument token from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " token: " << ::android::internal::ToString(in_token) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 11: { std::cout << "ITestService.RepeatByteEnum()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::aidl::tests::ByteEnum in_token; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::aidl::tests::ByteEnum _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readByte(reinterpret_cast(&_aidl_return)); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readByte(reinterpret_cast(&in_token)); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument token from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " token: " << ::android::internal::ToString(in_token) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 12: { std::cout << "ITestService.RepeatIntEnum()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::aidl::tests::IntEnum in_token; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::aidl::tests::IntEnum _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readInt32(reinterpret_cast(&_aidl_return)); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readInt32(reinterpret_cast(&in_token)); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument token from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " token: " << ::android::internal::ToString(in_token) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 13: { std::cout << "ITestService.RepeatLongEnum()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::aidl::tests::LongEnum in_token; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::aidl::tests::LongEnum _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readInt64(reinterpret_cast(&_aidl_return)); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readInt64(reinterpret_cast(&in_token)); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument token from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " token: " << ::android::internal::ToString(in_token) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 14: { std::cout << "ITestService.ReverseBoolean()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector in_input; ::std::vector out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readBoolVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readBoolVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readBoolVector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 15: { std::cout << "ITestService.ReverseByte()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector in_input; ::std::vector out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readByteVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readByteVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readByteVector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 16: { std::cout << "ITestService.ReverseChar()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector in_input; ::std::vector out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readCharVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readCharVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readCharVector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 17: { std::cout << "ITestService.ReverseInt()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector in_input; ::std::vector out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readInt32Vector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readInt32Vector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readInt32Vector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 18: { std::cout << "ITestService.ReverseLong()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector in_input; ::std::vector out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readInt64Vector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readInt64Vector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readInt64Vector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 19: { std::cout << "ITestService.ReverseFloat()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector in_input; ::std::vector out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readFloatVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readFloatVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readFloatVector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 20: { std::cout << "ITestService.ReverseDouble()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector in_input; ::std::vector out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readDoubleVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readDoubleVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readDoubleVector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 21: { std::cout << "ITestService.ReverseString()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector<::android::String16> in_input; ::std::vector<::android::String16> out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector<::android::String16> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readString16Vector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readString16Vector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readString16Vector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 22: { std::cout << "ITestService.ReverseByteEnum()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector<::android::aidl::tests::ByteEnum> in_input; ::std::vector<::android::aidl::tests::ByteEnum> out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector<::android::aidl::tests::ByteEnum> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readEnumVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readEnumVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readEnumVector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 23: { std::cout << "ITestService.ReverseIntEnum()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector<::android::aidl::tests::IntEnum> in_input; ::std::vector<::android::aidl::tests::IntEnum> out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector<::android::aidl::tests::IntEnum> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readEnumVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readEnumVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readEnumVector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 24: { std::cout << "ITestService.ReverseLongEnum()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector<::android::aidl::tests::LongEnum> in_input; ::std::vector<::android::aidl::tests::LongEnum> out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector<::android::aidl::tests::LongEnum> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readEnumVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readEnumVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readEnumVector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 25: { std::cout << "ITestService.GetOtherTestService()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::String16 in_name; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::sp<::android::aidl::tests::INamedCallback> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readStrongBinder(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readString16(&in_name); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument name from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " name: " << ::android::internal::ToString(in_name) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 26: { std::cout << "ITestService.SetOtherTestService()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::String16 in_name; ::android::sp<::android::aidl::tests::INamedCallback> in_service; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); bool _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readBool(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readString16(&in_name); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument name from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readStrongBinder(&in_service); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument service from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " name: " << ::android::internal::ToString(in_name) << std::endl; std::cout << " service: " << ::android::internal::ToString(in_service) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 27: { std::cout << "ITestService.VerifyName()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::sp<::android::aidl::tests::INamedCallback> in_service; ::android::String16 in_name; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); bool _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readBool(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readStrongBinder(&in_service); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument service from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readString16(&in_name); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument name from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " service: " << ::android::internal::ToString(in_service) << std::endl; std::cout << " name: " << ::android::internal::ToString(in_name) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 28: { std::cout << "ITestService.GetInterfaceArray()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector<::android::String16> in_names; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector<::android::sp<::android::aidl::tests::INamedCallback>> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readStrongBinderVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readString16Vector(&in_names); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument names from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " names: " << ::android::internal::ToString(in_names) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 29: { std::cout << "ITestService.VerifyNamesWithInterfaceArray()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector<::android::sp<::android::aidl::tests::INamedCallback>> in_services; ::std::vector<::android::String16> in_names; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); bool _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readBool(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_services); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument services from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readString16Vector(&in_names); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument names from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " services: " << ::android::internal::ToString(in_services) << std::endl; std::cout << " names: " << ::android::internal::ToString(in_names) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 30: { std::cout << "ITestService.GetNullableInterfaceArray()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::std::vector<::std::optional<::android::String16>>> in_names; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readStrongBinderVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readString16Vector(&in_names); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument names from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " names: " << ::android::internal::ToString(in_names) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 31: { std::cout << "ITestService.VerifyNamesWithNullableInterfaceArray()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>> in_services; ::std::optional<::std::vector<::std::optional<::android::String16>>> in_names; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); bool _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readBool(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_services); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument services from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readString16Vector(&in_names); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument names from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " services: " << ::android::internal::ToString(in_services) << std::endl; std::cout << " names: " << ::android::internal::ToString(in_names) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 32: { std::cout << "ITestService.GetInterfaceList()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::std::vector<::std::optional<::android::String16>>> in_names; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readStrongBinderVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readString16Vector(&in_names); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument names from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " names: " << ::android::internal::ToString(in_names) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 33: { std::cout << "ITestService.VerifyNamesWithInterfaceList()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>> in_services; ::std::optional<::std::vector<::std::optional<::android::String16>>> in_names; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); bool _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readBool(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_services); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument services from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readString16Vector(&in_names); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument names from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " services: " << ::android::internal::ToString(in_services) << std::endl; std::cout << " names: " << ::android::internal::ToString(in_names) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 34: { std::cout << "ITestService.ReverseStringList()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector<::android::String16> in_input; ::std::vector<::android::String16> out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector<::android::String16> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readString16Vector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readString16Vector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readString16Vector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 35: { std::cout << "ITestService.RepeatParcelFileDescriptor()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::os::ParcelFileDescriptor in_read; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::os::ParcelFileDescriptor _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readParcelable(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readParcelable(&in_read); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument read from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " read: " << ::android::internal::ToString(in_read) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 36: { std::cout << "ITestService.ReverseParcelFileDescriptorArray()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector<::android::os::ParcelFileDescriptor> in_input; ::std::vector<::android::os::ParcelFileDescriptor> out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector<::android::os::ParcelFileDescriptor> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readParcelableVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readParcelableVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readParcelableVector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 37: { std::cout << "ITestService.ThrowServiceException()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } int32_t in_code; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readInt32(&in_code); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument code from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " code: " << ::android::internal::ToString(in_code) << std::endl; std::cout << " return: void" << std::endl; } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 38: { std::cout << "ITestService.RepeatNullableIntArray()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::std::vector> in_input; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::optional<::std::vector> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readInt32Vector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readInt32Vector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 39: { std::cout << "ITestService.RepeatNullableByteEnumArray()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::std::vector<::android::aidl::tests::ByteEnum>> in_input; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::optional<::std::vector<::android::aidl::tests::ByteEnum>> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readEnumVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readEnumVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 40: { std::cout << "ITestService.RepeatNullableIntEnumArray()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::std::vector<::android::aidl::tests::IntEnum>> in_input; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::optional<::std::vector<::android::aidl::tests::IntEnum>> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readEnumVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readEnumVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 41: { std::cout << "ITestService.RepeatNullableLongEnumArray()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::std::vector<::android::aidl::tests::LongEnum>> in_input; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::optional<::std::vector<::android::aidl::tests::LongEnum>> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readEnumVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readEnumVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 42: { std::cout << "ITestService.RepeatNullableString()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::android::String16> in_input; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::optional<::android::String16> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readString16(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readString16(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 43: { std::cout << "ITestService.RepeatNullableStringList()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::std::vector<::std::optional<::android::String16>>> in_input; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::optional<::std::vector<::std::optional<::android::String16>>> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readString16Vector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readString16Vector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 44: { std::cout << "ITestService.RepeatNullableParcelable()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::android::aidl::tests::ITestService::Empty> in_input; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::optional<::android::aidl::tests::ITestService::Empty> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readParcelable(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 45: { std::cout << "ITestService.RepeatNullableParcelableArray()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>> in_input; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readParcelableVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readParcelableVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 46: { std::cout << "ITestService.RepeatNullableParcelableList()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>> in_input; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readParcelableVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readParcelableVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 47: { std::cout << "ITestService.TakesAnIBinder()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::sp<::android::IBinder> in_input; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readStrongBinder(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " return: void" << std::endl; } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 48: { std::cout << "ITestService.TakesANullableIBinder()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::sp<::android::IBinder> in_input; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readNullableStrongBinder(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " return: void" << std::endl; } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 49: { std::cout << "ITestService.TakesAnIBinderList()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector<::android::sp<::android::IBinder>> in_input; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " return: void" << std::endl; } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 50: { std::cout << "ITestService.TakesANullableIBinderList()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::std::vector<::android::sp<::android::IBinder>>> in_input; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " return: void" << std::endl; } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 51: { std::cout << "ITestService.RepeatUtf8CppString()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::string in_token; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::string _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readUtf8FromUtf16(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readUtf8FromUtf16(&in_token); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument token from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " token: " << ::android::internal::ToString(in_token) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 52: { std::cout << "ITestService.RepeatNullableUtf8CppString()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::std::string> in_token; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::optional<::std::string> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readUtf8FromUtf16(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readUtf8FromUtf16(&in_token); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument token from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " token: " << ::android::internal::ToString(in_token) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 53: { std::cout << "ITestService.ReverseUtf8CppString()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector<::std::string> in_input; ::std::vector<::std::string> out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector<::std::string> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readUtf8VectorFromUtf16Vector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readUtf8VectorFromUtf16Vector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readUtf8VectorFromUtf16Vector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 54: { std::cout << "ITestService.ReverseNullableUtf8CppString()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::std::vector<::std::optional<::std::string>>> in_input; ::std::optional<::std::vector<::std::optional<::std::string>>> out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::optional<::std::vector<::std::optional<::std::string>>> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readUtf8VectorFromUtf16Vector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readUtf8VectorFromUtf16Vector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readUtf8VectorFromUtf16Vector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 55: { std::cout << "ITestService.ReverseUtf8CppStringList()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::std::vector<::std::optional<::std::string>>> in_input; ::std::optional<::std::vector<::std::optional<::std::string>>> out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::optional<::std::vector<::std::optional<::std::string>>> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readUtf8VectorFromUtf16Vector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readUtf8VectorFromUtf16Vector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readUtf8VectorFromUtf16Vector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 56: { std::cout << "ITestService.GetCallback()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } bool in_return_null; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::sp<::android::aidl::tests::INamedCallback> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readNullableStrongBinder(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readBool(&in_return_null); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument return_null from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " return_null: " << ::android::internal::ToString(in_return_null) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 57: { std::cout << "ITestService.FillOutStructuredParcelable()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::aidl::tests::StructuredParcelable in_parcel; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readParcelable(&in_parcel); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument parcel from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " parcel: " << ::android::internal::ToString(in_parcel) << std::endl; std::cout << " return: void" << std::endl; } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 58: { std::cout << "ITestService.RepeatExtendableParcelable()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::aidl::tests::extension::ExtendableParcelable in_ep; ::android::aidl::tests::extension::ExtendableParcelable out_ep2; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readParcelable(&in_ep); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument ep from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readParcelable(&out_ep2); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument ep2 from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " ep: " << ::android::internal::ToString(in_ep) << std::endl; std::cout << " ep2: " << ::android::internal::ToString(out_ep2) << std::endl; std::cout << " return: void" << std::endl; } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 59: { std::cout << "ITestService.ReverseList()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::aidl::tests::RecursiveList in_list; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::aidl::tests::RecursiveList _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readParcelable(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readParcelable(&in_list); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument list from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " list: " << ::android::internal::ToString(in_list) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 60: { std::cout << "ITestService.ReverseIBinderArray()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector<::android::sp<::android::IBinder>> in_input; ::std::vector<::android::sp<::android::IBinder>> out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector<::android::sp<::android::IBinder>> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readStrongBinderVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readStrongBinderVector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 61: { std::cout << "ITestService.ReverseNullableIBinderArray()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::std::vector<::android::sp<::android::IBinder>>> in_input; ::std::optional<::std::vector<::android::sp<::android::IBinder>>> out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::optional<::std::vector<::android::sp<::android::IBinder>>> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readStrongBinderVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readStrongBinderVector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 62: { std::cout << "ITestService.RepeatSimpleParcelable()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::aidl::tests::SimpleParcelable in_input; ::android::aidl::tests::SimpleParcelable out_repeat; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::aidl::tests::SimpleParcelable _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readParcelable(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readParcelable(&out_repeat); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeat from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeat: " << ::android::internal::ToString(out_repeat) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 63: { std::cout << "ITestService.ReverseSimpleParcelables()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector<::android::aidl::tests::SimpleParcelable> in_input; ::std::vector<::android::aidl::tests::SimpleParcelable> out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector<::android::aidl::tests::SimpleParcelable> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readParcelableVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readParcelableVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readParcelableVector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 64: { std::cout << "ITestService.GetOldNameInterface()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::sp<::android::aidl::tests::IOldName> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readStrongBinder(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails } while(false); std::cout << " arguments: " << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 65: { std::cout << "ITestService.GetNewNameInterface()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::sp<::android::aidl::tests::INewName> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readStrongBinder(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails } while(false); std::cout << " arguments: " << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 66: { std::cout << "ITestService.GetUnionTags()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector<::android::aidl::tests::Union> in_input; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector<::android::aidl::tests::Union::Tag> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readEnumVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readParcelableVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 67: { std::cout << "ITestService.GetCppJavaTests()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::sp<::android::IBinder> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readNullableStrongBinder(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails } while(false); std::cout << " arguments: " << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 68: { std::cout << "ITestService.getBackendType()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::aidl::tests::BackendType _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readByte(reinterpret_cast(&_aidl_return)); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails } while(false); std::cout << " arguments: " << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 69: { std::cout << "ITestService.GetCircular()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::aidl::tests::CircularParcelable out_cp; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::sp<::android::aidl::tests::ICircular> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readStrongBinder(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readParcelable(&out_cp); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument cp from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " cp: " << ::android::internal::ToString(out_cp) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; default: { std::cout << " Transaction code " << _aidl_code << " not known." << std::endl; _aidl_ret_status = android::UNKNOWN_TRANSACTION; } } return _aidl_ret_status; // To prevent unused variable warnings (void)_aidl_ret_status; (void)_aidl_data; (void)_aidl_reply; } } // namespace #include using android::aidl::Analyzer; __attribute__((constructor)) static void addAnalyzer() { Analyzer::installAnalyzer(std::make_unique("android.aidl.tests.ITestService", "ITestService", &analyzeITestService)); } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_I0100644 0000000 0000000 00000000213 15172120304 033151 xustar000000000 0000000 111 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ITestService.cpp.d 28 mtime=1776853188.4020000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ITestService.cpp.0100644 0000000 0000000 00000002236 15172120304 032761 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ITestService.cpp : \ system/tools/aidl/tests/android/aidl/tests/ITestService.aidl \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ICircular.aidl \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl \ system/tools/aidl/tests/android/aidl/tests/SimpleParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_I0100644 0000000 0000000 00000000034 15172120304 033152 xustar000000000 0000000 28 mtime=1776853188.4020000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/IntEnum.cpp0100644 0000000 0000000 00000001276 15172120304 031714 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/IntEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_I0100644 0000000 0000000 00000000034 15172120304 033152 xustar000000000 0000000 28 mtime=1776853188.4020000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/IntEnum.cpp.d0100644 0000000 0000000 00000000264 15172120304 032132 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/IntEnum.cpp : \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_L0100644 0000000 0000000 00000000215 15172120304 033156 xustar000000000 0000000 113 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ListOfInterfaces.cpp 28 mtime=1776853188.4020000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ListOfInterfaces.0100644 0000000 0000000 00000001320 15172120304 033024 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/ListOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ListOfInterfaces.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_L0100644 0000000 0000000 00000000217 15172120304 033160 xustar000000000 0000000 115 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ListOfInterfaces.cpp.d 28 mtime=1776853188.4020000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ListOfInterfaces.0100644 0000000 0000000 00000000306 15172120304 033027 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ListOfInterfaces.cpp : \ system/tools/aidl/tests/android/aidl/tests/ListOfInterfaces.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_L0100644 0000000 0000000 00000000034 15172120304 033155 xustar000000000 0000000 28 mtime=1776853188.4020000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/LongEnum.cpp0100644 0000000 0000000 00000001300 15172120304 032045 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/LongEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_L0100644 0000000 0000000 00000000034 15172120304 033155 xustar000000000 0000000 28 mtime=1776853188.4020000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/LongEnum.cpp.d0100644 0000000 0000000 00000000266 15172120304 032301 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/LongEnum.cpp : \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_O0100644 0000000 0000000 00000000227 15172120304 033164 xustar000000000 0000000 123 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/OtherParcelableForToString.cpp 28 mtime=1776853188.4030000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/OtherParcelableFo0100644 0000000 0000000 00000001344 15172120304 033071 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/OtherParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_O0100644 0000000 0000000 00000000231 15172120304 033157 xustar000000000 0000000 125 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/OtherParcelableForToString.cpp.d 28 mtime=1776853188.4030000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/OtherParcelableFo0100644 0000000 0000000 00000000332 15172120304 033065 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/OtherParcelableForToString.cpp : \ system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_P0100644 0000000 0000000 00000000222 15172120304 033160 xustar000000000 0000000 118 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ParcelableForToString.cpp 28 mtime=1776853188.4030000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ParcelableForToSt0100644 0000000 0000000 00000001332 15172120304 033060 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/ParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ParcelableForToString.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_P0100644 0000000 0000000 00000000224 15172120304 033162 xustar000000000 0000000 120 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ParcelableForToString.cpp.d 28 mtime=1776853188.4030000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ParcelableForToSt0100644 0000000 0000000 00000001363 15172120304 033064 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ParcelableForToString.cpp : \ system/tools/aidl/tests/android/aidl/tests/ParcelableForToString.aidl \ system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_R0100644 0000000 0000000 00000000212 15172120304 033161 xustar000000000 0000000 110 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/RecursiveList.cpp 28 mtime=1776853188.4030000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/RecursiveList.cpp0100644 0000000 0000000 00000001312 15172120304 033127 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/RecursiveList.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_R0100644 0000000 0000000 00000000214 15172120304 033163 xustar000000000 0000000 112 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/RecursiveList.cpp.d 28 mtime=1776853188.4030000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/RecursiveList.cpp0100644 0000000 0000000 00000000300 15172120304 033123 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/RecursiveList.cpp : \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_S0100644 0000000 0000000 00000000221 15172120304 033162 xustar000000000 0000000 117 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/StructuredParcelable.cpp 28 mtime=1776853188.4030000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/StructuredParcela0100644 0000000 0000000 00000001330 15172120304 033177 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/StructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_S0100644 0000000 0000000 00000000223 15172120304 033164 xustar000000000 0000000 119 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/StructuredParcelable.cpp.d 28 mtime=1776853188.4030000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/StructuredParcela0100644 0000000 0000000 00000001011 15172120304 033173 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/StructuredParcelable.cpp : \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_U0100644 0000000 0000000 00000000034 15172120304 033166 xustar000000000 0000000 28 mtime=1776853188.4030000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/Union.cpp0100644 0000000 0000000 00000001272 15172120304 031421 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/Union.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/Union.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_U0100644 0000000 0000000 00000000034 15172120304 033166 xustar000000000 0000000 28 mtime=1776853188.4030000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/Union.cpp.d0100644 0000000 0000000 00000000355 15172120304 031644 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/Union.cpp : \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_U0100644 0000000 0000000 00000000034 15172120304 033166 xustar000000000 0000000 28 mtime=1776853188.4030000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/UnionWithFd.cpp0100644 0000000 0000000 00000001306 15172120304 032525 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/UnionWithFd.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/UnionWithFd.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_U0100644 0000000 0000000 00000000212 15172120304 033164 xustar000000000 0000000 110 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/UnionWithFd.cpp.d 28 mtime=1776853188.4030000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/UnionWithFd.cpp.d0100644 0000000 0000000 00000000274 15172120304 032752 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/UnionWithFd.cpp : \ system/tools/aidl/tests/android/aidl/tests/UnionWithFd.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_e0100644 0000000 0000000 00000000034 15172120304 033206 xustar000000000 0000000 28 mtime=1776853188.4030000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/0040755 0000000 0000000 00000000000 15172120304 031642 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_e0100644 0000000 0000000 00000000233 15172120304 033207 xustar000000000 0000000 127 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/ExtendableParcelable.cpp 28 mtime=1776853188.4030000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/Extenda0100644 0000000 0000000 00000001354 15172120304 033155 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/extension/ExtendableParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_e0100644 0000000 0000000 00000000235 15172120304 033211 xustar000000000 0000000 129 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/ExtendableParcelable.cpp.d 28 mtime=1776853188.4030000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/Extenda0100644 0000000 0000000 00000000342 15172120304 033151 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/ExtendableParcelable.cpp : \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_e0100644 0000000 0000000 00000000214 15172120304 033206 xustar000000000 0000000 112 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/MyExt.cpp 28 mtime=1776853188.4030000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/MyExt.c0100644 0000000 0000000 00000001316 15172120304 033052 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/extension/MyExt.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_e0100644 0000000 0000000 00000000216 15172120304 033210 xustar000000000 0000000 114 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/MyExt.cpp.d 28 mtime=1776853188.4030000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/MyExt.c0100644 0000000 0000000 00000000304 15172120304 033046 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/MyExt.cpp : \ system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_e0100644 0000000 0000000 00000000215 15172120304 033207 xustar000000000 0000000 113 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/MyExt2.cpp 28 mtime=1776853188.4030000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/MyExt2.0100644 0000000 0000000 00000001320 15172120304 032764 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/extension/MyExt2.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt2.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_e0100644 0000000 0000000 00000000217 15172120304 033211 xustar000000000 0000000 115 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/MyExt2.cpp.d 28 mtime=1776853188.4030000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/MyExt2.0100644 0000000 0000000 00000000412 15172120304 032765 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/MyExt2.cpp : \ system/tools/aidl/tests/android/aidl/tests/extension/MyExt2.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_e0100644 0000000 0000000 00000000220 15172120304 033203 xustar000000000 0000000 116 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/MyExtLike.cpp 28 mtime=1776853188.4030000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/MyExtLi0100644 0000000 0000000 00000001326 15172120304 033117 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/extension/MyExtLike.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExtLike.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_e0100644 0000000 0000000 00000000222 15172120304 033205 xustar000000000 0000000 118 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/MyExtLike.cpp.d 28 mtime=1776853188.4030000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/MyExtLi0100644 0000000 0000000 00000000314 15172120304 033113 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/MyExtLike.cpp : \ system/tools/aidl/tests/android/aidl/tests/extension/MyExtLike.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_n0100644 0000000 0000000 00000000034 15172120304 033217 xustar000000000 0000000 28 mtime=1776853188.4030000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/nested/0040755 0000000 0000000 00000000000 15172120304 031110 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_n0100644 0000000 0000000 00000000220 15172120304 033214 xustar000000000 0000000 116 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/nested/DeeplyNested.cpp 28 mtime=1776853188.4030000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/nested/DeeplyNest0100644 0000000 0000000 00000001326 15172120304 033106 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/nested/DeeplyNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/DeeplyNested.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_n0100644 0000000 0000000 00000000222 15172120304 033216 xustar000000000 0000000 118 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/nested/DeeplyNested.cpp.d 28 mtime=1776853188.4030000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/nested/DeeplyNest0100644 0000000 0000000 00000000314 15172120304 033102 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/nested/DeeplyNested.cpp : \ system/tools/aidl/tests/android/aidl/tests/nested/DeeplyNested.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_n0100644 0000000 0000000 00000000222 15172120304 033216 xustar000000000 0000000 118 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/nested/INestedService.cpp 28 mtime=1776853188.4030000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/nested/INestedSer0100644 0000000 0000000 00000012032 15172120304 033033 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/nested/INestedService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/INestedService.aidl */ #include #include #include #include namespace { android::status_t analyzeINestedService(uint32_t _aidl_code, const android::Parcel& _aidl_data, const android::Parcel& _aidl_reply) { android::status_t _aidl_ret_status; switch(_aidl_code) { case ::android::IBinder::FIRST_CALL_TRANSACTION + 0: { std::cout << "INestedService.flipStatus()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.nested.INestedService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::aidl::tests::nested::ParcelableWithNested in_p; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::aidl::tests::nested::INestedService::Result _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readParcelable(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readParcelable(&in_p); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument p from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " p: " << ::android::internal::ToString(in_p) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 1: { std::cout << "INestedService.flipStatusWithCallback()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.nested.INestedService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::aidl::tests::nested::ParcelableWithNested::Status in_status; ::android::sp<::android::aidl::tests::nested::INestedService::ICallback> in_cb; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readByte(reinterpret_cast(&in_status)); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument status from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readStrongBinder(&in_cb); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument cb from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " status: " << ::android::internal::ToString(in_status) << std::endl; std::cout << " cb: " << ::android::internal::ToString(in_cb) << std::endl; std::cout << " return: void" << std::endl; } break; default: { std::cout << " Transaction code " << _aidl_code << " not known." << std::endl; _aidl_ret_status = android::UNKNOWN_TRANSACTION; } } return _aidl_ret_status; // To prevent unused variable warnings (void)_aidl_ret_status; (void)_aidl_data; (void)_aidl_reply; } } // namespace #include using android::aidl::Analyzer; __attribute__((constructor)) static void addAnalyzer() { Analyzer::installAnalyzer(std::make_unique("android.aidl.tests.nested.INestedService", "INestedService", &analyzeINestedService)); } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_n0100644 0000000 0000000 00000000224 15172120304 033220 xustar000000000 0000000 120 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/nested/INestedService.cpp.d 28 mtime=1776853188.4040000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/nested/INestedSer0100644 0000000 0000000 00000000440 15172120304 033033 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/nested/INestedService.cpp : \ system/tools/aidl/tests/android/aidl/tests/nested/INestedService.aidl \ system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_n0100644 0000000 0000000 00000000230 15172120304 033215 xustar000000000 0000000 124 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/nested/ParcelableWithNested.cpp 28 mtime=1776853188.4040000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/nested/Parcelable0100644 0000000 0000000 00000001346 15172120304 033066 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/nested/ParcelableWithNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_n0100644 0000000 0000000 00000000232 15172120304 033217 xustar000000000 0000000 126 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/nested/ParcelableWithNested.cpp.d 28 mtime=1776853188.4040000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/nested/Parcelable0100644 0000000 0000000 00000000334 15172120304 033062 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/nested/ParcelableWithNested.cpp : \ system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_u0100644 0000000 0000000 00000000034 15172120304 033226 xustar000000000 0000000 28 mtime=1776853188.4040000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/unions/0040755 0000000 0000000 00000000000 15172120304 031141 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_u0100644 0000000 0000000 00000000215 15172120304 033227 xustar000000000 0000000 113 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/unions/EnumUnion.cpp 28 mtime=1776853188.4040000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/unions/EnumUnion.0100644 0000000 0000000 00000001320 15172120304 033050 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/unions/EnumUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_u0100644 0000000 0000000 00000000217 15172120304 033231 xustar000000000 0000000 115 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/unions/EnumUnion.cpp.d 28 mtime=1776853188.4040000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/unions/EnumUnion.0100644 0000000 0000000 00000000477 15172120304 033064 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/unions/EnumUnion.cpp : \ system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_u0100644 0000000 0000000 00000000220 15172120304 033223 xustar000000000 0000000 116 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/unions/UnionInUnion.cpp 28 mtime=1776853188.4040000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/unions/UnionInUni0100644 0000000 0000000 00000001326 15172120304 033116 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/unions/UnionInUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/UnionInUnion.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_tests_u0100644 0000000 0000000 00000000222 15172120304 033225 xustar000000000 0000000 118 path=tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/unions/UnionInUnion.cpp.d 28 mtime=1776853188.4040000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/unions/UnionInUni0100644 0000000 0000000 00000000612 15172120304 033113 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/unions/UnionInUnion.cpp : \ system/tools/aidl/tests/android/aidl/tests/unions/UnionInUnion.aidl \ system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-analyzer-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 031052 xustar000000000 0000000 28 mtime=1776853188.4040000 tests/golden_output/aidl-test-interface-cpp-analyzer-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 026044 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_0100644 0000000 0000000 00000000034 15172120304 024452 xustar000000000 0000000 28 mtime=1776853188.4040000 tests/golden_output/aidl-test-interface-cpp-source/0040755 0000000 0000000 00000000000 15172120304 021537 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_0100644 0000000 0000000 00000000034 15172120304 025303 xustar000000000 0000000 28 mtime=1776853188.4040000 tests/golden_output/aidl-test-interface-cpp-source/gen/0040755 0000000 0000000 00000000000 15172120304 022310 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 027003 xustar000000000 0000000 28 mtime=1776853188.4040000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 023730 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 027774 xustar000000000 0000000 28 mtime=1776853188.4040000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 024641 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_0100644 0000000 0000000 00000000034 15172120304 031216 xustar000000000 0000000 28 mtime=1776853188.4040000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/0040755 0000000 0000000 00000000000 15172120304 026003 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_ArrayOfInt0100644 0000000 0000000 00000000034 15172120304 033155 xustar000000000 0000000 28 mtime=1776853188.4040000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/ArrayOfInterfaces.cpp0100644 0000000 0000000 00000050534 15172120304 032062 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ArrayOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ArrayOfInterfaces.aidl */ #include namespace android { namespace aidl { namespace tests { ::android::status_t ArrayOfInterfaces::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t ArrayOfInterfaces::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android #include #include namespace android { namespace aidl { namespace tests { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_NESTED_INTERFACE(ArrayOfInterfaces, EmptyInterface, "android.aidl.tests.ArrayOfInterfaces.IEmptyInterface") } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { ArrayOfInterfaces::BpEmptyInterface::BpEmptyInterface(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { ArrayOfInterfaces::BnEmptyInterface::BnEmptyInterface() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t ArrayOfInterfaces::BnEmptyInterface::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android #include #include namespace android { namespace aidl { namespace tests { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_NESTED_INTERFACE(ArrayOfInterfaces, MyInterface, "android.aidl.tests.ArrayOfInterfaces.IMyInterface") } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { ArrayOfInterfaces::BpMyInterface::BpMyInterface(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } ::android::binder::Status ArrayOfInterfaces::BpMyInterface::methodWithInterfaces(const ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& iface, const ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& nullable_iface, const ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>& iface_array_in, ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>* iface_array_out, ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>* iface_array_inout, const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>& nullable_iface_array_in, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>* nullable_iface_array_out, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>* nullable_iface_array_inout, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyInterface::methodWithInterfaces::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinder(iface); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinder(nullable_iface); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinderVector(iface_array_in); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*iface_array_out); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinderVector(*iface_array_inout); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinderVector(nullable_iface_array_in); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*nullable_iface_array_out); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinderVector(*nullable_iface_array_inout); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(ArrayOfInterfaces::BnMyInterface::TRANSACTION_methodWithInterfaces, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IMyInterface::getDefaultImpl()) [[unlikely]] { return IMyInterface::getDefaultImpl()->methodWithInterfaces(iface, nullable_iface, iface_array_in, iface_array_out, iface_array_inout, nullable_iface_array_in, nullable_iface_array_out, nullable_iface_array_inout, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(iface_array_out); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(iface_array_inout); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(nullable_iface_array_out); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(nullable_iface_array_inout); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { ArrayOfInterfaces::BnMyInterface::BnMyInterface() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t ArrayOfInterfaces::BnMyInterface::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnMyInterface::TRANSACTION_methodWithInterfaces: { ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface> in_iface; ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface> in_nullable_iface; ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>> in_iface_array_in; ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>> out_iface_array_out; ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>> in_iface_array_inout; ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>> in_nullable_iface_array_in; ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>> out_nullable_iface_array_out; ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>> in_nullable_iface_array_inout; ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyInterface::methodWithInterfaces::cppServer"); _aidl_ret_status = _aidl_data.readStrongBinder(&in_iface); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readNullableStrongBinder(&in_nullable_iface); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_iface_array_in); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_iface_array_out); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_iface_array_inout); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_nullable_iface_array_in); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_nullable_iface_array_out); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_nullable_iface_array_inout); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(methodWithInterfaces(in_iface, in_nullable_iface, in_iface_array_in, &out_iface_array_out, &in_iface_array_inout, in_nullable_iface_array_in, &out_nullable_iface_array_out, &in_nullable_iface_array_inout, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(out_iface_array_out); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(in_iface_array_inout); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(out_nullable_iface_array_out); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(in_nullable_iface_array_inout); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { ::android::status_t ArrayOfInterfaces::MyParcelable::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readStrongBinder(&iface); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readNullableStrongBinder(&nullable_iface); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readStrongBinderVector(&iface_array); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readStrongBinderVector(&nullable_iface_array); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t ArrayOfInterfaces::MyParcelable::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeStrongBinder(iface); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeStrongBinder(nullable_iface); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeStrongBinderVector(iface_array); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeStrongBinderVector(nullable_iface_array); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { ::android::status_t ArrayOfInterfaces::MyUnion::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_tag)) != ::android::OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case iface: { ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface> _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readStrongBinder(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case nullable_iface: { ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface> _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readNullableStrongBinder(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case iface_array: { ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>> _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readStrongBinderVector(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case nullable_iface_array: { ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>> _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readStrongBinderVector(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } } return ::android::BAD_VALUE; } ::android::status_t ArrayOfInterfaces::MyUnion::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(getTag())); if (_aidl_ret_status != ::android::OK) return _aidl_ret_status; switch (getTag()) { case iface: return _aidl_parcel->writeStrongBinder(get()); case nullable_iface: return _aidl_parcel->writeStrongBinder(get()); case iface_array: return _aidl_parcel->writeStrongBinderVector(get()); case nullable_iface_array: return _aidl_parcel->writeStrongBinderVector(get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_ArrayOfInt0100644 0000000 0000000 00000000034 15172120304 033155 xustar000000000 0000000 28 mtime=1776853188.4040000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/ArrayOfInterfaces.cpp.d0100644 0000000 0000000 00000000277 15172120304 032303 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/ArrayOfInterfaces.cpp : \ system/tools/aidl/tests/android/aidl/tests/ArrayOfInterfaces.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_BackendTyp0100644 0000000 0000000 00000000034 15172120304 033163 xustar000000000 0000000 28 mtime=1776853188.4040000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/BackendType.cpp0100644 0000000 0000000 00000001241 15172120304 030673 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/BackendType.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/BackendType.aidl */ // This file is intentionally left blank as placeholder for enum declaration. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_BackendTyp0100644 0000000 0000000 00000000034 15172120304 033163 xustar000000000 0000000 28 mtime=1776853188.4040000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/BackendType.cpp.d0100644 0000000 0000000 00000000263 15172120304 031120 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/BackendType.cpp : \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_ByteEnum.c0100644 0000000 0000000 00000000034 15172120304 033110 xustar000000000 0000000 28 mtime=1776853188.4050000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/ByteEnum.cpp0100644 0000000 0000000 00000001233 15172120304 030233 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ByteEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl */ // This file is intentionally left blank as placeholder for enum declaration. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_ByteEnum.c0100644 0000000 0000000 00000000034 15172120304 033110 xustar000000000 0000000 28 mtime=1776853188.4070000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/ByteEnum.cpp.d0100644 0000000 0000000 00000000255 15172120304 030460 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/ByteEnum.cpp : \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_CircularPa0100644 0000000 0000000 00000000034 15172120304 033164 xustar000000000 0000000 28 mtime=1776853188.4070000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/CircularParcelable.cpp0100644 0000000 0000000 00000004737 15172120304 032236 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/CircularParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl */ #include namespace android { namespace aidl { namespace tests { ::android::status_t CircularParcelable::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readNullableStrongBinder(&testService); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t CircularParcelable::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeStrongBinder(testService); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_CircularPa0100644 0000000 0000000 00000000034 15172120304 033164 xustar000000000 0000000 28 mtime=1776853188.4070000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/CircularParcelable.cpp.d0100644 0000000 0000000 00000002233 15172120304 032445 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/CircularParcelable.cpp : \ system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ITestService.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl \ system/tools/aidl/tests/android/aidl/tests/SimpleParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl \ system/tools/aidl/tests/android/aidl/tests/ICircular.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_ConstantEx0100644 0000000 0000000 00000000212 15172120304 033223 xustar000000000 0000000 110 path=tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/ConstantExpressionEnum.cpp 28 mtime=1776853188.4070000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/ConstantExpressionEnum.cpp0100644 0000000 0000000 00000001267 15172120304 033210 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ConstantExpressionEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl */ // This file is intentionally left blank as placeholder for enum declaration. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_ConstantEx0100644 0000000 0000000 00000000214 15172120304 033225 xustar000000000 0000000 112 path=tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/ConstantExpressionEnum.cpp.d 28 mtime=1776853188.4080000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/ConstantExpressionEnum.cpp0100644 0000000 0000000 00000000311 15172120304 033175 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/ConstantExpressionEnum.cpp : \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_Deprecated0100644 0000000 0000000 00000000034 15172120304 033177 xustar000000000 0000000 28 mtime=1776853188.4080000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/DeprecatedEnum.cpp0100644 0000000 0000000 00000001247 15172120304 031375 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/DeprecatedEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedEnum.aidl */ // This file is intentionally left blank as placeholder for enum declaration. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_Deprecated0100644 0000000 0000000 00000000034 15172120304 033177 xustar000000000 0000000 28 mtime=1776853188.4080000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/DeprecatedEnum.cpp.d0100644 0000000 0000000 00000000271 15172120304 031613 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/DeprecatedEnum.cpp : \ system/tools/aidl/tests/android/aidl/tests/DeprecatedEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_Deprecated0100644 0000000 0000000 00000000034 15172120304 033177 xustar000000000 0000000 28 mtime=1776853188.4080000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/DeprecatedParcelable.cpp0100644 0000000 0000000 00000003771 15172120304 032527 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/DeprecatedParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedParcelable.aidl */ #include namespace android { namespace aidl { namespace tests { ::android::status_t DeprecatedParcelable::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t DeprecatedParcelable::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_Deprecated0100644 0000000 0000000 00000000212 15172120304 033175 xustar000000000 0000000 110 path=tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/DeprecatedParcelable.cpp.d 28 mtime=1776853188.4080000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/DeprecatedParcelable.cpp.d0100644 0000000 0000000 00000000305 15172120304 032737 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/DeprecatedParcelable.cpp : \ system/tools/aidl/tests/android/aidl/tests/DeprecatedParcelable.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_FixedSize.0100644 0000000 0000000 00000000034 15172120304 033107 xustar000000000 0000000 28 mtime=1776853188.4080000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/FixedSize.cpp0100644 0000000 0000000 00000030174 15172120304 030403 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/FixedSize.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/FixedSize.aidl */ #include namespace android { namespace aidl { namespace tests { ::android::status_t FixedSize::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t FixedSize::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { ::android::status_t FixedSize::FixedParcelable::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readBool(&booleanValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readByte(&byteValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readChar(&charValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&intValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt64(&longValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFloat(&floatValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readDouble(&doubleValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt64(reinterpret_cast(&enumValue)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelable(&parcelableValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t FixedSize::FixedParcelable::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeBool(booleanValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeByte(byteValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeChar(charValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(intValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt64(longValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFloat(floatValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeDouble(doubleValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt64(static_cast(enumValue)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelable(parcelableValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { ::android::status_t FixedSize::FixedUnion::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_tag)) != ::android::OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case booleanValue: { bool _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readBool(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case byteValue: { int8_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readByte(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case charValue: { char16_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readChar(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case intValue: { int32_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case longValue: { int64_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt64(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case floatValue: { float _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readFloat(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case doubleValue: { double _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readDouble(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case enumValue: { ::android::aidl::tests::LongEnum _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt64(reinterpret_cast(&_aidl_value))) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::android::aidl::tests::LongEnum>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } } return ::android::BAD_VALUE; } ::android::status_t FixedSize::FixedUnion::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(getTag())); if (_aidl_ret_status != ::android::OK) return _aidl_ret_status; switch (getTag()) { case booleanValue: return _aidl_parcel->writeBool(get()); case byteValue: return _aidl_parcel->writeByte(get()); case charValue: return _aidl_parcel->writeChar(get()); case intValue: return _aidl_parcel->writeInt32(get()); case longValue: return _aidl_parcel->writeInt64(get()); case floatValue: return _aidl_parcel->writeFloat(get()); case doubleValue: return _aidl_parcel->writeDouble(get()); case enumValue: return _aidl_parcel->writeInt64(static_cast(get())); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_FixedSize.0100644 0000000 0000000 00000000034 15172120304 033107 xustar000000000 0000000 28 mtime=1776853188.4080000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/FixedSize.cpp.d0100644 0000000 0000000 00000000354 15172120304 030622 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/FixedSize.cpp : \ system/tools/aidl/tests/android/aidl/tests/FixedSize.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_GenericStr0100644 0000000 0000000 00000000217 15172120304 033207 xustar000000000 0000000 115 path=tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/GenericStructuredParcelable.cpp 28 mtime=1776853188.4080000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/GenericStructuredParcelabl0100644 0000000 0000000 00000001164 15172120304 033174 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/GenericStructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl */ ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_GenericStr0100644 0000000 0000000 00000000221 15172120304 033202 xustar000000000 0000000 117 path=tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/GenericStructuredParcelable.cpp.d 28 mtime=1776853188.4080000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/GenericStructuredParcelabl0100644 0000000 0000000 00000000323 15172120304 033170 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/GenericStructuredParcelable.cpp : \ system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_ICircular.0100644 0000000 0000000 00000000034 15172120304 033072 xustar000000000 0000000 28 mtime=1776853188.4080000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/ICircular.cpp0100644 0000000 0000000 00000010343 15172120304 030362 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ICircular.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ICircular.aidl */ #include #include namespace android { namespace aidl { namespace tests { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE(Circular, "android.aidl.tests.ICircular") } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { BpCircular::BpCircular(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } ::android::binder::Status BpCircular::GetTestService(::android::sp<::android::aidl::tests::ITestService>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICircular::GetTestService::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnCircular::TRANSACTION_GetTestService, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ICircular::getDefaultImpl()) [[unlikely]] { return ICircular::getDefaultImpl()->GetTestService(_aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readNullableStrongBinder(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { BnCircular::BnCircular() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t BnCircular::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnCircular::TRANSACTION_GetTestService: { ::android::sp<::android::aidl::tests::ITestService> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICircular::GetTestService::cppServer"); ::android::binder::Status _aidl_status(GetTestService(&_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinder(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_ICircular.0100644 0000000 0000000 00000000034 15172120304 033072 xustar000000000 0000000 28 mtime=1776853188.4080000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/ICircular.cpp.d0100644 0000000 0000000 00000002222 15172120304 030601 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/ICircular.cpp : \ system/tools/aidl/tests/android/aidl/tests/ICircular.aidl \ system/tools/aidl/tests/android/aidl/tests/ITestService.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl \ system/tools/aidl/tests/android/aidl/tests/SimpleParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl \ system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_IDeprecate0100644 0000000 0000000 00000000034 15172120304 033144 xustar000000000 0000000 28 mtime=1776853188.4080000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/IDeprecated.cpp0100644 0000000 0000000 00000004402 15172120304 030655 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/IDeprecated.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IDeprecated.aidl */ #include #include namespace android { namespace aidl { namespace tests { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE(Deprecated, "android.aidl.tests.IDeprecated") } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { BpDeprecated::BpDeprecated(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { BnDeprecated::BnDeprecated() { ::android::internal::Stability::markCompilationUnit(this); } #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated" ::android::status_t BnDeprecated::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } #pragma clang diagnostic pop } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_IDeprecate0100644 0000000 0000000 00000000034 15172120304 033144 xustar000000000 0000000 28 mtime=1776853188.4080000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/IDeprecated.cpp.d0100644 0000000 0000000 00000000263 15172120304 031100 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/IDeprecated.cpp : \ system/tools/aidl/tests/android/aidl/tests/IDeprecated.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_INamedCall0100644 0000000 0000000 00000000034 15172120304 033070 xustar000000000 0000000 28 mtime=1776853188.4090000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/INamedCallback.cpp0100644 0000000 0000000 00000010320 15172120304 031252 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/INamedCallback.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl */ #include #include namespace android { namespace aidl { namespace tests { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE(NamedCallback, "android.aidl.tests.INamedCallback") } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { BpNamedCallback::BpNamedCallback(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } ::android::binder::Status BpNamedCallback::GetName(::android::String16* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::INamedCallback::GetName::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnNamedCallback::TRANSACTION_GetName, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && INamedCallback::getDefaultImpl()) [[unlikely]] { return INamedCallback::getDefaultImpl()->GetName(_aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readString16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { BnNamedCallback::BnNamedCallback() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t BnNamedCallback::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnNamedCallback::TRANSACTION_GetName: { ::android::String16 _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::INamedCallback::GetName::cppServer"); ::android::binder::Status _aidl_status(GetName(&_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeString16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_INamedCall0100644 0000000 0000000 00000000034 15172120304 033070 xustar000000000 0000000 28 mtime=1776853188.4090000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/INamedCallback.cpp.d0100644 0000000 0000000 00000000271 15172120304 031500 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/INamedCallback.cpp : \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_INewName.c0100644 0000000 0000000 00000000034 15172120304 033023 xustar000000000 0000000 28 mtime=1776853188.4090000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/INewName.cpp0100644 0000000 0000000 00000010123 15172120304 030144 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/INewName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INewName.aidl */ #include #include namespace android { namespace aidl { namespace tests { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE(NewName, "android.aidl.tests.IOldName") } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { BpNewName::BpNewName(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } ::android::binder::Status BpNewName::RealName(::android::String16* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::INewName::RealName::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnNewName::TRANSACTION_RealName, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && INewName::getDefaultImpl()) [[unlikely]] { return INewName::getDefaultImpl()->RealName(_aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readString16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { BnNewName::BnNewName() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t BnNewName::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnNewName::TRANSACTION_RealName: { ::android::String16 _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::INewName::RealName::cppServer"); ::android::binder::Status _aidl_status(RealName(&_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeString16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_INewName.c0100644 0000000 0000000 00000000034 15172120304 033023 xustar000000000 0000000 28 mtime=1776853188.4090000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/INewName.cpp.d0100644 0000000 0000000 00000000255 15172120304 030373 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/INewName.cpp : \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_IOldName.c0100644 0000000 0000000 00000000034 15172120304 033010 xustar000000000 0000000 28 mtime=1776853188.4090000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/IOldName.cpp0100644 0000000 0000000 00000010123 15172120304 030131 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/IOldName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IOldName.aidl */ #include #include namespace android { namespace aidl { namespace tests { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE(OldName, "android.aidl.tests.IOldName") } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { BpOldName::BpOldName(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } ::android::binder::Status BpOldName::RealName(::android::String16* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IOldName::RealName::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnOldName::TRANSACTION_RealName, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IOldName::getDefaultImpl()) [[unlikely]] { return IOldName::getDefaultImpl()->RealName(_aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readString16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { BnOldName::BnOldName() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t BnOldName::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnOldName::TRANSACTION_RealName: { ::android::String16 _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IOldName::RealName::cppServer"); ::android::binder::Status _aidl_status(RealName(&_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeString16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_IOldName.c0100644 0000000 0000000 00000000034 15172120304 033010 xustar000000000 0000000 28 mtime=1776853188.4090000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/IOldName.cpp.d0100644 0000000 0000000 00000000255 15172120304 030360 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/IOldName.cpp : \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_ITestServi0100644 0000000 0000000 00000000034 15172120304 033200 xustar000000000 0000000 28 mtime=1776853188.4090000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/ITestService.cpp0100644 0000000 0000000 00000703163 15172120304 031067 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ITestService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ITestService.aidl */ #include #include namespace android { namespace aidl { namespace tests { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE(TestService, "android.aidl.tests.ITestService") const ::android::String16& ITestService::STRING_CONSTANT() { static const ::android::String16 value(::android::String16("foo")); return value; } const ::android::String16& ITestService::STRING_CONSTANT2() { static const ::android::String16 value(::android::String16("bar")); return value; } const ::std::string& ITestService::STRING_CONSTANT_UTF8() { static const ::std::string value("baz"); return value; } } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { BpTestService::BpTestService(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } ::android::binder::Status BpTestService::UnimplementedMethod(int32_t arg, int32_t* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::UnimplementedMethod::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeInt32(arg); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_UnimplementedMethod, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->UnimplementedMethod(arg, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readInt32(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::Deprecated() { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::Deprecated::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_Deprecated, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->Deprecated(); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::TestOneway() { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::TestOneway::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_TestOneway, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_ONEWAY | ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->TestOneway(); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatBoolean(bool token, bool* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatBoolean::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeBool(token); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatBoolean, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatBoolean(token, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readBool(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatByte(int8_t token, int8_t* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatByte::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeByte(token); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatByte, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatByte(token, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readByte(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatChar(char16_t token, char16_t* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatChar::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeChar(token); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatChar, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatChar(token, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readChar(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatInt(int32_t token, int32_t* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatInt::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeInt32(token); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatInt, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatInt(token, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readInt32(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatLong(int64_t token, int64_t* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatLong::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeInt64(token); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatLong, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatLong(token, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readInt64(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatFloat(float token, float* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatFloat::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeFloat(token); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatFloat, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatFloat(token, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readFloat(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatDouble(double token, double* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatDouble::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeDouble(token); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatDouble, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatDouble(token, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readDouble(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatString(const ::android::String16& token, ::android::String16* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatString::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeString16(token); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatString, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatString(token, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readString16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatByteEnum(::android::aidl::tests::ByteEnum token, ::android::aidl::tests::ByteEnum* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatByteEnum::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeByte(static_cast(token)); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatByteEnum, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatByteEnum(token, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readByte(reinterpret_cast(_aidl_return)); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatIntEnum(::android::aidl::tests::IntEnum token, ::android::aidl::tests::IntEnum* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatIntEnum::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeInt32(static_cast(token)); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatIntEnum, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatIntEnum(token, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readInt32(reinterpret_cast(_aidl_return)); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatLongEnum(::android::aidl::tests::LongEnum token, ::android::aidl::tests::LongEnum* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatLongEnum::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeInt64(static_cast(token)); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatLongEnum, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatLongEnum(token, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readInt64(reinterpret_cast(_aidl_return)); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseBoolean(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseBoolean::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeBoolVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseBoolean, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseBoolean(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readBoolVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readBoolVector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseByte(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseByte::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeByteVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseByte, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseByte(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readByteVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readByteVector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseChar(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseChar::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeCharVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseChar, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseChar(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readCharVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readCharVector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseInt(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseInt::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeInt32Vector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseInt, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseInt(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readInt32Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readInt32Vector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseLong(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseLong::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeInt64Vector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseLong, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseLong(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readInt64Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readInt64Vector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseFloat(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseFloat::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeFloatVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseFloat, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseFloat(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readFloatVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readFloatVector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseDouble(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseDouble::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeDoubleVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseDouble, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseDouble(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readDoubleVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readDoubleVector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseString(const ::std::vector<::android::String16>& input, ::std::vector<::android::String16>* repeated, ::std::vector<::android::String16>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseString::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeString16Vector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseString, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseString(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readString16Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readString16Vector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseByteEnum(const ::std::vector<::android::aidl::tests::ByteEnum>& input, ::std::vector<::android::aidl::tests::ByteEnum>* repeated, ::std::vector<::android::aidl::tests::ByteEnum>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseByteEnum::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeEnumVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseByteEnum, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseByteEnum(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readEnumVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readEnumVector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseIntEnum(const ::std::vector<::android::aidl::tests::IntEnum>& input, ::std::vector<::android::aidl::tests::IntEnum>* repeated, ::std::vector<::android::aidl::tests::IntEnum>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseIntEnum::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeEnumVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseIntEnum, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseIntEnum(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readEnumVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readEnumVector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseLongEnum(const ::std::vector<::android::aidl::tests::LongEnum>& input, ::std::vector<::android::aidl::tests::LongEnum>* repeated, ::std::vector<::android::aidl::tests::LongEnum>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseLongEnum::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeEnumVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseLongEnum, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseLongEnum(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readEnumVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readEnumVector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::GetOtherTestService(const ::android::String16& name, ::android::sp<::android::aidl::tests::INamedCallback>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetOtherTestService::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeString16(name); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_GetOtherTestService, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->GetOtherTestService(name, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readStrongBinder(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::SetOtherTestService(const ::android::String16& name, const ::android::sp<::android::aidl::tests::INamedCallback>& service, bool* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::SetOtherTestService::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeString16(name); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinder(service); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_SetOtherTestService, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->SetOtherTestService(name, service, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readBool(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::VerifyName(const ::android::sp<::android::aidl::tests::INamedCallback>& service, const ::android::String16& name, bool* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::VerifyName::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinder(service); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeString16(name); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_VerifyName, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->VerifyName(service, name, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readBool(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::GetInterfaceArray(const ::std::vector<::android::String16>& names, ::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetInterfaceArray::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeString16Vector(names); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_GetInterfaceArray, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->GetInterfaceArray(names, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::VerifyNamesWithInterfaceArray(const ::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>& services, const ::std::vector<::android::String16>& names, bool* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::VerifyNamesWithInterfaceArray::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinderVector(services); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeString16Vector(names); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_VerifyNamesWithInterfaceArray, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->VerifyNamesWithInterfaceArray(services, names, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readBool(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::GetNullableInterfaceArray(const ::std::optional<::std::vector<::std::optional<::android::String16>>>& names, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetNullableInterfaceArray::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeString16Vector(names); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_GetNullableInterfaceArray, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->GetNullableInterfaceArray(names, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::VerifyNamesWithNullableInterfaceArray(const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>& services, const ::std::optional<::std::vector<::std::optional<::android::String16>>>& names, bool* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::VerifyNamesWithNullableInterfaceArray::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinderVector(services); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeString16Vector(names); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_VerifyNamesWithNullableInterfaceArray, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->VerifyNamesWithNullableInterfaceArray(services, names, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readBool(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::GetInterfaceList(const ::std::optional<::std::vector<::std::optional<::android::String16>>>& names, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetInterfaceList::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeString16Vector(names); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_GetInterfaceList, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->GetInterfaceList(names, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::VerifyNamesWithInterfaceList(const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>& services, const ::std::optional<::std::vector<::std::optional<::android::String16>>>& names, bool* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::VerifyNamesWithInterfaceList::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinderVector(services); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeString16Vector(names); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_VerifyNamesWithInterfaceList, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->VerifyNamesWithInterfaceList(services, names, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readBool(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseStringList(const ::std::vector<::android::String16>& input, ::std::vector<::android::String16>* repeated, ::std::vector<::android::String16>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseStringList::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeString16Vector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseStringList, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseStringList(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readString16Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readString16Vector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatParcelFileDescriptor(const ::android::os::ParcelFileDescriptor& read, ::android::os::ParcelFileDescriptor* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatParcelFileDescriptor::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(read); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatParcelFileDescriptor, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatParcelFileDescriptor(read, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseParcelFileDescriptorArray(const ::std::vector<::android::os::ParcelFileDescriptor>& input, ::std::vector<::android::os::ParcelFileDescriptor>* repeated, ::std::vector<::android::os::ParcelFileDescriptor>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseParcelFileDescriptorArray::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelableVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseParcelFileDescriptorArray, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseParcelFileDescriptorArray(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelableVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readParcelableVector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ThrowServiceException(int32_t code) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ThrowServiceException::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeInt32(code); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ThrowServiceException, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ThrowServiceException(code); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatNullableIntArray(const ::std::optional<::std::vector>& input, ::std::optional<::std::vector>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableIntArray::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeInt32Vector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatNullableIntArray, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatNullableIntArray(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readInt32Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatNullableByteEnumArray(const ::std::optional<::std::vector<::android::aidl::tests::ByteEnum>>& input, ::std::optional<::std::vector<::android::aidl::tests::ByteEnum>>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableByteEnumArray::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeEnumVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatNullableByteEnumArray, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatNullableByteEnumArray(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readEnumVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatNullableIntEnumArray(const ::std::optional<::std::vector<::android::aidl::tests::IntEnum>>& input, ::std::optional<::std::vector<::android::aidl::tests::IntEnum>>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableIntEnumArray::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeEnumVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatNullableIntEnumArray, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatNullableIntEnumArray(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readEnumVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatNullableLongEnumArray(const ::std::optional<::std::vector<::android::aidl::tests::LongEnum>>& input, ::std::optional<::std::vector<::android::aidl::tests::LongEnum>>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableLongEnumArray::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeEnumVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatNullableLongEnumArray, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatNullableLongEnumArray(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readEnumVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatNullableString(const ::std::optional<::android::String16>& input, ::std::optional<::android::String16>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableString::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeString16(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatNullableString, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatNullableString(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readString16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatNullableStringList(const ::std::optional<::std::vector<::std::optional<::android::String16>>>& input, ::std::optional<::std::vector<::std::optional<::android::String16>>>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableStringList::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeString16Vector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatNullableStringList, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatNullableStringList(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readString16Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatNullableParcelable(const ::std::optional<::android::aidl::tests::ITestService::Empty>& input, ::std::optional<::android::aidl::tests::ITestService::Empty>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableParcelable::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeNullableParcelable(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatNullableParcelable, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatNullableParcelable(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatNullableParcelableArray(const ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>& input, ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableParcelableArray::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelableVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatNullableParcelableArray, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatNullableParcelableArray(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelableVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatNullableParcelableList(const ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>& input, ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableParcelableList::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelableVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatNullableParcelableList, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatNullableParcelableList(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelableVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::TakesAnIBinder(const ::android::sp<::android::IBinder>& input) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::TakesAnIBinder::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinder(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_TakesAnIBinder, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->TakesAnIBinder(input); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::TakesANullableIBinder(const ::android::sp<::android::IBinder>& input) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::TakesANullableIBinder::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinder(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_TakesANullableIBinder, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->TakesANullableIBinder(input); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::TakesAnIBinderList(const ::std::vector<::android::sp<::android::IBinder>>& input) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::TakesAnIBinderList::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinderVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_TakesAnIBinderList, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->TakesAnIBinderList(input); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::TakesANullableIBinderList(const ::std::optional<::std::vector<::android::sp<::android::IBinder>>>& input) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::TakesANullableIBinderList::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinderVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_TakesANullableIBinderList, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->TakesANullableIBinderList(input); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatUtf8CppString(const ::std::string& token, ::std::string* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatUtf8CppString::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeUtf8AsUtf16(token); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatUtf8CppString, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatUtf8CppString(token, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readUtf8FromUtf16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatNullableUtf8CppString(const ::std::optional<::std::string>& token, ::std::optional<::std::string>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableUtf8CppString::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeUtf8AsUtf16(token); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatNullableUtf8CppString, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatNullableUtf8CppString(token, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readUtf8FromUtf16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseUtf8CppString(const ::std::vector<::std::string>& input, ::std::vector<::std::string>* repeated, ::std::vector<::std::string>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseUtf8CppString::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeUtf8VectorAsUtf16Vector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseUtf8CppString, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseUtf8CppString(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readUtf8VectorFromUtf16Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readUtf8VectorFromUtf16Vector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseNullableUtf8CppString(const ::std::optional<::std::vector<::std::optional<::std::string>>>& input, ::std::optional<::std::vector<::std::optional<::std::string>>>* repeated, ::std::optional<::std::vector<::std::optional<::std::string>>>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseNullableUtf8CppString::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeUtf8VectorAsUtf16Vector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseNullableUtf8CppString, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseNullableUtf8CppString(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readUtf8VectorFromUtf16Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readUtf8VectorFromUtf16Vector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseUtf8CppStringList(const ::std::optional<::std::vector<::std::optional<::std::string>>>& input, ::std::optional<::std::vector<::std::optional<::std::string>>>* repeated, ::std::optional<::std::vector<::std::optional<::std::string>>>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseUtf8CppStringList::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeUtf8VectorAsUtf16Vector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseUtf8CppStringList, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseUtf8CppStringList(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readUtf8VectorFromUtf16Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readUtf8VectorFromUtf16Vector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::GetCallback(bool return_null, ::android::sp<::android::aidl::tests::INamedCallback>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetCallback::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeBool(return_null); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_GetCallback, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->GetCallback(return_null, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readNullableStrongBinder(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::FillOutStructuredParcelable(::android::aidl::tests::StructuredParcelable* parcel) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::FillOutStructuredParcelable::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(*parcel); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_FillOutStructuredParcelable, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->FillOutStructuredParcelable(parcel); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(parcel); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatExtendableParcelable(const ::android::aidl::tests::extension::ExtendableParcelable& ep, ::android::aidl::tests::extension::ExtendableParcelable* ep2) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatExtendableParcelable::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(ep); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatExtendableParcelable, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatExtendableParcelable(ep, ep2); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(ep2); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseList(const ::android::aidl::tests::RecursiveList& list, ::android::aidl::tests::RecursiveList* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseList::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(list); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseList, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseList(list, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseIBinderArray(const ::std::vector<::android::sp<::android::IBinder>>& input, ::std::vector<::android::sp<::android::IBinder>>* repeated, ::std::vector<::android::sp<::android::IBinder>>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseIBinderArray::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinderVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseIBinderArray, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseIBinderArray(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseNullableIBinderArray(const ::std::optional<::std::vector<::android::sp<::android::IBinder>>>& input, ::std::optional<::std::vector<::android::sp<::android::IBinder>>>* repeated, ::std::optional<::std::vector<::android::sp<::android::IBinder>>>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseNullableIBinderArray::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinderVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseNullableIBinderArray, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseNullableIBinderArray(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatSimpleParcelable(const ::android::aidl::tests::SimpleParcelable& input, ::android::aidl::tests::SimpleParcelable* repeat, ::android::aidl::tests::SimpleParcelable* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatSimpleParcelable::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatSimpleParcelable, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatSimpleParcelable(input, repeat, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readParcelable(repeat); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseSimpleParcelables(const ::std::vector<::android::aidl::tests::SimpleParcelable>& input, ::std::vector<::android::aidl::tests::SimpleParcelable>* repeated, ::std::vector<::android::aidl::tests::SimpleParcelable>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseSimpleParcelables::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelableVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseSimpleParcelables, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseSimpleParcelables(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelableVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readParcelableVector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::GetOldNameInterface(::android::sp<::android::aidl::tests::IOldName>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetOldNameInterface::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_GetOldNameInterface, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->GetOldNameInterface(_aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readStrongBinder(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::GetNewNameInterface(::android::sp<::android::aidl::tests::INewName>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetNewNameInterface::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_GetNewNameInterface, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->GetNewNameInterface(_aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readStrongBinder(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::GetUnionTags(const ::std::vector<::android::aidl::tests::Union>& input, ::std::vector<::android::aidl::tests::Union::Tag>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetUnionTags::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelableVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_GetUnionTags, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->GetUnionTags(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readEnumVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::GetCppJavaTests(::android::sp<::android::IBinder>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetCppJavaTests::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_GetCppJavaTests, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->GetCppJavaTests(_aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readNullableStrongBinder(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::getBackendType(::android::aidl::tests::BackendType* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::getBackendType::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_getBackendType, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->getBackendType(_aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readByte(reinterpret_cast(_aidl_return)); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::GetCircular(::android::aidl::tests::CircularParcelable* cp, ::android::sp<::android::aidl::tests::ICircular>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetCircular::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_GetCircular, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->GetCircular(cp, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readStrongBinder(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readParcelable(cp); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { BnTestService::BnTestService() { ::android::internal::Stability::markCompilationUnit(this); } #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated" ::android::status_t BnTestService::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnTestService::TRANSACTION_UnimplementedMethod: { int32_t in_arg; int32_t _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::UnimplementedMethod::cppServer"); _aidl_ret_status = _aidl_data.readInt32(&in_arg); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(UnimplementedMethod(in_arg, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeInt32(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_Deprecated: { if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::Deprecated::cppServer"); ::android::binder::Status _aidl_status(Deprecated()); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; case BnTestService::TRANSACTION_TestOneway: { if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::TestOneway::cppServer"); ::android::binder::Status _aidl_status(TestOneway()); } break; case BnTestService::TRANSACTION_RepeatBoolean: { bool in_token; bool _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatBoolean::cppServer"); _aidl_ret_status = _aidl_data.readBool(&in_token); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatBoolean(in_token, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeBool(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatByte: { int8_t in_token; int8_t _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatByte::cppServer"); _aidl_ret_status = _aidl_data.readByte(&in_token); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatByte(in_token, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeByte(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatChar: { char16_t in_token; char16_t _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatChar::cppServer"); _aidl_ret_status = _aidl_data.readChar(&in_token); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatChar(in_token, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeChar(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatInt: { int32_t in_token; int32_t _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatInt::cppServer"); _aidl_ret_status = _aidl_data.readInt32(&in_token); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatInt(in_token, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeInt32(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatLong: { int64_t in_token; int64_t _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatLong::cppServer"); _aidl_ret_status = _aidl_data.readInt64(&in_token); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatLong(in_token, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeInt64(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatFloat: { float in_token; float _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatFloat::cppServer"); _aidl_ret_status = _aidl_data.readFloat(&in_token); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatFloat(in_token, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeFloat(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatDouble: { double in_token; double _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatDouble::cppServer"); _aidl_ret_status = _aidl_data.readDouble(&in_token); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatDouble(in_token, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeDouble(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatString: { ::android::String16 in_token; ::android::String16 _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatString::cppServer"); _aidl_ret_status = _aidl_data.readString16(&in_token); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatString(in_token, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeString16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatByteEnum: { ::android::aidl::tests::ByteEnum in_token; ::android::aidl::tests::ByteEnum _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatByteEnum::cppServer"); _aidl_ret_status = _aidl_data.readByte(reinterpret_cast(&in_token)); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatByteEnum(in_token, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeByte(static_cast(_aidl_return)); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatIntEnum: { ::android::aidl::tests::IntEnum in_token; ::android::aidl::tests::IntEnum _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatIntEnum::cppServer"); _aidl_ret_status = _aidl_data.readInt32(reinterpret_cast(&in_token)); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatIntEnum(in_token, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeInt32(static_cast(_aidl_return)); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatLongEnum: { ::android::aidl::tests::LongEnum in_token; ::android::aidl::tests::LongEnum _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatLongEnum::cppServer"); _aidl_ret_status = _aidl_data.readInt64(reinterpret_cast(&in_token)); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatLongEnum(in_token, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeInt64(static_cast(_aidl_return)); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseBoolean: { ::std::vector in_input; ::std::vector out_repeated; ::std::vector _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseBoolean::cppServer"); _aidl_ret_status = _aidl_data.readBoolVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseBoolean(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeBoolVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeBoolVector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseByte: { ::std::vector in_input; ::std::vector out_repeated; ::std::vector _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseByte::cppServer"); _aidl_ret_status = _aidl_data.readByteVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseByte(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeByteVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeByteVector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseChar: { ::std::vector in_input; ::std::vector out_repeated; ::std::vector _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseChar::cppServer"); _aidl_ret_status = _aidl_data.readCharVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseChar(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeCharVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeCharVector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseInt: { ::std::vector in_input; ::std::vector out_repeated; ::std::vector _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseInt::cppServer"); _aidl_ret_status = _aidl_data.readInt32Vector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseInt(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeInt32Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeInt32Vector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseLong: { ::std::vector in_input; ::std::vector out_repeated; ::std::vector _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseLong::cppServer"); _aidl_ret_status = _aidl_data.readInt64Vector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseLong(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeInt64Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeInt64Vector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseFloat: { ::std::vector in_input; ::std::vector out_repeated; ::std::vector _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseFloat::cppServer"); _aidl_ret_status = _aidl_data.readFloatVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseFloat(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeFloatVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeFloatVector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseDouble: { ::std::vector in_input; ::std::vector out_repeated; ::std::vector _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseDouble::cppServer"); _aidl_ret_status = _aidl_data.readDoubleVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseDouble(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeDoubleVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeDoubleVector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseString: { ::std::vector<::android::String16> in_input; ::std::vector<::android::String16> out_repeated; ::std::vector<::android::String16> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseString::cppServer"); _aidl_ret_status = _aidl_data.readString16Vector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseString(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeString16Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeString16Vector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseByteEnum: { ::std::vector<::android::aidl::tests::ByteEnum> in_input; ::std::vector<::android::aidl::tests::ByteEnum> out_repeated; ::std::vector<::android::aidl::tests::ByteEnum> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseByteEnum::cppServer"); _aidl_ret_status = _aidl_data.readEnumVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseByteEnum(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeEnumVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeEnumVector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseIntEnum: { ::std::vector<::android::aidl::tests::IntEnum> in_input; ::std::vector<::android::aidl::tests::IntEnum> out_repeated; ::std::vector<::android::aidl::tests::IntEnum> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseIntEnum::cppServer"); _aidl_ret_status = _aidl_data.readEnumVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseIntEnum(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeEnumVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeEnumVector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseLongEnum: { ::std::vector<::android::aidl::tests::LongEnum> in_input; ::std::vector<::android::aidl::tests::LongEnum> out_repeated; ::std::vector<::android::aidl::tests::LongEnum> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseLongEnum::cppServer"); _aidl_ret_status = _aidl_data.readEnumVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseLongEnum(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeEnumVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeEnumVector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_GetOtherTestService: { ::android::String16 in_name; ::android::sp<::android::aidl::tests::INamedCallback> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetOtherTestService::cppServer"); _aidl_ret_status = _aidl_data.readString16(&in_name); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(GetOtherTestService(in_name, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinder(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_SetOtherTestService: { ::android::String16 in_name; ::android::sp<::android::aidl::tests::INamedCallback> in_service; bool _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::SetOtherTestService::cppServer"); _aidl_ret_status = _aidl_data.readString16(&in_name); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readStrongBinder(&in_service); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(SetOtherTestService(in_name, in_service, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeBool(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_VerifyName: { ::android::sp<::android::aidl::tests::INamedCallback> in_service; ::android::String16 in_name; bool _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::VerifyName::cppServer"); _aidl_ret_status = _aidl_data.readStrongBinder(&in_service); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readString16(&in_name); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(VerifyName(in_service, in_name, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeBool(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_GetInterfaceArray: { ::std::vector<::android::String16> in_names; ::std::vector<::android::sp<::android::aidl::tests::INamedCallback>> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetInterfaceArray::cppServer"); _aidl_ret_status = _aidl_data.readString16Vector(&in_names); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(GetInterfaceArray(in_names, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_VerifyNamesWithInterfaceArray: { ::std::vector<::android::sp<::android::aidl::tests::INamedCallback>> in_services; ::std::vector<::android::String16> in_names; bool _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::VerifyNamesWithInterfaceArray::cppServer"); _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_services); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readString16Vector(&in_names); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(VerifyNamesWithInterfaceArray(in_services, in_names, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeBool(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_GetNullableInterfaceArray: { ::std::optional<::std::vector<::std::optional<::android::String16>>> in_names; ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetNullableInterfaceArray::cppServer"); _aidl_ret_status = _aidl_data.readString16Vector(&in_names); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(GetNullableInterfaceArray(in_names, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_VerifyNamesWithNullableInterfaceArray: { ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>> in_services; ::std::optional<::std::vector<::std::optional<::android::String16>>> in_names; bool _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::VerifyNamesWithNullableInterfaceArray::cppServer"); _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_services); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readString16Vector(&in_names); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(VerifyNamesWithNullableInterfaceArray(in_services, in_names, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeBool(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_GetInterfaceList: { ::std::optional<::std::vector<::std::optional<::android::String16>>> in_names; ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetInterfaceList::cppServer"); _aidl_ret_status = _aidl_data.readString16Vector(&in_names); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(GetInterfaceList(in_names, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_VerifyNamesWithInterfaceList: { ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>> in_services; ::std::optional<::std::vector<::std::optional<::android::String16>>> in_names; bool _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::VerifyNamesWithInterfaceList::cppServer"); _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_services); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readString16Vector(&in_names); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(VerifyNamesWithInterfaceList(in_services, in_names, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeBool(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseStringList: { ::std::vector<::android::String16> in_input; ::std::vector<::android::String16> out_repeated; ::std::vector<::android::String16> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseStringList::cppServer"); _aidl_ret_status = _aidl_data.readString16Vector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseStringList(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeString16Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeString16Vector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatParcelFileDescriptor: { ::android::os::ParcelFileDescriptor in_read; ::android::os::ParcelFileDescriptor _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatParcelFileDescriptor::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_read); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatParcelFileDescriptor(in_read, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseParcelFileDescriptorArray: { ::std::vector<::android::os::ParcelFileDescriptor> in_input; ::std::vector<::android::os::ParcelFileDescriptor> out_repeated; ::std::vector<::android::os::ParcelFileDescriptor> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseParcelFileDescriptorArray::cppServer"); _aidl_ret_status = _aidl_data.readParcelableVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseParcelFileDescriptorArray(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelableVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeParcelableVector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ThrowServiceException: { int32_t in_code; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ThrowServiceException::cppServer"); _aidl_ret_status = _aidl_data.readInt32(&in_code); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ThrowServiceException(in_code)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; case BnTestService::TRANSACTION_RepeatNullableIntArray: { ::std::optional<::std::vector> in_input; ::std::optional<::std::vector> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableIntArray::cppServer"); _aidl_ret_status = _aidl_data.readInt32Vector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatNullableIntArray(in_input, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeInt32Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatNullableByteEnumArray: { ::std::optional<::std::vector<::android::aidl::tests::ByteEnum>> in_input; ::std::optional<::std::vector<::android::aidl::tests::ByteEnum>> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableByteEnumArray::cppServer"); _aidl_ret_status = _aidl_data.readEnumVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatNullableByteEnumArray(in_input, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeEnumVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatNullableIntEnumArray: { ::std::optional<::std::vector<::android::aidl::tests::IntEnum>> in_input; ::std::optional<::std::vector<::android::aidl::tests::IntEnum>> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableIntEnumArray::cppServer"); _aidl_ret_status = _aidl_data.readEnumVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatNullableIntEnumArray(in_input, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeEnumVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatNullableLongEnumArray: { ::std::optional<::std::vector<::android::aidl::tests::LongEnum>> in_input; ::std::optional<::std::vector<::android::aidl::tests::LongEnum>> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableLongEnumArray::cppServer"); _aidl_ret_status = _aidl_data.readEnumVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatNullableLongEnumArray(in_input, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeEnumVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatNullableString: { ::std::optional<::android::String16> in_input; ::std::optional<::android::String16> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableString::cppServer"); _aidl_ret_status = _aidl_data.readString16(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatNullableString(in_input, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeString16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatNullableStringList: { ::std::optional<::std::vector<::std::optional<::android::String16>>> in_input; ::std::optional<::std::vector<::std::optional<::android::String16>>> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableStringList::cppServer"); _aidl_ret_status = _aidl_data.readString16Vector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatNullableStringList(in_input, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeString16Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatNullableParcelable: { ::std::optional<::android::aidl::tests::ITestService::Empty> in_input; ::std::optional<::android::aidl::tests::ITestService::Empty> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableParcelable::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatNullableParcelable(in_input, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeNullableParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatNullableParcelableArray: { ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>> in_input; ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableParcelableArray::cppServer"); _aidl_ret_status = _aidl_data.readParcelableVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatNullableParcelableArray(in_input, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelableVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatNullableParcelableList: { ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>> in_input; ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableParcelableList::cppServer"); _aidl_ret_status = _aidl_data.readParcelableVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatNullableParcelableList(in_input, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelableVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_TakesAnIBinder: { ::android::sp<::android::IBinder> in_input; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::TakesAnIBinder::cppServer"); _aidl_ret_status = _aidl_data.readStrongBinder(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(TakesAnIBinder(in_input)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; case BnTestService::TRANSACTION_TakesANullableIBinder: { ::android::sp<::android::IBinder> in_input; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::TakesANullableIBinder::cppServer"); _aidl_ret_status = _aidl_data.readNullableStrongBinder(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(TakesANullableIBinder(in_input)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; case BnTestService::TRANSACTION_TakesAnIBinderList: { ::std::vector<::android::sp<::android::IBinder>> in_input; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::TakesAnIBinderList::cppServer"); _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(TakesAnIBinderList(in_input)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; case BnTestService::TRANSACTION_TakesANullableIBinderList: { ::std::optional<::std::vector<::android::sp<::android::IBinder>>> in_input; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::TakesANullableIBinderList::cppServer"); _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(TakesANullableIBinderList(in_input)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; case BnTestService::TRANSACTION_RepeatUtf8CppString: { ::std::string in_token; ::std::string _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatUtf8CppString::cppServer"); _aidl_ret_status = _aidl_data.readUtf8FromUtf16(&in_token); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatUtf8CppString(in_token, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeUtf8AsUtf16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatNullableUtf8CppString: { ::std::optional<::std::string> in_token; ::std::optional<::std::string> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableUtf8CppString::cppServer"); _aidl_ret_status = _aidl_data.readUtf8FromUtf16(&in_token); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatNullableUtf8CppString(in_token, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeUtf8AsUtf16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseUtf8CppString: { ::std::vector<::std::string> in_input; ::std::vector<::std::string> out_repeated; ::std::vector<::std::string> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseUtf8CppString::cppServer"); _aidl_ret_status = _aidl_data.readUtf8VectorFromUtf16Vector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseUtf8CppString(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeUtf8VectorAsUtf16Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeUtf8VectorAsUtf16Vector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseNullableUtf8CppString: { ::std::optional<::std::vector<::std::optional<::std::string>>> in_input; ::std::optional<::std::vector<::std::optional<::std::string>>> out_repeated; ::std::optional<::std::vector<::std::optional<::std::string>>> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseNullableUtf8CppString::cppServer"); _aidl_ret_status = _aidl_data.readUtf8VectorFromUtf16Vector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseNullableUtf8CppString(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeUtf8VectorAsUtf16Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeUtf8VectorAsUtf16Vector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseUtf8CppStringList: { ::std::optional<::std::vector<::std::optional<::std::string>>> in_input; ::std::optional<::std::vector<::std::optional<::std::string>>> out_repeated; ::std::optional<::std::vector<::std::optional<::std::string>>> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseUtf8CppStringList::cppServer"); _aidl_ret_status = _aidl_data.readUtf8VectorFromUtf16Vector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseUtf8CppStringList(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeUtf8VectorAsUtf16Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeUtf8VectorAsUtf16Vector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_GetCallback: { bool in_return_null; ::android::sp<::android::aidl::tests::INamedCallback> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetCallback::cppServer"); _aidl_ret_status = _aidl_data.readBool(&in_return_null); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(GetCallback(in_return_null, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinder(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_FillOutStructuredParcelable: { ::android::aidl::tests::StructuredParcelable in_parcel; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::FillOutStructuredParcelable::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_parcel); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(FillOutStructuredParcelable(&in_parcel)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(in_parcel); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatExtendableParcelable: { ::android::aidl::tests::extension::ExtendableParcelable in_ep; ::android::aidl::tests::extension::ExtendableParcelable out_ep2; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatExtendableParcelable::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_ep); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatExtendableParcelable(in_ep, &out_ep2)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(out_ep2); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseList: { ::android::aidl::tests::RecursiveList in_list; ::android::aidl::tests::RecursiveList _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseList::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_list); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseList(in_list, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseIBinderArray: { ::std::vector<::android::sp<::android::IBinder>> in_input; ::std::vector<::android::sp<::android::IBinder>> out_repeated; ::std::vector<::android::sp<::android::IBinder>> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseIBinderArray::cppServer"); _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseIBinderArray(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseNullableIBinderArray: { ::std::optional<::std::vector<::android::sp<::android::IBinder>>> in_input; ::std::optional<::std::vector<::android::sp<::android::IBinder>>> out_repeated; ::std::optional<::std::vector<::android::sp<::android::IBinder>>> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseNullableIBinderArray::cppServer"); _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseNullableIBinderArray(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatSimpleParcelable: { ::android::aidl::tests::SimpleParcelable in_input; ::android::aidl::tests::SimpleParcelable out_repeat; ::android::aidl::tests::SimpleParcelable _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatSimpleParcelable::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatSimpleParcelable(in_input, &out_repeat, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(out_repeat); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseSimpleParcelables: { ::std::vector<::android::aidl::tests::SimpleParcelable> in_input; ::std::vector<::android::aidl::tests::SimpleParcelable> out_repeated; ::std::vector<::android::aidl::tests::SimpleParcelable> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseSimpleParcelables::cppServer"); _aidl_ret_status = _aidl_data.readParcelableVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseSimpleParcelables(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelableVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeParcelableVector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_GetOldNameInterface: { ::android::sp<::android::aidl::tests::IOldName> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetOldNameInterface::cppServer"); ::android::binder::Status _aidl_status(GetOldNameInterface(&_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinder(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_GetNewNameInterface: { ::android::sp<::android::aidl::tests::INewName> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetNewNameInterface::cppServer"); ::android::binder::Status _aidl_status(GetNewNameInterface(&_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinder(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_GetUnionTags: { ::std::vector<::android::aidl::tests::Union> in_input; ::std::vector<::android::aidl::tests::Union::Tag> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetUnionTags::cppServer"); _aidl_ret_status = _aidl_data.readParcelableVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(GetUnionTags(in_input, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeEnumVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_GetCppJavaTests: { ::android::sp<::android::IBinder> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetCppJavaTests::cppServer"); ::android::binder::Status _aidl_status(GetCppJavaTests(&_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinder(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_getBackendType: { ::android::aidl::tests::BackendType _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::getBackendType::cppServer"); ::android::binder::Status _aidl_status(getBackendType(&_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeByte(static_cast(_aidl_return)); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_GetCircular: { ::android::aidl::tests::CircularParcelable out_cp; ::android::sp<::android::aidl::tests::ICircular> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetCircular::cppServer"); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(GetCircular(&out_cp, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinder(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(out_cp); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } #pragma clang diagnostic pop } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { ::android::status_t ITestService::Empty::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t ITestService::Empty::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { ::android::status_t ITestService::CompilerChecks::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readStrongBinder(&binder); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readNullableStrongBinder(&nullable_binder); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readStrongBinderVector(&binder_array); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readStrongBinderVector(&nullable_binder_array); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readStrongBinderVector(&binder_list); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readStrongBinderVector(&nullable_binder_list); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelable(&pfd); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelable(&nullable_pfd); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelableVector(&pfd_array); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelableVector(&nullable_pfd_array); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelableVector(&pfd_list); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelableVector(&nullable_pfd_list); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelable(&parcel); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelable(&nullable_parcel); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelableVector(&parcel_array); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelableVector(&nullable_parcel_array); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelableVector(&parcel_list); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelableVector(&nullable_parcel_list); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t ITestService::CompilerChecks::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeStrongBinder(binder); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeStrongBinder(nullable_binder); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeStrongBinderVector(binder_array); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeStrongBinderVector(nullable_binder_array); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeStrongBinderVector(binder_list); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeStrongBinderVector(nullable_binder_list); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelable(pfd); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeNullableParcelable(nullable_pfd); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelableVector(pfd_array); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelableVector(nullable_pfd_array); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelableVector(pfd_list); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelableVector(nullable_pfd_list); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelable(parcel); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeNullableParcelable(nullable_parcel); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelableVector(parcel_array); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelableVector(nullable_parcel_array); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelableVector(parcel_list); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelableVector(nullable_parcel_list); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android #include #include namespace android { namespace aidl { namespace tests { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_NESTED_INTERFACE(ITestService::CompilerChecks, Foo, "android.aidl.tests.ITestService.CompilerChecks.Foo") } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { ITestService::CompilerChecks::BpFoo::BpFoo(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { ITestService::CompilerChecks::BnFoo::BnFoo() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t ITestService::CompilerChecks::BnFoo::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" ::android::status_t ITestService::CompilerChecks::HasDeprecated::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&deprecated); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t ITestService::CompilerChecks::HasDeprecated::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeInt32(deprecated); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } #pragma clang diagnostic pop } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { ::android::status_t ITestService::CompilerChecks::UsingHasDeprecated::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_tag)) != ::android::OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case n: { int32_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case m: { ::android::aidl::tests::ITestService::CompilerChecks::HasDeprecated _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readParcelable(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::android::aidl::tests::ITestService::CompilerChecks::HasDeprecated>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } } return ::android::BAD_VALUE; } ::android::status_t ITestService::CompilerChecks::UsingHasDeprecated::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(getTag())); if (_aidl_ret_status != ::android::OK) return _aidl_ret_status; switch (getTag()) { case n: return _aidl_parcel->writeInt32(get()); case m: return _aidl_parcel->writeParcelable(get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace aidl } // namespace android #include #include namespace android { namespace aidl { namespace tests { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_NESTED_INTERFACE(ITestService::CompilerChecks, NoPrefixInterface, "android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface") } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { ITestService::CompilerChecks::BpNoPrefixInterface::BpNoPrefixInterface(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } ::android::binder::Status ITestService::CompilerChecks::BpNoPrefixInterface::foo() { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::NoPrefixInterface::foo::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(ITestService::CompilerChecks::BnNoPrefixInterface::TRANSACTION_foo, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && INoPrefixInterface::getDefaultImpl()) [[unlikely]] { return INoPrefixInterface::getDefaultImpl()->foo(); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { ITestService::CompilerChecks::BnNoPrefixInterface::BnNoPrefixInterface() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t ITestService::CompilerChecks::BnNoPrefixInterface::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnNoPrefixInterface::TRANSACTION_foo: { if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::NoPrefixInterface::foo::cppServer"); ::android::binder::Status _aidl_status(foo()); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { ::android::status_t ITestService::CompilerChecks::INoPrefixInterface::Nested::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t ITestService::CompilerChecks::INoPrefixInterface::Nested::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android #include #include namespace android { namespace aidl { namespace tests { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_NESTED_INTERFACE(ITestService::CompilerChecks::INoPrefixInterface, NestedNoPrefixInterface, "android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.NestedNoPrefixInterface") } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { ITestService::CompilerChecks::INoPrefixInterface::BpNestedNoPrefixInterface::BpNestedNoPrefixInterface(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } ::android::binder::Status ITestService::CompilerChecks::INoPrefixInterface::BpNestedNoPrefixInterface::foo() { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::NestedNoPrefixInterface::foo::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(ITestService::CompilerChecks::INoPrefixInterface::BnNestedNoPrefixInterface::TRANSACTION_foo, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && INestedNoPrefixInterface::getDefaultImpl()) [[unlikely]] { return INestedNoPrefixInterface::getDefaultImpl()->foo(); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { ITestService::CompilerChecks::INoPrefixInterface::BnNestedNoPrefixInterface::BnNestedNoPrefixInterface() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t ITestService::CompilerChecks::INoPrefixInterface::BnNestedNoPrefixInterface::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnNestedNoPrefixInterface::TRANSACTION_foo: { if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::NestedNoPrefixInterface::foo::cppServer"); ::android::binder::Status _aidl_status(foo()); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_ITestServi0100644 0000000 0000000 00000000034 15172120304 033200 xustar000000000 0000000 28 mtime=1776853188.4110000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/ITestService.cpp.d0100644 0000000 0000000 00000002225 15172120304 031300 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/ITestService.cpp : \ system/tools/aidl/tests/android/aidl/tests/ITestService.aidl \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ICircular.aidl \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl \ system/tools/aidl/tests/android/aidl/tests/SimpleParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_IntEnum.cp0100644 0000000 0000000 00000000034 15172120304 033117 xustar000000000 0000000 28 mtime=1776853188.4110000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/IntEnum.cpp0100644 0000000 0000000 00000001231 15172120304 030060 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/IntEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl */ // This file is intentionally left blank as placeholder for enum declaration. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_IntEnum.cp0100644 0000000 0000000 00000000034 15172120304 033117 xustar000000000 0000000 28 mtime=1776853188.4110000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/IntEnum.cpp.d0100644 0000000 0000000 00000000253 15172120304 030305 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/IntEnum.cpp : \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_ListOfInte0100644 0000000 0000000 00000000034 15172120304 033157 xustar000000000 0000000 28 mtime=1776853188.4120000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/ListOfInterfaces.cpp0100644 0000000 0000000 00000047237 15172120304 031725 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ListOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ListOfInterfaces.aidl */ #include namespace android { namespace aidl { namespace tests { ::android::status_t ListOfInterfaces::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t ListOfInterfaces::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android #include #include namespace android { namespace aidl { namespace tests { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_NESTED_INTERFACE(ListOfInterfaces, EmptyInterface, "android.aidl.tests.ListOfInterfaces.IEmptyInterface") } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { ListOfInterfaces::BpEmptyInterface::BpEmptyInterface(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { ListOfInterfaces::BnEmptyInterface::BnEmptyInterface() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t ListOfInterfaces::BnEmptyInterface::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android #include #include namespace android { namespace aidl { namespace tests { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_NESTED_INTERFACE(ListOfInterfaces, MyInterface, "android.aidl.tests.ListOfInterfaces.IMyInterface") } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { ListOfInterfaces::BpMyInterface::BpMyInterface(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } ::android::binder::Status ListOfInterfaces::BpMyInterface::methodWithInterfaces(const ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& iface, const ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& nullable_iface, const ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>& iface_list_in, ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>* iface_list_out, ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>* iface_list_inout, const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>& nullable_iface_list_in, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>* nullable_iface_list_out, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>* nullable_iface_list_inout, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyInterface::methodWithInterfaces::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinder(iface); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinder(nullable_iface); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinderVector(iface_list_in); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinderVector(*iface_list_inout); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinderVector(nullable_iface_list_in); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinderVector(*nullable_iface_list_inout); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(ListOfInterfaces::BnMyInterface::TRANSACTION_methodWithInterfaces, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IMyInterface::getDefaultImpl()) [[unlikely]] { return IMyInterface::getDefaultImpl()->methodWithInterfaces(iface, nullable_iface, iface_list_in, iface_list_out, iface_list_inout, nullable_iface_list_in, nullable_iface_list_out, nullable_iface_list_inout, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(iface_list_out); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(iface_list_inout); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(nullable_iface_list_out); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(nullable_iface_list_inout); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { ListOfInterfaces::BnMyInterface::BnMyInterface() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t ListOfInterfaces::BnMyInterface::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnMyInterface::TRANSACTION_methodWithInterfaces: { ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface> in_iface; ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface> in_nullable_iface; ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>> in_iface_list_in; ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>> out_iface_list_out; ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>> in_iface_list_inout; ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>> in_nullable_iface_list_in; ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>> out_nullable_iface_list_out; ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>> in_nullable_iface_list_inout; ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyInterface::methodWithInterfaces::cppServer"); _aidl_ret_status = _aidl_data.readStrongBinder(&in_iface); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readNullableStrongBinder(&in_nullable_iface); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_iface_list_in); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_iface_list_inout); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_nullable_iface_list_in); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_nullable_iface_list_inout); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(methodWithInterfaces(in_iface, in_nullable_iface, in_iface_list_in, &out_iface_list_out, &in_iface_list_inout, in_nullable_iface_list_in, &out_nullable_iface_list_out, &in_nullable_iface_list_inout, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(out_iface_list_out); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(in_iface_list_inout); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(out_nullable_iface_list_out); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(in_nullable_iface_list_inout); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { ::android::status_t ListOfInterfaces::MyParcelable::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readStrongBinder(&iface); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readNullableStrongBinder(&nullable_iface); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readStrongBinderVector(&iface_list); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readStrongBinderVector(&nullable_iface_list); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t ListOfInterfaces::MyParcelable::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeStrongBinder(iface); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeStrongBinder(nullable_iface); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeStrongBinderVector(iface_list); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeStrongBinderVector(nullable_iface_list); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { ::android::status_t ListOfInterfaces::MyUnion::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_tag)) != ::android::OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case iface: { ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface> _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readStrongBinder(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case nullable_iface: { ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface> _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readNullableStrongBinder(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case iface_list: { ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>> _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readStrongBinderVector(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case nullable_iface_list: { ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>> _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readStrongBinderVector(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } } return ::android::BAD_VALUE; } ::android::status_t ListOfInterfaces::MyUnion::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(getTag())); if (_aidl_ret_status != ::android::OK) return _aidl_ret_status; switch (getTag()) { case iface: return _aidl_parcel->writeStrongBinder(get()); case nullable_iface: return _aidl_parcel->writeStrongBinder(get()); case iface_list: return _aidl_parcel->writeStrongBinderVector(get()); case nullable_iface_list: return _aidl_parcel->writeStrongBinderVector(get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_ListOfInte0100644 0000000 0000000 00000000034 15172120304 033157 xustar000000000 0000000 28 mtime=1776853188.4120000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/ListOfInterfaces.cpp.d0100644 0000000 0000000 00000000275 15172120304 032136 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/ListOfInterfaces.cpp : \ system/tools/aidl/tests/android/aidl/tests/ListOfInterfaces.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_LongEnum.c0100644 0000000 0000000 00000000034 15172120304 033104 xustar000000000 0000000 28 mtime=1776853188.4120000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/LongEnum.cpp0100644 0000000 0000000 00000001233 15172120304 030227 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/LongEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl */ // This file is intentionally left blank as placeholder for enum declaration. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_LongEnum.c0100644 0000000 0000000 00000000034 15172120304 033104 xustar000000000 0000000 28 mtime=1776853188.4120000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/LongEnum.cpp.d0100644 0000000 0000000 00000000255 15172120304 030454 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/LongEnum.cpp : \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_OtherParce0100644 0000000 0000000 00000000216 15172120304 033175 xustar000000000 0000000 114 path=tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/OtherParcelableForToString.cpp 28 mtime=1776853188.4120000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/OtherParcelableForToString0100644 0000000 0000000 00000004753 15172120304 033131 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/OtherParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl */ #include namespace android { namespace aidl { namespace tests { ::android::status_t OtherParcelableForToString::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readString16(&field); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t OtherParcelableForToString::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeString16(field); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_OtherParce0100644 0000000 0000000 00000000220 15172120304 033170 xustar000000000 0000000 116 path=tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/OtherParcelableForToString.cpp.d 28 mtime=1776853188.4120000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/OtherParcelableForToString0100644 0000000 0000000 00000000321 15172120304 033114 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/OtherParcelableForToString.cpp : \ system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_Parcelable0100644 0000000 0000000 00000000034 15172120304 033171 xustar000000000 0000000 28 mtime=1776853188.4120000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/ParcelableForToString.cpp0100644 0000000 0000000 00000031601 15172120304 032700 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ParcelableForToString.aidl */ #include namespace android { namespace aidl { namespace tests { ::android::status_t ParcelableForToString::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&intValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32Vector(&intArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt64(&longValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt64Vector(&longArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readDouble(&doubleValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readDoubleVector(&doubleArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFloat(&floatValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFloatVector(&floatArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readByte(&byteValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readByteVector(&byteArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readBool(&booleanValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readBoolVector(&booleanArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readString16(&stringValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readString16Vector(&stringArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readString16Vector(&stringList); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelable(&parcelableValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelableVector(&parcelableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast(&enumValue)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readEnumVector(&enumArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readString16Vector(&nullArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readString16Vector(&nullList); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelable(&parcelableGeneric); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelable(&unionValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t ParcelableForToString::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeInt32(intValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32Vector(intArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt64(longValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt64Vector(longArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeDouble(doubleValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeDoubleVector(doubleArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFloat(floatValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFloatVector(floatArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeByte(byteValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeByteVector(byteArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeBool(booleanValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeBoolVector(booleanArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeString16(stringValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeString16Vector(stringArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeString16Vector(stringList); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelable(parcelableValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelableVector(parcelableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(enumValue)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeEnumVector(enumArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeString16Vector(nullArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeString16Vector(nullList); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelable(parcelableGeneric); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelable(unionValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_Parcelable0100644 0000000 0000000 00000000213 15172120304 033170 xustar000000000 0000000 111 path=tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/ParcelableForToString.cpp.d 28 mtime=1776853188.4120000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/ParcelableForToString.cpp.0100644 0000000 0000000 00000001352 15172120304 032756 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/ParcelableForToString.cpp : \ system/tools/aidl/tests/android/aidl/tests/ParcelableForToString.aidl \ system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_RecursiveL0100644 0000000 0000000 00000000034 15172120304 033222 xustar000000000 0000000 28 mtime=1776853188.4120000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/RecursiveList.cpp0100644 0000000 0000000 00000005602 15172120304 031312 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/RecursiveList.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl */ #include namespace android { namespace aidl { namespace tests { ::android::status_t RecursiveList::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&value); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelable(&next); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t RecursiveList::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeInt32(value); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeNullableParcelable(next); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_RecursiveL0100644 0000000 0000000 00000000034 15172120304 033222 xustar000000000 0000000 28 mtime=1776853188.4120000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/RecursiveList.cpp.d0100644 0000000 0000000 00000000267 15172120304 031536 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/RecursiveList.cpp : \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_Structured0100644 0000000 0000000 00000000034 15172120304 033303 xustar000000000 0000000 28 mtime=1776853188.4120000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/StructuredParcelable.cpp0100644 0000000 0000000 00000074175 15172120304 032641 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/StructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl */ #include namespace android { namespace aidl { namespace tests { ::android::status_t StructuredParcelable::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32Vector(&shouldContainThreeFs); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&f); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readUtf8FromUtf16(&shouldBeJerry); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readByte(reinterpret_cast(&shouldBeByteBar)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast(&shouldBeIntBar)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt64(reinterpret_cast(&shouldBeLongBar)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readEnumVector(&shouldContainTwoByteFoos); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readEnumVector(&shouldContainTwoIntFoos); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readEnumVector(&shouldContainTwoLongFoos); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readString16(&stringDefaultsToFoo); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readByte(&byteDefaultsToFour); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&intDefaultsToFive); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt64(&longDefaultsToNegativeSeven); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readBool(&booleanDefaultsToTrue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readChar(&charDefaultsToC); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFloat(&floatDefaultsToPi); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readDouble(&doubleWithDefault); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32Vector(&arrayDefaultsTo123); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32Vector(&arrayDefaultsToEmpty); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readBool(&boolDefault); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readByte(&byteDefault); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&intDefault); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt64(&longDefault); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFloat(&floatDefault); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readDouble(&doubleDefault); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readDouble(&checkDoubleFromFloat); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readString16Vector(&checkStringArray1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readUtf8VectorFromUtf16Vector(&checkStringArray2); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&int32_min); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&int32_max); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt64(&int64_max); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&hexInt32_neg_1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readNullableStrongBinder(&ibinder); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelable(&empty); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readByteVector(&int8_1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32Vector(&int32_1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt64Vector(&int64_1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&hexInt32_pos_1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&hexInt64_pos_1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast(&const_exprs_1)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast(&const_exprs_2)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast(&const_exprs_3)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast(&const_exprs_4)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast(&const_exprs_5)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast(&const_exprs_6)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast(&const_exprs_7)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast(&const_exprs_8)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast(&const_exprs_9)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast(&const_exprs_10)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readUtf8FromUtf16(&addString1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readUtf8FromUtf16(&addString2); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&shouldSetBit0AndBit2); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelable(&u); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelable(&shouldBeConstS1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast(&defaultWithFoo)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t StructuredParcelable::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeInt32Vector(shouldContainThreeFs); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(f); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeUtf8AsUtf16(shouldBeJerry); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeByte(static_cast(shouldBeByteBar)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(shouldBeIntBar)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt64(static_cast(shouldBeLongBar)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeEnumVector(shouldContainTwoByteFoos); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeEnumVector(shouldContainTwoIntFoos); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeEnumVector(shouldContainTwoLongFoos); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeString16(stringDefaultsToFoo); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeByte(byteDefaultsToFour); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(intDefaultsToFive); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt64(longDefaultsToNegativeSeven); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeBool(booleanDefaultsToTrue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeChar(charDefaultsToC); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFloat(floatDefaultsToPi); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeDouble(doubleWithDefault); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32Vector(arrayDefaultsTo123); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32Vector(arrayDefaultsToEmpty); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeBool(boolDefault); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeByte(byteDefault); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(intDefault); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt64(longDefault); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFloat(floatDefault); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeDouble(doubleDefault); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeDouble(checkDoubleFromFloat); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeString16Vector(checkStringArray1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeUtf8VectorAsUtf16Vector(checkStringArray2); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(int32_min); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(int32_max); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt64(int64_max); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(hexInt32_neg_1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeStrongBinder(ibinder); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelable(empty); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeByteVector(int8_1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32Vector(int32_1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt64Vector(int64_1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(hexInt32_pos_1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(hexInt64_pos_1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(const_exprs_1)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(const_exprs_2)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(const_exprs_3)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(const_exprs_4)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(const_exprs_5)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(const_exprs_6)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(const_exprs_7)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(const_exprs_8)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(const_exprs_9)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(const_exprs_10)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeUtf8AsUtf16(addString1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeUtf8AsUtf16(addString2); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(shouldSetBit0AndBit2); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeNullableParcelable(u); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeNullableParcelable(shouldBeConstS1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(defaultWithFoo)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { ::android::status_t StructuredParcelable::Empty::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t StructuredParcelable::Empty::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_Structured0100644 0000000 0000000 00000000212 15172120304 033301 xustar000000000 0000000 110 path=tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/StructuredParcelable.cpp.d 28 mtime=1776853188.4130000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/StructuredParcelable.cpp.d0100644 0000000 0000000 00000001000 15172120304 033034 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/StructuredParcelable.cpp : \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_Union.cpp0100644 0000000 0000000 00000000034 15172120304 033010 xustar000000000 0000000 28 mtime=1776853188.4130000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/Union.cpp0100644 0000000 0000000 00000011401 15172120304 027571 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/Union.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/Union.aidl */ #include namespace android { namespace aidl { namespace tests { const ::std::string& Union::S1() { static const ::std::string value("a string constant in union"); return value; } ::android::status_t Union::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_tag)) != ::android::OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case ns: { ::std::vector _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32Vector(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::std::vector>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case n: { int32_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case m: { int32_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case s: { ::std::string _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readUtf8FromUtf16(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::std::string>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case ibinder: { ::android::sp<::android::IBinder> _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readNullableStrongBinder(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::android::sp<::android::IBinder>>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case ss: { ::std::vector<::std::string> _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readUtf8VectorFromUtf16Vector(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::std::vector<::std::string>>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case be: { ::android::aidl::tests::ByteEnum _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readByte(reinterpret_cast(&_aidl_value))) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::android::aidl::tests::ByteEnum>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } } return ::android::BAD_VALUE; } ::android::status_t Union::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(getTag())); if (_aidl_ret_status != ::android::OK) return _aidl_ret_status; switch (getTag()) { case ns: return _aidl_parcel->writeInt32Vector(get()); case n: return _aidl_parcel->writeInt32(get()); case m: return _aidl_parcel->writeInt32(get()); case s: return _aidl_parcel->writeUtf8AsUtf16(get()); case ibinder: return _aidl_parcel->writeStrongBinder(get()); case ss: return _aidl_parcel->writeUtf8VectorAsUtf16Vector(get()); case be: return _aidl_parcel->writeByte(static_cast(get())); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_Union.cpp.0100644 0000000 0000000 00000000034 15172120304 033066 xustar000000000 0000000 28 mtime=1776853188.4130000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/Union.cpp.d0100644 0000000 0000000 00000000344 15172120304 030017 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/Union.cpp : \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_UnionWithF0100644 0000000 0000000 00000000034 15172120304 033171 xustar000000000 0000000 28 mtime=1776853188.4130000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/UnionWithFd.cpp0100644 0000000 0000000 00000004517 15172120304 030711 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/UnionWithFd.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/UnionWithFd.aidl */ #include namespace android { namespace aidl { namespace tests { ::android::status_t UnionWithFd::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_tag)) != ::android::OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case num: { int32_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case pfd: { ::android::os::ParcelFileDescriptor _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readParcelable(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::android::os::ParcelFileDescriptor>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } } return ::android::BAD_VALUE; } ::android::status_t UnionWithFd::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(getTag())); if (_aidl_ret_status != ::android::OK) return _aidl_ret_status; switch (getTag()) { case num: return _aidl_parcel->writeInt32(get()); case pfd: return _aidl_parcel->writeParcelable(get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_UnionWithF0100644 0000000 0000000 00000000034 15172120304 033171 xustar000000000 0000000 28 mtime=1776853188.4130000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/UnionWithFd.cpp.d0100644 0000000 0000000 00000000263 15172120304 031125 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/UnionWithFd.cpp : \ system/tools/aidl/tests/android/aidl/tests/UnionWithFd.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_extension_0100644 0000000 0000000 00000000034 15172120304 033312 xustar000000000 0000000 28 mtime=1776853188.4130000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/0040755 0000000 0000000 00000000000 15172120304 030017 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_extension_0100644 0000000 0000000 00000000222 15172120304 033311 xustar000000000 0000000 118 path=tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/ExtendableParcelable.cpp 28 mtime=1776853188.4130000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/ExtendableParcel0100644 0000000 0000000 00000010521 15172120304 033140 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/extension/ExtendableParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl */ #include namespace android { namespace aidl { namespace tests { namespace extension { ::android::status_t ExtendableParcelable::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&a); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readUtf8FromUtf16(&b); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelable(&ext); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt64(&c); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelable(&ext2); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t ExtendableParcelable::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeInt32(a); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeUtf8AsUtf16(b); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelable(ext); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt64(c); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelable(ext2); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace extension } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_extension_0100644 0000000 0000000 00000000224 15172120304 033313 xustar000000000 0000000 120 path=tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/ExtendableParcelable.cpp.d 28 mtime=1776853188.4140000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/ExtendableParcel0100644 0000000 0000000 00000000331 15172120304 033136 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/ExtendableParcelable.cpp : \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_extension_0100644 0000000 0000000 00000000034 15172120304 033312 xustar000000000 0000000 28 mtime=1776853188.4140000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/MyExt.cpp0100644 0000000 0000000 00000005626 15172120304 031577 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/extension/MyExt.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl */ #include namespace android { namespace aidl { namespace tests { namespace extension { ::android::status_t MyExt::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&a); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readUtf8FromUtf16(&b); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t MyExt::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeInt32(a); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeUtf8AsUtf16(b); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace extension } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_extension_0100644 0000000 0000000 00000000034 15172120304 033312 xustar000000000 0000000 28 mtime=1776853188.4140000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/MyExt.cpp.d0100644 0000000 0000000 00000000273 15172120304 032012 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/MyExt.cpp : \ system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_extension_0100644 0000000 0000000 00000000034 15172120304 033312 xustar000000000 0000000 28 mtime=1776853188.4140000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/MyExt2.cpp0100644 0000000 0000000 00000006553 15172120304 031661 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/extension/MyExt2.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt2.aidl */ #include namespace android { namespace aidl { namespace tests { namespace extension { ::android::status_t MyExt2::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&a); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelable(&b); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readUtf8FromUtf16(&c); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t MyExt2::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeInt32(a); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelable(b); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeUtf8AsUtf16(c); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace extension } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_extension_0100644 0000000 0000000 00000000034 15172120304 033312 xustar000000000 0000000 28 mtime=1776853188.4140000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/MyExt2.cpp.d0100644 0000000 0000000 00000000401 15172120304 032065 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/MyExt2.cpp : \ system/tools/aidl/tests/android/aidl/tests/extension/MyExt2.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_extension_0100644 0000000 0000000 00000000034 15172120304 033312 xustar000000000 0000000 28 mtime=1776853188.4140000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/MyExtLike.cpp0100644 0000000 0000000 00000005642 15172120304 032402 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/extension/MyExtLike.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExtLike.aidl */ #include namespace android { namespace aidl { namespace tests { namespace extension { ::android::status_t MyExtLike::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&a); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readString16(&b); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t MyExtLike::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeInt32(a); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeString16(b); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace extension } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_extension_0100644 0000000 0000000 00000000034 15172120304 033312 xustar000000000 0000000 28 mtime=1776853188.4140000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/MyExtLike.cpp.d0100644 0000000 0000000 00000000303 15172120304 032611 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/MyExtLike.cpp : \ system/tools/aidl/tests/android/aidl/tests/extension/MyExtLike.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_nested_0100644 0000000 0000000 00000000034 15172120304 032560 xustar000000000 0000000 28 mtime=1776853188.4140000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/nested/0040755 0000000 0000000 00000000000 15172120304 027265 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_nested_Dee0100644 0000000 0000000 00000000034 15172120304 033176 xustar000000000 0000000 28 mtime=1776853188.4140000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/nested/DeeplyNested.cpp0100644 0000000 0000000 00000020343 15172120304 032355 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/nested/DeeplyNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/DeeplyNested.aidl */ #include namespace android { namespace aidl { namespace tests { namespace nested { ::android::status_t DeeplyNested::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t DeeplyNested::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { namespace nested { ::android::status_t DeeplyNested::A::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readByte(reinterpret_cast(&e)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t DeeplyNested::A::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeByte(static_cast(e)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { namespace nested { ::android::status_t DeeplyNested::B::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t DeeplyNested::B::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { namespace nested { ::android::status_t DeeplyNested::B::C::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t DeeplyNested::B::C::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { namespace nested { ::android::status_t DeeplyNested::B::C::D::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t DeeplyNested::B::C::D::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_nested_Dee0100644 0000000 0000000 00000000034 15172120304 033176 xustar000000000 0000000 28 mtime=1776853188.4140000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/nested/DeeplyNested.cpp.d0100644 0000000 0000000 00000000303 15172120304 032571 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/nested/DeeplyNested.cpp : \ system/tools/aidl/tests/android/aidl/tests/nested/DeeplyNested.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_nested_INe0100644 0000000 0000000 00000000034 15172120304 033154 xustar000000000 0000000 28 mtime=1776853188.4140000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/nested/INestedService.cpp0100644 0000000 0000000 00000033347 15172120304 032654 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/nested/INestedService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/INestedService.aidl */ #include #include namespace android { namespace aidl { namespace tests { namespace nested { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE(NestedService, "android.aidl.tests.nested.INestedService") } // namespace nested } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { namespace nested { BpNestedService::BpNestedService(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } ::android::binder::Status BpNestedService::flipStatus(const ::android::aidl::tests::nested::ParcelableWithNested& p, ::android::aidl::tests::nested::INestedService::Result* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::INestedService::flipStatus::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(p); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnNestedService::TRANSACTION_flipStatus, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && INestedService::getDefaultImpl()) [[unlikely]] { return INestedService::getDefaultImpl()->flipStatus(p, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpNestedService::flipStatusWithCallback(::android::aidl::tests::nested::ParcelableWithNested::Status status, const ::android::sp<::android::aidl::tests::nested::INestedService::ICallback>& cb) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::INestedService::flipStatusWithCallback::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeByte(static_cast(status)); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinder(cb); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnNestedService::TRANSACTION_flipStatusWithCallback, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && INestedService::getDefaultImpl()) [[unlikely]] { return INestedService::getDefaultImpl()->flipStatusWithCallback(status, cb); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { namespace nested { BnNestedService::BnNestedService() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t BnNestedService::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnNestedService::TRANSACTION_flipStatus: { ::android::aidl::tests::nested::ParcelableWithNested in_p; ::android::aidl::tests::nested::INestedService::Result _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::INestedService::flipStatus::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_p); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(flipStatus(in_p, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnNestedService::TRANSACTION_flipStatusWithCallback: { ::android::aidl::tests::nested::ParcelableWithNested::Status in_status; ::android::sp<::android::aidl::tests::nested::INestedService::ICallback> in_cb; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::INestedService::flipStatusWithCallback::cppServer"); _aidl_ret_status = _aidl_data.readByte(reinterpret_cast(&in_status)); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readStrongBinder(&in_cb); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(flipStatusWithCallback(in_status, in_cb)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { namespace nested { ::android::status_t INestedService::Result::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readByte(reinterpret_cast(&status)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t INestedService::Result::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeByte(static_cast(status)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android #include #include namespace android { namespace aidl { namespace tests { namespace nested { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_NESTED_INTERFACE(INestedService, Callback, "android.aidl.tests.nested.INestedService.ICallback") } // namespace nested } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { namespace nested { INestedService::BpCallback::BpCallback(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } ::android::binder::Status INestedService::BpCallback::done(::android::aidl::tests::nested::ParcelableWithNested::Status status) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICallback::done::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeByte(static_cast(status)); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(INestedService::BnCallback::TRANSACTION_done, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ICallback::getDefaultImpl()) [[unlikely]] { return ICallback::getDefaultImpl()->done(status); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { namespace nested { INestedService::BnCallback::BnCallback() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t INestedService::BnCallback::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnCallback::TRANSACTION_done: { ::android::aidl::tests::nested::ParcelableWithNested::Status in_status; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICallback::done::cppServer"); _aidl_ret_status = _aidl_data.readByte(reinterpret_cast(&in_status)); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(done(in_status)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_nested_INe0100644 0000000 0000000 00000000213 15172120304 033153 xustar000000000 0000000 111 path=tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/nested/INestedService.cpp.d 28 mtime=1776853188.4140000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/nested/INestedService.cpp.0100644 0000000 0000000 00000000427 15172120304 032723 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/nested/INestedService.cpp : \ system/tools/aidl/tests/android/aidl/tests/nested/INestedService.aidl \ system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_nested_Par0100644 0000000 0000000 00000000217 15172120304 033226 xustar000000000 0000000 115 path=tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/nested/ParcelableWithNested.cpp 28 mtime=1776853188.4140000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/nested/ParcelableWithNeste0100644 0000000 0000000 00000005067 15172120304 033102 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/nested/ParcelableWithNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl */ #include namespace android { namespace aidl { namespace tests { namespace nested { ::android::status_t ParcelableWithNested::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readByte(reinterpret_cast(&status)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t ParcelableWithNested::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeByte(static_cast(status)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_nested_Par0100644 0000000 0000000 00000000221 15172120304 033221 xustar000000000 0000000 117 path=tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/nested/ParcelableWithNested.cpp.d 28 mtime=1776853188.4140000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/nested/ParcelableWithNeste0100644 0000000 0000000 00000000323 15172120304 033070 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/nested/ParcelableWithNested.cpp : \ system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_unions_0100644 0000000 0000000 00000000034 15172120304 032611 xustar000000000 0000000 28 mtime=1776853188.4140000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/unions/0040755 0000000 0000000 00000000000 15172120304 027316 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_unions_Enu0100644 0000000 0000000 00000000034 15172120304 033261 xustar000000000 0000000 28 mtime=1776853188.4140000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/unions/EnumUnion.cpp0100644 0000000 0000000 00000006432 15172120304 031741 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/unions/EnumUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl */ #include namespace android { namespace aidl { namespace tests { namespace unions { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" ::android::status_t EnumUnion::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_tag)) != ::android::OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case intEnum: { ::android::aidl::tests::IntEnum _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast(&_aidl_value))) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::android::aidl::tests::IntEnum>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case longEnum: { ::android::aidl::tests::LongEnum _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt64(reinterpret_cast(&_aidl_value))) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::android::aidl::tests::LongEnum>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case deprecatedField: { int32_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } } return ::android::BAD_VALUE; } ::android::status_t EnumUnion::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(getTag())); if (_aidl_ret_status != ::android::OK) return _aidl_ret_status; switch (getTag()) { case intEnum: return _aidl_parcel->writeInt32(static_cast(get())); case longEnum: return _aidl_parcel->writeInt64(static_cast(get())); #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" case deprecatedField: return _aidl_parcel->writeInt32(get()); #pragma clang diagnostic pop } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } #pragma clang diagnostic pop } // namespace unions } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_unions_Enu0100644 0000000 0000000 00000000034 15172120304 033261 xustar000000000 0000000 28 mtime=1776853188.4150000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/unions/EnumUnion.cpp.d0100644 0000000 0000000 00000000466 15172120304 032164 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/unions/EnumUnion.cpp : \ system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_unions_Uni0100644 0000000 0000000 00000000034 15172120304 033265 xustar000000000 0000000 28 mtime=1776853188.4150000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/unions/UnionInUnion.cpp0100644 0000000 0000000 00000004670 15172120304 032416 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/unions/UnionInUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/UnionInUnion.aidl */ #include namespace android { namespace aidl { namespace tests { namespace unions { ::android::status_t UnionInUnion::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_tag)) != ::android::OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case first: { ::android::aidl::tests::unions::EnumUnion _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readParcelable(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::android::aidl::tests::unions::EnumUnion>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case second: { int32_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } } return ::android::BAD_VALUE; } ::android::status_t UnionInUnion::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(getTag())); if (_aidl_ret_status != ::android::OK) return _aidl_ret_status; switch (getTag()) { case first: return _aidl_parcel->writeParcelable(get()); case second: return _aidl_parcel->writeInt32(get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace unions } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_android_aidl_tests_unions_Uni0100644 0000000 0000000 00000000034 15172120304 033265 xustar000000000 0000000 28 mtime=1776853188.4150000 tests/golden_output/aidl-test-interface-cpp-source/gen/android/aidl/tests/unions/UnionInUnion.cpp.d0100644 0000000 0000000 00000000601 15172120304 032626 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/unions/UnionInUnion.cpp : \ system/tools/aidl/tests/android/aidl/tests/unions/UnionInUnion.aidl \ system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_0100644 0000000 0000000 00000000034 15172120304 027006 xustar000000000 0000000 28 mtime=1776853188.4150000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/0040755 0000000 0000000 00000000000 15172120304 023733 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_0100644 0000000 0000000 00000000034 15172120304 030506 xustar000000000 0000000 28 mtime=1776853188.4150000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/0040755 0000000 0000000 00000000000 15172120304 025353 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_0100644 0000000 0000000 00000000034 15172120304 031477 xustar000000000 0000000 28 mtime=1776853188.4150000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/0040755 0000000 0000000 00000000000 15172120304 026264 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_0100644 0000000 0000000 00000000034 15172120304 032721 xustar000000000 0000000 28 mtime=1776853188.4150000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/0040755 0000000 0000000 00000000000 15172120304 027426 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Ar0100644 0000000 0000000 00000000213 15172120304 033203 xustar000000000 0000000 111 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/ArrayOfInterfaces.h 28 mtime=1776853188.4150000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/ArrayOfInterfaces.0100644 0000000 0000000 00000043637 15172120304 033010 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ArrayOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ArrayOfInterfaces.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace android { namespace aidl { namespace tests { class ArrayOfInterfaces : public ::android::Parcelable { public: class IEmptyInterfaceDelegator; class IEmptyInterface : public ::android::IInterface { public: typedef IEmptyInterfaceDelegator DefaultDelegator; DECLARE_META_INTERFACE(EmptyInterface) }; // class IEmptyInterface class IEmptyInterfaceDefault : public IEmptyInterface { public: ::android::IBinder* onAsBinder() override { return nullptr; } }; // class IEmptyInterfaceDefault class BpEmptyInterface : public ::android::BpInterface { public: explicit BpEmptyInterface(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpEmptyInterface() = default; }; // class BpEmptyInterface class BnEmptyInterface : public ::android::BnInterface { public: explicit BnEmptyInterface(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnEmptyInterface class IEmptyInterfaceDelegator : public BnEmptyInterface { public: explicit IEmptyInterfaceDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } private: ::android::sp _aidl_delegate; }; // class IEmptyInterfaceDelegator class IMyInterfaceDelegator; class IMyInterface : public ::android::IInterface { public: typedef IMyInterfaceDelegator DefaultDelegator; DECLARE_META_INTERFACE(MyInterface) virtual ::android::binder::Status methodWithInterfaces(const ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& iface, const ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& nullable_iface, const ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>& iface_array_in, ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>* iface_array_out, ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>* iface_array_inout, const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>& nullable_iface_array_in, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>* nullable_iface_array_out, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>* nullable_iface_array_inout, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>* _aidl_return) = 0; }; // class IMyInterface class IMyInterfaceDefault : public IMyInterface { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status methodWithInterfaces(const ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& /*iface*/, const ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& /*nullable_iface*/, const ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>& /*iface_array_in*/, ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>* /*iface_array_out*/, ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>* /*iface_array_inout*/, const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>& /*nullable_iface_array_in*/, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>* /*nullable_iface_array_out*/, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>* /*nullable_iface_array_inout*/, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } }; // class IMyInterfaceDefault class BpMyInterface : public ::android::BpInterface { public: explicit BpMyInterface(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpMyInterface() = default; ::android::binder::Status methodWithInterfaces(const ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& iface, const ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& nullable_iface, const ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>& iface_array_in, ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>* iface_array_out, ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>* iface_array_inout, const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>& nullable_iface_array_in, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>* nullable_iface_array_out, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>* nullable_iface_array_inout, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>* _aidl_return) override; }; // class BpMyInterface class BnMyInterface : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_methodWithInterfaces = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; explicit BnMyInterface(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnMyInterface class IMyInterfaceDelegator : public BnMyInterface { public: explicit IMyInterfaceDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status methodWithInterfaces(const ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& iface, const ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& nullable_iface, const ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>& iface_array_in, ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>* iface_array_out, ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>* iface_array_inout, const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>& nullable_iface_array_in, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>* nullable_iface_array_out, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>* nullable_iface_array_inout, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>* _aidl_return) override { ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterfaceDelegator> _iface; if (iface) { _iface = ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterfaceDelegator>::cast(delegate(iface)); } ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterfaceDelegator> _nullable_iface; if (nullable_iface) { _nullable_iface = ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterfaceDelegator>::cast(delegate(nullable_iface)); } return _aidl_delegate->methodWithInterfaces(_iface, _nullable_iface, iface_array_in, iface_array_out, iface_array_inout, nullable_iface_array_in, nullable_iface_array_out, nullable_iface_array_inout, _aidl_return); } private: ::android::sp _aidl_delegate; }; // class IMyInterfaceDelegator class MyParcelable : public ::android::Parcelable { public: ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface> iface; ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface> nullable_iface; ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>> iface_array; ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>> nullable_iface_array; inline bool operator==(const MyParcelable& _rhs) const { return std::tie(iface, nullable_iface, iface_array, nullable_iface_array) == std::tie(_rhs.iface, _rhs.nullable_iface, _rhs.iface_array, _rhs.nullable_iface_array); } inline bool operator<(const MyParcelable& _rhs) const { return std::tie(iface, nullable_iface, iface_array, nullable_iface_array) < std::tie(_rhs.iface, _rhs.nullable_iface, _rhs.iface_array, _rhs.nullable_iface_array); } inline bool operator!=(const MyParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyParcelable& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.ArrayOfInterfaces.MyParcelable"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "MyParcelable{"; _aidl_os << "iface: " << ::android::internal::ToString(iface); _aidl_os << ", nullable_iface: " << ::android::internal::ToString(nullable_iface); _aidl_os << ", iface_array: " << ::android::internal::ToString(iface_array); _aidl_os << ", nullable_iface_array: " << ::android::internal::ToString(nullable_iface_array); _aidl_os << "}"; return _aidl_os.str(); } }; // class MyParcelable class MyUnion : public ::android::Parcelable { public: enum class Tag : int32_t { iface = 0, nullable_iface = 1, iface_array = 2, nullable_iface_array = 3, }; // Expose tag symbols for legacy code static const inline Tag iface = Tag::iface; static const inline Tag nullable_iface = Tag::nullable_iface; static const inline Tag iface_array = Tag::iface_array; static const inline Tag nullable_iface_array = Tag::nullable_iface_array; template static constexpr bool _not_self = !std::is_same_v>, MyUnion>; MyUnion() : _value(std::in_place_index(iface)>, ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>()) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr MyUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit MyUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static MyUnion make(_Tp&&... _args) { return MyUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static MyUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return MyUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } inline bool operator==(const MyUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const MyUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const MyUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyUnion& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.ArrayOfInterfaces.MyUnion"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream os; os << "MyUnion{"; switch (getTag()) { case iface: os << "iface: " << ::android::internal::ToString(get()); break; case nullable_iface: os << "nullable_iface: " << ::android::internal::ToString(get()); break; case iface_array: os << "iface_array: " << ::android::internal::ToString(get()); break; case nullable_iface_array: os << "nullable_iface_array: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>, ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>, ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>> _value; }; // class MyUnion inline bool operator==(const ArrayOfInterfaces&) const { return std::tie() == std::tie(); } inline bool operator<(const ArrayOfInterfaces&) const { return std::tie() < std::tie(); } inline bool operator!=(const ArrayOfInterfaces& _rhs) const { return !(*this == _rhs); } inline bool operator>(const ArrayOfInterfaces& _rhs) const { return _rhs < *this; } inline bool operator>=(const ArrayOfInterfaces& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const ArrayOfInterfaces& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.ArrayOfInterfaces"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "ArrayOfInterfaces{"; _aidl_os << "}"; return _aidl_os.str(); } }; // class ArrayOfInterfaces } // namespace tests } // namespace aidl } // namespace android namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(ArrayOfInterfaces::MyUnion::Tag val) { switch(val) { case ArrayOfInterfaces::MyUnion::Tag::iface: return "iface"; case ArrayOfInterfaces::MyUnion::Tag::nullable_iface: return "nullable_iface"; case ArrayOfInterfaces::MyUnion::Tag::iface_array: return "iface_array"; case ArrayOfInterfaces::MyUnion::Tag::nullable_iface_array: return "nullable_iface_array"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::tests::ArrayOfInterfaces::MyUnion::Tag, 4> enum_values<::android::aidl::tests::ArrayOfInterfaces::MyUnion::Tag> = { ::android::aidl::tests::ArrayOfInterfaces::MyUnion::Tag::iface, ::android::aidl::tests::ArrayOfInterfaces::MyUnion::Tag::nullable_iface, ::android::aidl::tests::ArrayOfInterfaces::MyUnion::Tag::iface_array, ::android::aidl::tests::ArrayOfInterfaces::MyUnion::Tag::nullable_iface_array, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Ba0100644 0000000 0000000 00000000034 15172120304 033164 xustar000000000 0000000 28 mtime=1776853188.4160000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BackendType.h0100644 0000000 0000000 00000003510 15172120304 031764 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/BackendType.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/BackendType.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { enum class BackendType : int8_t { CPP = 0, JAVA = 1, NDK = 2, RUST = 3, }; } // namespace tests } // namespace aidl } // namespace android namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(BackendType val) { switch(val) { case BackendType::CPP: return "CPP"; case BackendType::JAVA: return "JAVA"; case BackendType::NDK: return "NDK"; case BackendType::RUST: return "RUST"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::tests::BackendType, 4> enum_values<::android::aidl::tests::BackendType> = { ::android::aidl::tests::BackendType::CPP, ::android::aidl::tests::BackendType::JAVA, ::android::aidl::tests::BackendType::NDK, ::android::aidl::tests::BackendType::RUST, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bn0100644 0000000 0000000 00000000215 15172120304 033202 xustar000000000 0000000 113 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnArrayOfInterfaces.h 28 mtime=1776853188.4160000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnArrayOfInterface0100644 0000000 0000000 00000001232 15172120304 033010 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ArrayOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ArrayOfInterfaces.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bn0100644 0000000 0000000 00000000034 15172120304 033201 xustar000000000 0000000 28 mtime=1776853188.4160000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnBackendType.h0100644 0000000 0000000 00000001210 15172120304 032237 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/BackendType.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/BackendType.aidl */ #error TODO(b/111362593) enums do not have bn classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bn0100644 0000000 0000000 00000000034 15172120304 033201 xustar000000000 0000000 28 mtime=1776853188.4160000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnByteEnum.h0100644 0000000 0000000 00000001202 15172120304 031577 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ByteEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl */ #error TODO(b/111362593) enums do not have bn classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bn0100644 0000000 0000000 00000000034 15172120304 033201 xustar000000000 0000000 28 mtime=1776853188.4160000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnCircular.h0100644 0000000 0000000 00000003642 15172120304 031625 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ICircular.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ICircular.aidl */ #pragma once #include #include #include #include #include namespace android { namespace aidl { namespace tests { class BnCircular : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_GetTestService = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; explicit BnCircular(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnCircular class ICircularDelegator : public BnCircular { public: explicit ICircularDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status GetTestService(::android::sp<::android::aidl::tests::ITestService>* _aidl_return) override { auto _status = _aidl_delegate->GetTestService(_aidl_return); if (*_aidl_return) { *_aidl_return = ::android::sp<::android::aidl::tests::ITestServiceDelegator>::cast(delegate(*_aidl_return)); } return _status; } private: ::android::sp _aidl_delegate; }; // class ICircularDelegator } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bn0100644 0000000 0000000 00000000216 15172120304 033203 xustar000000000 0000000 114 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnCircularParcelable.h 28 mtime=1776853188.4160000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnCircularParcelab0100644 0000000 0000000 00000001234 15172120304 033024 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/CircularParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bn0100644 0000000 0000000 00000000222 15172120304 033200 xustar000000000 0000000 118 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnConstantExpressionEnum.h 28 mtime=1776853188.4160000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnConstantExpressi0100644 0000000 0000000 00000001236 15172120304 033144 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ConstantExpressionEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl */ #error TODO(b/111362593) enums do not have bn classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bn0100644 0000000 0000000 00000000034 15172120304 033201 xustar000000000 0000000 28 mtime=1776853188.4180000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnDeprecated.h0100644 0000000 0000000 00000003015 15172120304 032113 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/IDeprecated.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IDeprecated.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { class __attribute__((deprecated("test"))) BnDeprecated : public ::android::BnInterface { public: explicit BnDeprecated(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnDeprecated class __attribute__((deprecated("test"))) IDeprecatedDelegator : public BnDeprecated { public: explicit IDeprecatedDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } private: ::android::sp _aidl_delegate; }; // class IDeprecatedDelegator } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bn0100644 0000000 0000000 00000000212 15172120304 033177 xustar000000000 0000000 110 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnDeprecatedEnum.h 28 mtime=1776853188.4180000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnDeprecatedEnum.h0100644 0000000 0000000 00000001216 15172120304 032741 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/DeprecatedEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedEnum.aidl */ #error TODO(b/111362593) enums do not have bn classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bn0100644 0000000 0000000 00000000220 15172120304 033176 xustar000000000 0000000 116 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnDeprecatedParcelable.h 28 mtime=1776853188.4180000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnDeprecatedParcel0100644 0000000 0000000 00000001240 15172120304 033012 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/DeprecatedParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedParcelable.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bn0100644 0000000 0000000 00000000034 15172120304 033201 xustar000000000 0000000 28 mtime=1776853188.4180000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnFixedSize.h0100644 0000000 0000000 00000001212 15172120304 031742 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/FixedSize.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/FixedSize.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bn0100644 0000000 0000000 00000000227 15172120304 033205 xustar000000000 0000000 123 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnGenericStructuredParcelable.h 28 mtime=1776853188.4190000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnGenericStructure0100644 0000000 0000000 00000001256 15172120304 033127 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/GenericStructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bn0100644 0000000 0000000 00000000034 15172120304 033201 xustar000000000 0000000 28 mtime=1776853188.4190000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnIntEnum.h0100644 0000000 0000000 00000001200 15172120304 031424 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/IntEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl */ #error TODO(b/111362593) enums do not have bn classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bn0100644 0000000 0000000 00000000214 15172120304 033201 xustar000000000 0000000 112 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnListOfInterfaces.h 28 mtime=1776853188.4190000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnListOfInterfaces0100644 0000000 0000000 00000001230 15172120304 033026 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ListOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ListOfInterfaces.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bn0100644 0000000 0000000 00000000034 15172120304 033201 xustar000000000 0000000 28 mtime=1776853188.4190000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnLongEnum.h0100644 0000000 0000000 00000001202 15172120304 031573 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/LongEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl */ #error TODO(b/111362593) enums do not have bn classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bn0100644 0000000 0000000 00000000034 15172120304 033201 xustar000000000 0000000 28 mtime=1776853188.4190000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnNamedCallback.h0100644 0000000 0000000 00000003334 15172120304 032520 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/INamedCallback.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { class BnNamedCallback : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_GetName = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; explicit BnNamedCallback(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnNamedCallback class INamedCallbackDelegator : public BnNamedCallback { public: explicit INamedCallbackDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status GetName(::android::String16* _aidl_return) override { return _aidl_delegate->GetName(_aidl_return); } private: ::android::sp _aidl_delegate; }; // class INamedCallbackDelegator } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bn0100644 0000000 0000000 00000000034 15172120304 033201 xustar000000000 0000000 28 mtime=1776853188.4190000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnNewName.h0100644 0000000 0000000 00000003205 15172120304 031406 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/INewName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INewName.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { class BnNewName : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_RealName = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; explicit BnNewName(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnNewName class INewNameDelegator : public BnNewName { public: explicit INewNameDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status RealName(::android::String16* _aidl_return) override { return _aidl_delegate->RealName(_aidl_return); } private: ::android::sp _aidl_delegate; }; // class INewNameDelegator } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bn0100644 0000000 0000000 00000000034 15172120304 033201 xustar000000000 0000000 28 mtime=1776853188.4190000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnOldName.h0100644 0000000 0000000 00000003205 15172120304 031373 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/IOldName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IOldName.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { class BnOldName : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_RealName = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; explicit BnOldName(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnOldName class IOldNameDelegator : public BnOldName { public: explicit IOldNameDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status RealName(::android::String16* _aidl_return) override { return _aidl_delegate->RealName(_aidl_return); } private: ::android::sp _aidl_delegate; }; // class IOldNameDelegator } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bn0100644 0000000 0000000 00000000226 15172120304 033204 xustar000000000 0000000 122 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnOtherParcelableForToString.h 28 mtime=1776853188.4210000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnOtherParcelableF0100644 0000000 0000000 00000001254 15172120304 032772 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/OtherParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bn0100644 0000000 0000000 00000000221 15172120304 033177 xustar000000000 0000000 117 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnParcelableForToString.h 28 mtime=1776853188.4210000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnParcelableForToS0100644 0000000 0000000 00000001242 15172120304 032754 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ParcelableForToString.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bn0100644 0000000 0000000 00000000034 15172120304 033201 xustar000000000 0000000 28 mtime=1776853188.4210000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnRecursiveList.h0100644 0000000 0000000 00000001222 15172120304 032654 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/RecursiveList.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bn0100644 0000000 0000000 00000000220 15172120304 033176 xustar000000000 0000000 116 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnStructuredParcelable.h 28 mtime=1776853188.4210000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnStructuredParcel0100644 0000000 0000000 00000001240 15172120304 033116 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/StructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bn0100644 0000000 0000000 00000000034 15172120304 033201 xustar000000000 0000000 28 mtime=1776853188.4220000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnTestService.h0100644 0000000 0000000 00000066644 15172120304 032334 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ITestService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ITestService.aidl */ #pragma once #include #include #include #include #include #include #include #include #include namespace android { namespace aidl { namespace tests { class BnTestService : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_UnimplementedMethod = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_Deprecated = ::android::IBinder::FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_TestOneway = ::android::IBinder::FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_RepeatBoolean = ::android::IBinder::FIRST_CALL_TRANSACTION + 3; static constexpr uint32_t TRANSACTION_RepeatByte = ::android::IBinder::FIRST_CALL_TRANSACTION + 4; static constexpr uint32_t TRANSACTION_RepeatChar = ::android::IBinder::FIRST_CALL_TRANSACTION + 5; static constexpr uint32_t TRANSACTION_RepeatInt = ::android::IBinder::FIRST_CALL_TRANSACTION + 6; static constexpr uint32_t TRANSACTION_RepeatLong = ::android::IBinder::FIRST_CALL_TRANSACTION + 7; static constexpr uint32_t TRANSACTION_RepeatFloat = ::android::IBinder::FIRST_CALL_TRANSACTION + 8; static constexpr uint32_t TRANSACTION_RepeatDouble = ::android::IBinder::FIRST_CALL_TRANSACTION + 9; static constexpr uint32_t TRANSACTION_RepeatString = ::android::IBinder::FIRST_CALL_TRANSACTION + 10; static constexpr uint32_t TRANSACTION_RepeatByteEnum = ::android::IBinder::FIRST_CALL_TRANSACTION + 11; static constexpr uint32_t TRANSACTION_RepeatIntEnum = ::android::IBinder::FIRST_CALL_TRANSACTION + 12; static constexpr uint32_t TRANSACTION_RepeatLongEnum = ::android::IBinder::FIRST_CALL_TRANSACTION + 13; static constexpr uint32_t TRANSACTION_ReverseBoolean = ::android::IBinder::FIRST_CALL_TRANSACTION + 14; static constexpr uint32_t TRANSACTION_ReverseByte = ::android::IBinder::FIRST_CALL_TRANSACTION + 15; static constexpr uint32_t TRANSACTION_ReverseChar = ::android::IBinder::FIRST_CALL_TRANSACTION + 16; static constexpr uint32_t TRANSACTION_ReverseInt = ::android::IBinder::FIRST_CALL_TRANSACTION + 17; static constexpr uint32_t TRANSACTION_ReverseLong = ::android::IBinder::FIRST_CALL_TRANSACTION + 18; static constexpr uint32_t TRANSACTION_ReverseFloat = ::android::IBinder::FIRST_CALL_TRANSACTION + 19; static constexpr uint32_t TRANSACTION_ReverseDouble = ::android::IBinder::FIRST_CALL_TRANSACTION + 20; static constexpr uint32_t TRANSACTION_ReverseString = ::android::IBinder::FIRST_CALL_TRANSACTION + 21; static constexpr uint32_t TRANSACTION_ReverseByteEnum = ::android::IBinder::FIRST_CALL_TRANSACTION + 22; static constexpr uint32_t TRANSACTION_ReverseIntEnum = ::android::IBinder::FIRST_CALL_TRANSACTION + 23; static constexpr uint32_t TRANSACTION_ReverseLongEnum = ::android::IBinder::FIRST_CALL_TRANSACTION + 24; static constexpr uint32_t TRANSACTION_GetOtherTestService = ::android::IBinder::FIRST_CALL_TRANSACTION + 25; static constexpr uint32_t TRANSACTION_SetOtherTestService = ::android::IBinder::FIRST_CALL_TRANSACTION + 26; static constexpr uint32_t TRANSACTION_VerifyName = ::android::IBinder::FIRST_CALL_TRANSACTION + 27; static constexpr uint32_t TRANSACTION_GetInterfaceArray = ::android::IBinder::FIRST_CALL_TRANSACTION + 28; static constexpr uint32_t TRANSACTION_VerifyNamesWithInterfaceArray = ::android::IBinder::FIRST_CALL_TRANSACTION + 29; static constexpr uint32_t TRANSACTION_GetNullableInterfaceArray = ::android::IBinder::FIRST_CALL_TRANSACTION + 30; static constexpr uint32_t TRANSACTION_VerifyNamesWithNullableInterfaceArray = ::android::IBinder::FIRST_CALL_TRANSACTION + 31; static constexpr uint32_t TRANSACTION_GetInterfaceList = ::android::IBinder::FIRST_CALL_TRANSACTION + 32; static constexpr uint32_t TRANSACTION_VerifyNamesWithInterfaceList = ::android::IBinder::FIRST_CALL_TRANSACTION + 33; static constexpr uint32_t TRANSACTION_ReverseStringList = ::android::IBinder::FIRST_CALL_TRANSACTION + 34; static constexpr uint32_t TRANSACTION_RepeatParcelFileDescriptor = ::android::IBinder::FIRST_CALL_TRANSACTION + 35; static constexpr uint32_t TRANSACTION_ReverseParcelFileDescriptorArray = ::android::IBinder::FIRST_CALL_TRANSACTION + 36; static constexpr uint32_t TRANSACTION_ThrowServiceException = ::android::IBinder::FIRST_CALL_TRANSACTION + 37; static constexpr uint32_t TRANSACTION_RepeatNullableIntArray = ::android::IBinder::FIRST_CALL_TRANSACTION + 38; static constexpr uint32_t TRANSACTION_RepeatNullableByteEnumArray = ::android::IBinder::FIRST_CALL_TRANSACTION + 39; static constexpr uint32_t TRANSACTION_RepeatNullableIntEnumArray = ::android::IBinder::FIRST_CALL_TRANSACTION + 40; static constexpr uint32_t TRANSACTION_RepeatNullableLongEnumArray = ::android::IBinder::FIRST_CALL_TRANSACTION + 41; static constexpr uint32_t TRANSACTION_RepeatNullableString = ::android::IBinder::FIRST_CALL_TRANSACTION + 42; static constexpr uint32_t TRANSACTION_RepeatNullableStringList = ::android::IBinder::FIRST_CALL_TRANSACTION + 43; static constexpr uint32_t TRANSACTION_RepeatNullableParcelable = ::android::IBinder::FIRST_CALL_TRANSACTION + 44; static constexpr uint32_t TRANSACTION_RepeatNullableParcelableArray = ::android::IBinder::FIRST_CALL_TRANSACTION + 45; static constexpr uint32_t TRANSACTION_RepeatNullableParcelableList = ::android::IBinder::FIRST_CALL_TRANSACTION + 46; static constexpr uint32_t TRANSACTION_TakesAnIBinder = ::android::IBinder::FIRST_CALL_TRANSACTION + 47; static constexpr uint32_t TRANSACTION_TakesANullableIBinder = ::android::IBinder::FIRST_CALL_TRANSACTION + 48; static constexpr uint32_t TRANSACTION_TakesAnIBinderList = ::android::IBinder::FIRST_CALL_TRANSACTION + 49; static constexpr uint32_t TRANSACTION_TakesANullableIBinderList = ::android::IBinder::FIRST_CALL_TRANSACTION + 50; static constexpr uint32_t TRANSACTION_RepeatUtf8CppString = ::android::IBinder::FIRST_CALL_TRANSACTION + 51; static constexpr uint32_t TRANSACTION_RepeatNullableUtf8CppString = ::android::IBinder::FIRST_CALL_TRANSACTION + 52; static constexpr uint32_t TRANSACTION_ReverseUtf8CppString = ::android::IBinder::FIRST_CALL_TRANSACTION + 53; static constexpr uint32_t TRANSACTION_ReverseNullableUtf8CppString = ::android::IBinder::FIRST_CALL_TRANSACTION + 54; static constexpr uint32_t TRANSACTION_ReverseUtf8CppStringList = ::android::IBinder::FIRST_CALL_TRANSACTION + 55; static constexpr uint32_t TRANSACTION_GetCallback = ::android::IBinder::FIRST_CALL_TRANSACTION + 56; static constexpr uint32_t TRANSACTION_FillOutStructuredParcelable = ::android::IBinder::FIRST_CALL_TRANSACTION + 57; static constexpr uint32_t TRANSACTION_RepeatExtendableParcelable = ::android::IBinder::FIRST_CALL_TRANSACTION + 58; static constexpr uint32_t TRANSACTION_ReverseList = ::android::IBinder::FIRST_CALL_TRANSACTION + 59; static constexpr uint32_t TRANSACTION_ReverseIBinderArray = ::android::IBinder::FIRST_CALL_TRANSACTION + 60; static constexpr uint32_t TRANSACTION_ReverseNullableIBinderArray = ::android::IBinder::FIRST_CALL_TRANSACTION + 61; static constexpr uint32_t TRANSACTION_RepeatSimpleParcelable = ::android::IBinder::FIRST_CALL_TRANSACTION + 62; static constexpr uint32_t TRANSACTION_ReverseSimpleParcelables = ::android::IBinder::FIRST_CALL_TRANSACTION + 63; static constexpr uint32_t TRANSACTION_GetOldNameInterface = ::android::IBinder::FIRST_CALL_TRANSACTION + 64; static constexpr uint32_t TRANSACTION_GetNewNameInterface = ::android::IBinder::FIRST_CALL_TRANSACTION + 65; static constexpr uint32_t TRANSACTION_GetUnionTags = ::android::IBinder::FIRST_CALL_TRANSACTION + 66; static constexpr uint32_t TRANSACTION_GetCppJavaTests = ::android::IBinder::FIRST_CALL_TRANSACTION + 67; static constexpr uint32_t TRANSACTION_getBackendType = ::android::IBinder::FIRST_CALL_TRANSACTION + 68; static constexpr uint32_t TRANSACTION_GetCircular = ::android::IBinder::FIRST_CALL_TRANSACTION + 69; explicit BnTestService(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnTestService class ITestServiceDelegator : public BnTestService { public: explicit ITestServiceDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status UnimplementedMethod(int32_t arg, int32_t* _aidl_return) override { return _aidl_delegate->UnimplementedMethod(arg, _aidl_return); } ::android::binder::Status Deprecated() override __attribute__((deprecated("to make sure we have something in system/tools/aidl which does a compile check of deprecated and make sure this is reflected in goldens"))) { return _aidl_delegate->Deprecated(); } ::android::binder::Status TestOneway() override { return _aidl_delegate->TestOneway(); } ::android::binder::Status RepeatBoolean(bool token, bool* _aidl_return) override { return _aidl_delegate->RepeatBoolean(token, _aidl_return); } ::android::binder::Status RepeatByte(int8_t token, int8_t* _aidl_return) override { return _aidl_delegate->RepeatByte(token, _aidl_return); } ::android::binder::Status RepeatChar(char16_t token, char16_t* _aidl_return) override { return _aidl_delegate->RepeatChar(token, _aidl_return); } ::android::binder::Status RepeatInt(int32_t token, int32_t* _aidl_return) override { return _aidl_delegate->RepeatInt(token, _aidl_return); } ::android::binder::Status RepeatLong(int64_t token, int64_t* _aidl_return) override { return _aidl_delegate->RepeatLong(token, _aidl_return); } ::android::binder::Status RepeatFloat(float token, float* _aidl_return) override { return _aidl_delegate->RepeatFloat(token, _aidl_return); } ::android::binder::Status RepeatDouble(double token, double* _aidl_return) override { return _aidl_delegate->RepeatDouble(token, _aidl_return); } ::android::binder::Status RepeatString(const ::android::String16& token, ::android::String16* _aidl_return) override { return _aidl_delegate->RepeatString(token, _aidl_return); } ::android::binder::Status RepeatByteEnum(::android::aidl::tests::ByteEnum token, ::android::aidl::tests::ByteEnum* _aidl_return) override { return _aidl_delegate->RepeatByteEnum(token, _aidl_return); } ::android::binder::Status RepeatIntEnum(::android::aidl::tests::IntEnum token, ::android::aidl::tests::IntEnum* _aidl_return) override { return _aidl_delegate->RepeatIntEnum(token, _aidl_return); } ::android::binder::Status RepeatLongEnum(::android::aidl::tests::LongEnum token, ::android::aidl::tests::LongEnum* _aidl_return) override { return _aidl_delegate->RepeatLongEnum(token, _aidl_return); } ::android::binder::Status ReverseBoolean(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) override { return _aidl_delegate->ReverseBoolean(input, repeated, _aidl_return); } ::android::binder::Status ReverseByte(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) override { return _aidl_delegate->ReverseByte(input, repeated, _aidl_return); } ::android::binder::Status ReverseChar(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) override { return _aidl_delegate->ReverseChar(input, repeated, _aidl_return); } ::android::binder::Status ReverseInt(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) override { return _aidl_delegate->ReverseInt(input, repeated, _aidl_return); } ::android::binder::Status ReverseLong(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) override { return _aidl_delegate->ReverseLong(input, repeated, _aidl_return); } ::android::binder::Status ReverseFloat(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) override { return _aidl_delegate->ReverseFloat(input, repeated, _aidl_return); } ::android::binder::Status ReverseDouble(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) override { return _aidl_delegate->ReverseDouble(input, repeated, _aidl_return); } ::android::binder::Status ReverseString(const ::std::vector<::android::String16>& input, ::std::vector<::android::String16>* repeated, ::std::vector<::android::String16>* _aidl_return) override { return _aidl_delegate->ReverseString(input, repeated, _aidl_return); } ::android::binder::Status ReverseByteEnum(const ::std::vector<::android::aidl::tests::ByteEnum>& input, ::std::vector<::android::aidl::tests::ByteEnum>* repeated, ::std::vector<::android::aidl::tests::ByteEnum>* _aidl_return) override { return _aidl_delegate->ReverseByteEnum(input, repeated, _aidl_return); } ::android::binder::Status ReverseIntEnum(const ::std::vector<::android::aidl::tests::IntEnum>& input, ::std::vector<::android::aidl::tests::IntEnum>* repeated, ::std::vector<::android::aidl::tests::IntEnum>* _aidl_return) override { return _aidl_delegate->ReverseIntEnum(input, repeated, _aidl_return); } ::android::binder::Status ReverseLongEnum(const ::std::vector<::android::aidl::tests::LongEnum>& input, ::std::vector<::android::aidl::tests::LongEnum>* repeated, ::std::vector<::android::aidl::tests::LongEnum>* _aidl_return) override { return _aidl_delegate->ReverseLongEnum(input, repeated, _aidl_return); } ::android::binder::Status GetOtherTestService(const ::android::String16& name, ::android::sp<::android::aidl::tests::INamedCallback>* _aidl_return) override { auto _status = _aidl_delegate->GetOtherTestService(name, _aidl_return); if (*_aidl_return) { *_aidl_return = ::android::sp<::android::aidl::tests::INamedCallbackDelegator>::cast(delegate(*_aidl_return)); } return _status; } ::android::binder::Status SetOtherTestService(const ::android::String16& name, const ::android::sp<::android::aidl::tests::INamedCallback>& service, bool* _aidl_return) override { ::android::sp<::android::aidl::tests::INamedCallbackDelegator> _service; if (service) { _service = ::android::sp<::android::aidl::tests::INamedCallbackDelegator>::cast(delegate(service)); } return _aidl_delegate->SetOtherTestService(name, _service, _aidl_return); } ::android::binder::Status VerifyName(const ::android::sp<::android::aidl::tests::INamedCallback>& service, const ::android::String16& name, bool* _aidl_return) override { ::android::sp<::android::aidl::tests::INamedCallbackDelegator> _service; if (service) { _service = ::android::sp<::android::aidl::tests::INamedCallbackDelegator>::cast(delegate(service)); } return _aidl_delegate->VerifyName(_service, name, _aidl_return); } ::android::binder::Status GetInterfaceArray(const ::std::vector<::android::String16>& names, ::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>* _aidl_return) override { return _aidl_delegate->GetInterfaceArray(names, _aidl_return); } ::android::binder::Status VerifyNamesWithInterfaceArray(const ::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>& services, const ::std::vector<::android::String16>& names, bool* _aidl_return) override { return _aidl_delegate->VerifyNamesWithInterfaceArray(services, names, _aidl_return); } ::android::binder::Status GetNullableInterfaceArray(const ::std::optional<::std::vector<::std::optional<::android::String16>>>& names, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>* _aidl_return) override { return _aidl_delegate->GetNullableInterfaceArray(names, _aidl_return); } ::android::binder::Status VerifyNamesWithNullableInterfaceArray(const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>& services, const ::std::optional<::std::vector<::std::optional<::android::String16>>>& names, bool* _aidl_return) override { return _aidl_delegate->VerifyNamesWithNullableInterfaceArray(services, names, _aidl_return); } ::android::binder::Status GetInterfaceList(const ::std::optional<::std::vector<::std::optional<::android::String16>>>& names, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>* _aidl_return) override { return _aidl_delegate->GetInterfaceList(names, _aidl_return); } ::android::binder::Status VerifyNamesWithInterfaceList(const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>& services, const ::std::optional<::std::vector<::std::optional<::android::String16>>>& names, bool* _aidl_return) override { return _aidl_delegate->VerifyNamesWithInterfaceList(services, names, _aidl_return); } ::android::binder::Status ReverseStringList(const ::std::vector<::android::String16>& input, ::std::vector<::android::String16>* repeated, ::std::vector<::android::String16>* _aidl_return) override { return _aidl_delegate->ReverseStringList(input, repeated, _aidl_return); } ::android::binder::Status RepeatParcelFileDescriptor(const ::android::os::ParcelFileDescriptor& read, ::android::os::ParcelFileDescriptor* _aidl_return) override { return _aidl_delegate->RepeatParcelFileDescriptor(read, _aidl_return); } ::android::binder::Status ReverseParcelFileDescriptorArray(const ::std::vector<::android::os::ParcelFileDescriptor>& input, ::std::vector<::android::os::ParcelFileDescriptor>* repeated, ::std::vector<::android::os::ParcelFileDescriptor>* _aidl_return) override { return _aidl_delegate->ReverseParcelFileDescriptorArray(input, repeated, _aidl_return); } ::android::binder::Status ThrowServiceException(int32_t code) override { return _aidl_delegate->ThrowServiceException(code); } ::android::binder::Status RepeatNullableIntArray(const ::std::optional<::std::vector>& input, ::std::optional<::std::vector>* _aidl_return) override { return _aidl_delegate->RepeatNullableIntArray(input, _aidl_return); } ::android::binder::Status RepeatNullableByteEnumArray(const ::std::optional<::std::vector<::android::aidl::tests::ByteEnum>>& input, ::std::optional<::std::vector<::android::aidl::tests::ByteEnum>>* _aidl_return) override { return _aidl_delegate->RepeatNullableByteEnumArray(input, _aidl_return); } ::android::binder::Status RepeatNullableIntEnumArray(const ::std::optional<::std::vector<::android::aidl::tests::IntEnum>>& input, ::std::optional<::std::vector<::android::aidl::tests::IntEnum>>* _aidl_return) override { return _aidl_delegate->RepeatNullableIntEnumArray(input, _aidl_return); } ::android::binder::Status RepeatNullableLongEnumArray(const ::std::optional<::std::vector<::android::aidl::tests::LongEnum>>& input, ::std::optional<::std::vector<::android::aidl::tests::LongEnum>>* _aidl_return) override { return _aidl_delegate->RepeatNullableLongEnumArray(input, _aidl_return); } ::android::binder::Status RepeatNullableString(const ::std::optional<::android::String16>& input, ::std::optional<::android::String16>* _aidl_return) override { return _aidl_delegate->RepeatNullableString(input, _aidl_return); } ::android::binder::Status RepeatNullableStringList(const ::std::optional<::std::vector<::std::optional<::android::String16>>>& input, ::std::optional<::std::vector<::std::optional<::android::String16>>>* _aidl_return) override { return _aidl_delegate->RepeatNullableStringList(input, _aidl_return); } ::android::binder::Status RepeatNullableParcelable(const ::std::optional<::android::aidl::tests::ITestService::Empty>& input, ::std::optional<::android::aidl::tests::ITestService::Empty>* _aidl_return) override { return _aidl_delegate->RepeatNullableParcelable(input, _aidl_return); } ::android::binder::Status RepeatNullableParcelableArray(const ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>& input, ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>* _aidl_return) override { return _aidl_delegate->RepeatNullableParcelableArray(input, _aidl_return); } ::android::binder::Status RepeatNullableParcelableList(const ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>& input, ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>* _aidl_return) override { return _aidl_delegate->RepeatNullableParcelableList(input, _aidl_return); } ::android::binder::Status TakesAnIBinder(const ::android::sp<::android::IBinder>& input) override { return _aidl_delegate->TakesAnIBinder(input); } ::android::binder::Status TakesANullableIBinder(const ::android::sp<::android::IBinder>& input) override { return _aidl_delegate->TakesANullableIBinder(input); } ::android::binder::Status TakesAnIBinderList(const ::std::vector<::android::sp<::android::IBinder>>& input) override { return _aidl_delegate->TakesAnIBinderList(input); } ::android::binder::Status TakesANullableIBinderList(const ::std::optional<::std::vector<::android::sp<::android::IBinder>>>& input) override { return _aidl_delegate->TakesANullableIBinderList(input); } ::android::binder::Status RepeatUtf8CppString(const ::std::string& token, ::std::string* _aidl_return) override { return _aidl_delegate->RepeatUtf8CppString(token, _aidl_return); } ::android::binder::Status RepeatNullableUtf8CppString(const ::std::optional<::std::string>& token, ::std::optional<::std::string>* _aidl_return) override { return _aidl_delegate->RepeatNullableUtf8CppString(token, _aidl_return); } ::android::binder::Status ReverseUtf8CppString(const ::std::vector<::std::string>& input, ::std::vector<::std::string>* repeated, ::std::vector<::std::string>* _aidl_return) override { return _aidl_delegate->ReverseUtf8CppString(input, repeated, _aidl_return); } ::android::binder::Status ReverseNullableUtf8CppString(const ::std::optional<::std::vector<::std::optional<::std::string>>>& input, ::std::optional<::std::vector<::std::optional<::std::string>>>* repeated, ::std::optional<::std::vector<::std::optional<::std::string>>>* _aidl_return) override { return _aidl_delegate->ReverseNullableUtf8CppString(input, repeated, _aidl_return); } ::android::binder::Status ReverseUtf8CppStringList(const ::std::optional<::std::vector<::std::optional<::std::string>>>& input, ::std::optional<::std::vector<::std::optional<::std::string>>>* repeated, ::std::optional<::std::vector<::std::optional<::std::string>>>* _aidl_return) override { return _aidl_delegate->ReverseUtf8CppStringList(input, repeated, _aidl_return); } ::android::binder::Status GetCallback(bool return_null, ::android::sp<::android::aidl::tests::INamedCallback>* _aidl_return) override { auto _status = _aidl_delegate->GetCallback(return_null, _aidl_return); if (*_aidl_return) { *_aidl_return = ::android::sp<::android::aidl::tests::INamedCallbackDelegator>::cast(delegate(*_aidl_return)); } return _status; } ::android::binder::Status FillOutStructuredParcelable(::android::aidl::tests::StructuredParcelable* parcel) override { return _aidl_delegate->FillOutStructuredParcelable(parcel); } ::android::binder::Status RepeatExtendableParcelable(const ::android::aidl::tests::extension::ExtendableParcelable& ep, ::android::aidl::tests::extension::ExtendableParcelable* ep2) override { return _aidl_delegate->RepeatExtendableParcelable(ep, ep2); } ::android::binder::Status ReverseList(const ::android::aidl::tests::RecursiveList& list, ::android::aidl::tests::RecursiveList* _aidl_return) override { return _aidl_delegate->ReverseList(list, _aidl_return); } ::android::binder::Status ReverseIBinderArray(const ::std::vector<::android::sp<::android::IBinder>>& input, ::std::vector<::android::sp<::android::IBinder>>* repeated, ::std::vector<::android::sp<::android::IBinder>>* _aidl_return) override { return _aidl_delegate->ReverseIBinderArray(input, repeated, _aidl_return); } ::android::binder::Status ReverseNullableIBinderArray(const ::std::optional<::std::vector<::android::sp<::android::IBinder>>>& input, ::std::optional<::std::vector<::android::sp<::android::IBinder>>>* repeated, ::std::optional<::std::vector<::android::sp<::android::IBinder>>>* _aidl_return) override { return _aidl_delegate->ReverseNullableIBinderArray(input, repeated, _aidl_return); } ::android::binder::Status RepeatSimpleParcelable(const ::android::aidl::tests::SimpleParcelable& input, ::android::aidl::tests::SimpleParcelable* repeat, ::android::aidl::tests::SimpleParcelable* _aidl_return) override { return _aidl_delegate->RepeatSimpleParcelable(input, repeat, _aidl_return); } ::android::binder::Status ReverseSimpleParcelables(const ::std::vector<::android::aidl::tests::SimpleParcelable>& input, ::std::vector<::android::aidl::tests::SimpleParcelable>* repeated, ::std::vector<::android::aidl::tests::SimpleParcelable>* _aidl_return) override { return _aidl_delegate->ReverseSimpleParcelables(input, repeated, _aidl_return); } ::android::binder::Status GetOldNameInterface(::android::sp<::android::aidl::tests::IOldName>* _aidl_return) override { auto _status = _aidl_delegate->GetOldNameInterface(_aidl_return); if (*_aidl_return) { *_aidl_return = ::android::sp<::android::aidl::tests::IOldNameDelegator>::cast(delegate(*_aidl_return)); } return _status; } ::android::binder::Status GetNewNameInterface(::android::sp<::android::aidl::tests::INewName>* _aidl_return) override { auto _status = _aidl_delegate->GetNewNameInterface(_aidl_return); if (*_aidl_return) { *_aidl_return = ::android::sp<::android::aidl::tests::INewNameDelegator>::cast(delegate(*_aidl_return)); } return _status; } ::android::binder::Status GetUnionTags(const ::std::vector<::android::aidl::tests::Union>& input, ::std::vector<::android::aidl::tests::Union::Tag>* _aidl_return) override { return _aidl_delegate->GetUnionTags(input, _aidl_return); } ::android::binder::Status GetCppJavaTests(::android::sp<::android::IBinder>* _aidl_return) override { return _aidl_delegate->GetCppJavaTests(_aidl_return); } ::android::binder::Status getBackendType(::android::aidl::tests::BackendType* _aidl_return) override { return _aidl_delegate->getBackendType(_aidl_return); } ::android::binder::Status GetCircular(::android::aidl::tests::CircularParcelable* cp, ::android::sp<::android::aidl::tests::ICircular>* _aidl_return) override { auto _status = _aidl_delegate->GetCircular(cp, _aidl_return); if (*_aidl_return) { *_aidl_return = ::android::sp<::android::aidl::tests::ICircularDelegator>::cast(delegate(*_aidl_return)); } return _status; } private: ::android::sp _aidl_delegate; }; // class ITestServiceDelegator } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bn0100644 0000000 0000000 00000000034 15172120304 033201 xustar000000000 0000000 28 mtime=1776853188.4220000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnUnion.h0100644 0000000 0000000 00000001202 15172120304 031137 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/Union.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/Union.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bn0100644 0000000 0000000 00000000034 15172120304 033201 xustar000000000 0000000 28 mtime=1776853188.4220000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnUnionWithFd.h0100644 0000000 0000000 00000001216 15172120304 032252 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/UnionWithFd.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/UnionWithFd.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bp0100644 0000000 0000000 00000000215 15172120304 033204 xustar000000000 0000000 113 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpArrayOfInterfaces.h 28 mtime=1776853188.4220000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpArrayOfInterface0100644 0000000 0000000 00000001232 15172120304 033012 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ArrayOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ArrayOfInterfaces.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bp0100644 0000000 0000000 00000000034 15172120304 033203 xustar000000000 0000000 28 mtime=1776853188.4220000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpBackendType.h0100644 0000000 0000000 00000001210 15172120304 032241 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/BackendType.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/BackendType.aidl */ #error TODO(b/111362593) enums do not have bp classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bp0100644 0000000 0000000 00000000034 15172120304 033203 xustar000000000 0000000 28 mtime=1776853188.4220000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpByteEnum.h0100644 0000000 0000000 00000001202 15172120304 031601 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ByteEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl */ #error TODO(b/111362593) enums do not have bp classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bp0100644 0000000 0000000 00000000034 15172120304 033203 xustar000000000 0000000 28 mtime=1776853188.4220000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpCircular.h0100644 0000000 0000000 00000002234 15172120304 031623 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ICircular.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ICircular.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { class BpCircular : public ::android::BpInterface { public: explicit BpCircular(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpCircular() = default; ::android::binder::Status GetTestService(::android::sp<::android::aidl::tests::ITestService>* _aidl_return) override; }; // class BpCircular } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bp0100644 0000000 0000000 00000000216 15172120304 033205 xustar000000000 0000000 114 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpCircularParcelable.h 28 mtime=1776853188.4220000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpCircularParcelab0100644 0000000 0000000 00000001234 15172120304 033026 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/CircularParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bp0100644 0000000 0000000 00000000222 15172120304 033202 xustar000000000 0000000 118 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpConstantExpressionEnum.h 28 mtime=1776853188.4220000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpConstantExpressi0100644 0000000 0000000 00000001236 15172120304 033146 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ConstantExpressionEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl */ #error TODO(b/111362593) enums do not have bp classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bp0100644 0000000 0000000 00000000034 15172120304 033203 xustar000000000 0000000 28 mtime=1776853188.4220000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpDeprecated.h0100644 0000000 0000000 00000002130 15172120304 032112 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/IDeprecated.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IDeprecated.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { class __attribute__((deprecated("test"))) BpDeprecated : public ::android::BpInterface { public: explicit BpDeprecated(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpDeprecated() = default; }; // class BpDeprecated } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bp0100644 0000000 0000000 00000000212 15172120304 033201 xustar000000000 0000000 110 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpDeprecatedEnum.h 28 mtime=1776853188.4220000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpDeprecatedEnum.h0100644 0000000 0000000 00000001216 15172120304 032743 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/DeprecatedEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedEnum.aidl */ #error TODO(b/111362593) enums do not have bp classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bp0100644 0000000 0000000 00000000220 15172120304 033200 xustar000000000 0000000 116 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpDeprecatedParcelable.h 28 mtime=1776853188.4220000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpDeprecatedParcel0100644 0000000 0000000 00000001240 15172120304 033014 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/DeprecatedParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedParcelable.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bp0100644 0000000 0000000 00000000034 15172120304 033203 xustar000000000 0000000 28 mtime=1776853188.4220000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpFixedSize.h0100644 0000000 0000000 00000001212 15172120304 031744 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/FixedSize.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/FixedSize.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bp0100644 0000000 0000000 00000000227 15172120304 033207 xustar000000000 0000000 123 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpGenericStructuredParcelable.h 28 mtime=1776853188.4220000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpGenericStructure0100644 0000000 0000000 00000001256 15172120304 033131 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/GenericStructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bp0100644 0000000 0000000 00000000034 15172120304 033203 xustar000000000 0000000 28 mtime=1776853188.4230000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpIntEnum.h0100644 0000000 0000000 00000001200 15172120304 031426 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/IntEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl */ #error TODO(b/111362593) enums do not have bp classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bp0100644 0000000 0000000 00000000214 15172120304 033203 xustar000000000 0000000 112 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpListOfInterfaces.h 28 mtime=1776853188.4230000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpListOfInterfaces0100644 0000000 0000000 00000001230 15172120304 033030 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ListOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ListOfInterfaces.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bp0100644 0000000 0000000 00000000034 15172120304 033203 xustar000000000 0000000 28 mtime=1776853188.4230000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpLongEnum.h0100644 0000000 0000000 00000001202 15172120304 031575 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/LongEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl */ #error TODO(b/111362593) enums do not have bp classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bp0100644 0000000 0000000 00000000034 15172120304 033203 xustar000000000 0000000 28 mtime=1776853188.4230000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpNamedCallback.h0100644 0000000 0000000 00000002235 15172120304 032521 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/INamedCallback.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { class BpNamedCallback : public ::android::BpInterface { public: explicit BpNamedCallback(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpNamedCallback() = default; ::android::binder::Status GetName(::android::String16* _aidl_return) override; }; // class BpNamedCallback } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bp0100644 0000000 0000000 00000000034 15172120304 033203 xustar000000000 0000000 28 mtime=1776853188.4240000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpNewName.h0100644 0000000 0000000 00000002156 15172120304 031414 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/INewName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INewName.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { class BpNewName : public ::android::BpInterface { public: explicit BpNewName(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpNewName() = default; ::android::binder::Status RealName(::android::String16* _aidl_return) override; }; // class BpNewName } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bp0100644 0000000 0000000 00000000034 15172120304 033203 xustar000000000 0000000 28 mtime=1776853188.4250000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpOldName.h0100644 0000000 0000000 00000002156 15172120304 031401 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/IOldName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IOldName.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { class BpOldName : public ::android::BpInterface { public: explicit BpOldName(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpOldName() = default; ::android::binder::Status RealName(::android::String16* _aidl_return) override; }; // class BpOldName } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bp0100644 0000000 0000000 00000000226 15172120304 033206 xustar000000000 0000000 122 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpOtherParcelableForToString.h 28 mtime=1776853188.4250000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpOtherParcelableF0100644 0000000 0000000 00000001254 15172120304 032774 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/OtherParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bp0100644 0000000 0000000 00000000221 15172120304 033201 xustar000000000 0000000 117 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpParcelableForToString.h 28 mtime=1776853188.4250000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpParcelableForToS0100644 0000000 0000000 00000001242 15172120304 032756 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ParcelableForToString.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bp0100644 0000000 0000000 00000000034 15172120304 033203 xustar000000000 0000000 28 mtime=1776853188.4250000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpRecursiveList.h0100644 0000000 0000000 00000001222 15172120304 032656 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/RecursiveList.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bp0100644 0000000 0000000 00000000220 15172120304 033200 xustar000000000 0000000 116 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpStructuredParcelable.h 28 mtime=1776853188.4250000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpStructuredParcel0100644 0000000 0000000 00000001240 15172120304 033120 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/StructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bp0100644 0000000 0000000 00000000034 15172120304 033203 xustar000000000 0000000 28 mtime=1776853188.4250000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpTestService.h0100644 0000000 0000000 00000031663 15172120304 032327 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ITestService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ITestService.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { class BpTestService : public ::android::BpInterface { public: explicit BpTestService(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpTestService() = default; ::android::binder::Status UnimplementedMethod(int32_t arg, int32_t* _aidl_return) override; ::android::binder::Status Deprecated() override __attribute__((deprecated("to make sure we have something in system/tools/aidl which does a compile check of deprecated and make sure this is reflected in goldens"))); ::android::binder::Status TestOneway() override; ::android::binder::Status RepeatBoolean(bool token, bool* _aidl_return) override; ::android::binder::Status RepeatByte(int8_t token, int8_t* _aidl_return) override; ::android::binder::Status RepeatChar(char16_t token, char16_t* _aidl_return) override; ::android::binder::Status RepeatInt(int32_t token, int32_t* _aidl_return) override; ::android::binder::Status RepeatLong(int64_t token, int64_t* _aidl_return) override; ::android::binder::Status RepeatFloat(float token, float* _aidl_return) override; ::android::binder::Status RepeatDouble(double token, double* _aidl_return) override; ::android::binder::Status RepeatString(const ::android::String16& token, ::android::String16* _aidl_return) override; ::android::binder::Status RepeatByteEnum(::android::aidl::tests::ByteEnum token, ::android::aidl::tests::ByteEnum* _aidl_return) override; ::android::binder::Status RepeatIntEnum(::android::aidl::tests::IntEnum token, ::android::aidl::tests::IntEnum* _aidl_return) override; ::android::binder::Status RepeatLongEnum(::android::aidl::tests::LongEnum token, ::android::aidl::tests::LongEnum* _aidl_return) override; ::android::binder::Status ReverseBoolean(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) override; ::android::binder::Status ReverseByte(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) override; ::android::binder::Status ReverseChar(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) override; ::android::binder::Status ReverseInt(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) override; ::android::binder::Status ReverseLong(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) override; ::android::binder::Status ReverseFloat(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) override; ::android::binder::Status ReverseDouble(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) override; ::android::binder::Status ReverseString(const ::std::vector<::android::String16>& input, ::std::vector<::android::String16>* repeated, ::std::vector<::android::String16>* _aidl_return) override; ::android::binder::Status ReverseByteEnum(const ::std::vector<::android::aidl::tests::ByteEnum>& input, ::std::vector<::android::aidl::tests::ByteEnum>* repeated, ::std::vector<::android::aidl::tests::ByteEnum>* _aidl_return) override; ::android::binder::Status ReverseIntEnum(const ::std::vector<::android::aidl::tests::IntEnum>& input, ::std::vector<::android::aidl::tests::IntEnum>* repeated, ::std::vector<::android::aidl::tests::IntEnum>* _aidl_return) override; ::android::binder::Status ReverseLongEnum(const ::std::vector<::android::aidl::tests::LongEnum>& input, ::std::vector<::android::aidl::tests::LongEnum>* repeated, ::std::vector<::android::aidl::tests::LongEnum>* _aidl_return) override; ::android::binder::Status GetOtherTestService(const ::android::String16& name, ::android::sp<::android::aidl::tests::INamedCallback>* _aidl_return) override; ::android::binder::Status SetOtherTestService(const ::android::String16& name, const ::android::sp<::android::aidl::tests::INamedCallback>& service, bool* _aidl_return) override; ::android::binder::Status VerifyName(const ::android::sp<::android::aidl::tests::INamedCallback>& service, const ::android::String16& name, bool* _aidl_return) override; ::android::binder::Status GetInterfaceArray(const ::std::vector<::android::String16>& names, ::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>* _aidl_return) override; ::android::binder::Status VerifyNamesWithInterfaceArray(const ::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>& services, const ::std::vector<::android::String16>& names, bool* _aidl_return) override; ::android::binder::Status GetNullableInterfaceArray(const ::std::optional<::std::vector<::std::optional<::android::String16>>>& names, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>* _aidl_return) override; ::android::binder::Status VerifyNamesWithNullableInterfaceArray(const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>& services, const ::std::optional<::std::vector<::std::optional<::android::String16>>>& names, bool* _aidl_return) override; ::android::binder::Status GetInterfaceList(const ::std::optional<::std::vector<::std::optional<::android::String16>>>& names, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>* _aidl_return) override; ::android::binder::Status VerifyNamesWithInterfaceList(const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>& services, const ::std::optional<::std::vector<::std::optional<::android::String16>>>& names, bool* _aidl_return) override; ::android::binder::Status ReverseStringList(const ::std::vector<::android::String16>& input, ::std::vector<::android::String16>* repeated, ::std::vector<::android::String16>* _aidl_return) override; ::android::binder::Status RepeatParcelFileDescriptor(const ::android::os::ParcelFileDescriptor& read, ::android::os::ParcelFileDescriptor* _aidl_return) override; ::android::binder::Status ReverseParcelFileDescriptorArray(const ::std::vector<::android::os::ParcelFileDescriptor>& input, ::std::vector<::android::os::ParcelFileDescriptor>* repeated, ::std::vector<::android::os::ParcelFileDescriptor>* _aidl_return) override; ::android::binder::Status ThrowServiceException(int32_t code) override; ::android::binder::Status RepeatNullableIntArray(const ::std::optional<::std::vector>& input, ::std::optional<::std::vector>* _aidl_return) override; ::android::binder::Status RepeatNullableByteEnumArray(const ::std::optional<::std::vector<::android::aidl::tests::ByteEnum>>& input, ::std::optional<::std::vector<::android::aidl::tests::ByteEnum>>* _aidl_return) override; ::android::binder::Status RepeatNullableIntEnumArray(const ::std::optional<::std::vector<::android::aidl::tests::IntEnum>>& input, ::std::optional<::std::vector<::android::aidl::tests::IntEnum>>* _aidl_return) override; ::android::binder::Status RepeatNullableLongEnumArray(const ::std::optional<::std::vector<::android::aidl::tests::LongEnum>>& input, ::std::optional<::std::vector<::android::aidl::tests::LongEnum>>* _aidl_return) override; ::android::binder::Status RepeatNullableString(const ::std::optional<::android::String16>& input, ::std::optional<::android::String16>* _aidl_return) override; ::android::binder::Status RepeatNullableStringList(const ::std::optional<::std::vector<::std::optional<::android::String16>>>& input, ::std::optional<::std::vector<::std::optional<::android::String16>>>* _aidl_return) override; ::android::binder::Status RepeatNullableParcelable(const ::std::optional<::android::aidl::tests::ITestService::Empty>& input, ::std::optional<::android::aidl::tests::ITestService::Empty>* _aidl_return) override; ::android::binder::Status RepeatNullableParcelableArray(const ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>& input, ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>* _aidl_return) override; ::android::binder::Status RepeatNullableParcelableList(const ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>& input, ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>* _aidl_return) override; ::android::binder::Status TakesAnIBinder(const ::android::sp<::android::IBinder>& input) override; ::android::binder::Status TakesANullableIBinder(const ::android::sp<::android::IBinder>& input) override; ::android::binder::Status TakesAnIBinderList(const ::std::vector<::android::sp<::android::IBinder>>& input) override; ::android::binder::Status TakesANullableIBinderList(const ::std::optional<::std::vector<::android::sp<::android::IBinder>>>& input) override; ::android::binder::Status RepeatUtf8CppString(const ::std::string& token, ::std::string* _aidl_return) override; ::android::binder::Status RepeatNullableUtf8CppString(const ::std::optional<::std::string>& token, ::std::optional<::std::string>* _aidl_return) override; ::android::binder::Status ReverseUtf8CppString(const ::std::vector<::std::string>& input, ::std::vector<::std::string>* repeated, ::std::vector<::std::string>* _aidl_return) override; ::android::binder::Status ReverseNullableUtf8CppString(const ::std::optional<::std::vector<::std::optional<::std::string>>>& input, ::std::optional<::std::vector<::std::optional<::std::string>>>* repeated, ::std::optional<::std::vector<::std::optional<::std::string>>>* _aidl_return) override; ::android::binder::Status ReverseUtf8CppStringList(const ::std::optional<::std::vector<::std::optional<::std::string>>>& input, ::std::optional<::std::vector<::std::optional<::std::string>>>* repeated, ::std::optional<::std::vector<::std::optional<::std::string>>>* _aidl_return) override; ::android::binder::Status GetCallback(bool return_null, ::android::sp<::android::aidl::tests::INamedCallback>* _aidl_return) override; ::android::binder::Status FillOutStructuredParcelable(::android::aidl::tests::StructuredParcelable* parcel) override; ::android::binder::Status RepeatExtendableParcelable(const ::android::aidl::tests::extension::ExtendableParcelable& ep, ::android::aidl::tests::extension::ExtendableParcelable* ep2) override; ::android::binder::Status ReverseList(const ::android::aidl::tests::RecursiveList& list, ::android::aidl::tests::RecursiveList* _aidl_return) override; ::android::binder::Status ReverseIBinderArray(const ::std::vector<::android::sp<::android::IBinder>>& input, ::std::vector<::android::sp<::android::IBinder>>* repeated, ::std::vector<::android::sp<::android::IBinder>>* _aidl_return) override; ::android::binder::Status ReverseNullableIBinderArray(const ::std::optional<::std::vector<::android::sp<::android::IBinder>>>& input, ::std::optional<::std::vector<::android::sp<::android::IBinder>>>* repeated, ::std::optional<::std::vector<::android::sp<::android::IBinder>>>* _aidl_return) override; ::android::binder::Status RepeatSimpleParcelable(const ::android::aidl::tests::SimpleParcelable& input, ::android::aidl::tests::SimpleParcelable* repeat, ::android::aidl::tests::SimpleParcelable* _aidl_return) override; ::android::binder::Status ReverseSimpleParcelables(const ::std::vector<::android::aidl::tests::SimpleParcelable>& input, ::std::vector<::android::aidl::tests::SimpleParcelable>* repeated, ::std::vector<::android::aidl::tests::SimpleParcelable>* _aidl_return) override; ::android::binder::Status GetOldNameInterface(::android::sp<::android::aidl::tests::IOldName>* _aidl_return) override; ::android::binder::Status GetNewNameInterface(::android::sp<::android::aidl::tests::INewName>* _aidl_return) override; ::android::binder::Status GetUnionTags(const ::std::vector<::android::aidl::tests::Union>& input, ::std::vector<::android::aidl::tests::Union::Tag>* _aidl_return) override; ::android::binder::Status GetCppJavaTests(::android::sp<::android::IBinder>* _aidl_return) override; ::android::binder::Status getBackendType(::android::aidl::tests::BackendType* _aidl_return) override; ::android::binder::Status GetCircular(::android::aidl::tests::CircularParcelable* cp, ::android::sp<::android::aidl::tests::ICircular>* _aidl_return) override; }; // class BpTestService } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bp0100644 0000000 0000000 00000000034 15172120304 033203 xustar000000000 0000000 28 mtime=1776853188.4250000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpUnion.h0100644 0000000 0000000 00000001202 15172120304 031141 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/Union.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/Union.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Bp0100644 0000000 0000000 00000000034 15172120304 033203 xustar000000000 0000000 28 mtime=1776853188.4250000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpUnionWithFd.h0100644 0000000 0000000 00000001216 15172120304 032254 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/UnionWithFd.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/UnionWithFd.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_By0100644 0000000 0000000 00000000034 15172120304 033214 xustar000000000 0000000 28 mtime=1776853188.4250000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/ByteEnum.h0100644 0000000 0000000 00000003272 15172120304 031330 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ByteEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { enum class ByteEnum : int8_t { FOO = 1, BAR = 2, BAZ = 3, }; } // namespace tests } // namespace aidl } // namespace android namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(ByteEnum val) { switch(val) { case ByteEnum::FOO: return "FOO"; case ByteEnum::BAR: return "BAR"; case ByteEnum::BAZ: return "BAZ"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::tests::ByteEnum, 3> enum_values<::android::aidl::tests::ByteEnum> = { ::android::aidl::tests::ByteEnum::FOO, ::android::aidl::tests::ByteEnum::BAR, ::android::aidl::tests::ByteEnum::BAZ, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Ci0100644 0000000 0000000 00000000214 15172120304 033175 xustar000000000 0000000 112 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/CircularParcelable.h 28 mtime=1776853188.4260000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/CircularParcelable0100644 0000000 0000000 00000004622 15172120304 033071 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/CircularParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl */ #pragma once #include #include #include #include #include #include #include namespace android::aidl::tests { class ITestService; } // namespace android::aidl::tests namespace android { namespace aidl { namespace tests { class CircularParcelable : public ::android::Parcelable { public: ::android::sp<::android::aidl::tests::ITestService> testService; inline bool operator==(const CircularParcelable& _rhs) const { return std::tie(testService) == std::tie(_rhs.testService); } inline bool operator<(const CircularParcelable& _rhs) const { return std::tie(testService) < std::tie(_rhs.testService); } inline bool operator!=(const CircularParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const CircularParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const CircularParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const CircularParcelable& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.CircularParcelable"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "CircularParcelable{"; _aidl_os << "testService: " << ::android::internal::ToString(testService); _aidl_os << "}"; return _aidl_os.str(); } }; // class CircularParcelable } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Co0100644 0000000 0000000 00000000220 15172120304 033200 xustar000000000 0000000 116 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/ConstantExpressionEnum.h 28 mtime=1776853188.4260000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/ConstantExpression0100644 0000000 0000000 00000004541 15172120304 033223 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ConstantExpressionEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { enum class ConstantExpressionEnum : int32_t { decInt32_1 = 1, decInt32_2 = 1, decInt64_1 = 1, decInt64_2 = 1, decInt64_3 = 1, decInt64_4 = 1, hexInt32_1 = 1, hexInt32_2 = 1, hexInt32_3 = 1, hexInt64_1 = 1, }; } // namespace tests } // namespace aidl } // namespace android namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(ConstantExpressionEnum val) { switch(val) { case ConstantExpressionEnum::decInt32_1: return "decInt32_1"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::tests::ConstantExpressionEnum, 10> enum_values<::android::aidl::tests::ConstantExpressionEnum> = { ::android::aidl::tests::ConstantExpressionEnum::decInt32_1, ::android::aidl::tests::ConstantExpressionEnum::decInt32_2, ::android::aidl::tests::ConstantExpressionEnum::decInt64_1, ::android::aidl::tests::ConstantExpressionEnum::decInt64_2, ::android::aidl::tests::ConstantExpressionEnum::decInt64_3, ::android::aidl::tests::ConstantExpressionEnum::decInt64_4, ::android::aidl::tests::ConstantExpressionEnum::hexInt32_1, ::android::aidl::tests::ConstantExpressionEnum::hexInt32_2, ::android::aidl::tests::ConstantExpressionEnum::hexInt32_3, ::android::aidl::tests::ConstantExpressionEnum::hexInt64_1, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_De0100644 0000000 0000000 00000000034 15172120304 033172 xustar000000000 0000000 28 mtime=1776853188.4260000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/DeprecatedEnum.h0100644 0000000 0000000 00000003705 15172120304 032466 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/DeprecatedEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedEnum.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { enum class __attribute__((deprecated("test"))) DeprecatedEnum : int32_t { A = 0, B = 1, C = 2, }; } // namespace tests } // namespace aidl } // namespace android namespace android { namespace aidl { namespace tests { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" [[nodiscard]] static inline std::string toString(DeprecatedEnum val) { switch(val) { case DeprecatedEnum::A: return "A"; case DeprecatedEnum::B: return "B"; case DeprecatedEnum::C: return "C"; default: return std::to_string(static_cast(val)); } } #pragma clang diagnostic pop } // namespace tests } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" #pragma clang diagnostic ignored "-Wdeprecated-declarations" template <> constexpr inline std::array<::android::aidl::tests::DeprecatedEnum, 3> enum_values<::android::aidl::tests::DeprecatedEnum> = { ::android::aidl::tests::DeprecatedEnum::A, ::android::aidl::tests::DeprecatedEnum::B, ::android::aidl::tests::DeprecatedEnum::C, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_De0100644 0000000 0000000 00000000216 15172120304 033174 xustar000000000 0000000 114 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/DeprecatedParcelable.h 28 mtime=1776853188.4260000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/DeprecatedParcelab0100644 0000000 0000000 00000004141 15172120304 033040 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/DeprecatedParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedParcelable.aidl */ #pragma once #include #include #include #include #include namespace android { namespace aidl { namespace tests { class __attribute__((deprecated("test"))) DeprecatedParcelable : public ::android::Parcelable { public: inline bool operator==(const DeprecatedParcelable&) const { return std::tie() == std::tie(); } inline bool operator<(const DeprecatedParcelable&) const { return std::tie() < std::tie(); } inline bool operator!=(const DeprecatedParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const DeprecatedParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const DeprecatedParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const DeprecatedParcelable& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.DeprecatedParcelable"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "DeprecatedParcelable{"; _aidl_os << "}"; return _aidl_os.str(); } }; // class DeprecatedParcelable } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Fi0100644 0000000 0000000 00000000034 15172120304 033200 xustar000000000 0000000 28 mtime=1776853188.4260000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/FixedSize.h0100644 0000000 0000000 00000027365 15172120304 031503 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/FixedSize.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/FixedSize.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace android { namespace aidl { namespace tests { class FixedSize : public ::android::Parcelable { public: class FixedUnion : public ::android::Parcelable { public: enum class Tag : int8_t { booleanValue = 0, byteValue = 1, charValue = 2, intValue = 3, longValue = 4, floatValue = 5, doubleValue = 6, enumValue = 7, }; // Expose tag symbols for legacy code static const inline Tag booleanValue = Tag::booleanValue; static const inline Tag byteValue = Tag::byteValue; static const inline Tag charValue = Tag::charValue; static const inline Tag intValue = Tag::intValue; static const inline Tag longValue = Tag::longValue; static const inline Tag floatValue = Tag::floatValue; static const inline Tag doubleValue = Tag::doubleValue; static const inline Tag enumValue = Tag::enumValue; template using _at = typename std::tuple_element(_Tag), std::tuple>::type; template static FixedUnion make(_Type&& _arg) { FixedUnion _inst; _inst.set<_Tag>(std::forward<_Type>(_arg)); return _inst; } constexpr Tag getTag() const { return _tag; } template const _at<_Tag>& get() const { if (_Tag != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return *(_at<_Tag>*)(&_value); } template _at<_Tag>& get() { if (_Tag != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return *(_at<_Tag>*)(&_value); } template void set(_Type&& _arg) { _tag = _Tag; get<_Tag>() = std::forward<_Type>(_arg); } static int _cmp(const FixedUnion& _lhs, const FixedUnion& _rhs) { return _cmp_value(_lhs.getTag(), _rhs.getTag()) || _cmp_value_at(_lhs, _rhs); } template static int _cmp_value_at(const FixedUnion& _lhs, const FixedUnion& _rhs) { if constexpr (_Tag == booleanValue) { return _cmp_value(_lhs.get<_Tag>(), _rhs.get<_Tag>()); } else { return (_lhs.getTag() == _Tag) ? _cmp_value(_lhs.get<_Tag>(), _rhs.get<_Tag>()) : _cmp_value_at(static_cast(_Tag)-1)>(_lhs, _rhs); } } template static int _cmp_value(const _Type& _lhs, const _Type& _rhs) { return (_lhs == _rhs) ? 0 : (_lhs < _rhs) ? -1 : 1; } inline bool operator!=(const FixedUnion&_rhs) const { return _cmp(*this, _rhs) != 0; } inline bool operator<(const FixedUnion&_rhs) const { return _cmp(*this, _rhs) < 0; } inline bool operator<=(const FixedUnion&_rhs) const { return _cmp(*this, _rhs) <= 0; } inline bool operator==(const FixedUnion&_rhs) const { return _cmp(*this, _rhs) == 0; } inline bool operator>(const FixedUnion&_rhs) const { return _cmp(*this, _rhs) > 0; } inline bool operator>=(const FixedUnion&_rhs) const { return _cmp(*this, _rhs) >= 0; } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.FixedSize.FixedUnion"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream os; os << "FixedUnion{"; switch (getTag()) { case booleanValue: os << "booleanValue: " << ::android::internal::ToString(get()); break; case byteValue: os << "byteValue: " << ::android::internal::ToString(get()); break; case charValue: os << "charValue: " << ::android::internal::ToString(get()); break; case intValue: os << "intValue: " << ::android::internal::ToString(get()); break; case longValue: os << "longValue: " << ::android::internal::ToString(get()); break; case floatValue: os << "floatValue: " << ::android::internal::ToString(get()); break; case doubleValue: os << "doubleValue: " << ::android::internal::ToString(get()); break; case enumValue: os << "enumValue: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: Tag _tag = booleanValue; union _value_t { _value_t() {} ~_value_t() {} bool booleanValue __attribute__((aligned (1))) = bool(false); int8_t byteValue __attribute__((aligned (1))); char16_t charValue __attribute__((aligned (2))); int32_t intValue __attribute__((aligned (4))); int64_t longValue __attribute__((aligned (8))); float floatValue __attribute__((aligned (4))); double doubleValue __attribute__((aligned (8))); ::android::aidl::tests::LongEnum enumValue __attribute__((aligned (8))); } _value; }; // class FixedUnion class FixedParcelable : public ::android::Parcelable { public: bool booleanValue = false; int8_t byteValue = 0; char16_t charValue = '\0'; int32_t intValue = 0; int64_t longValue = 0L; float floatValue = 0.000000f; double doubleValue = 0.000000; ::android::aidl::tests::LongEnum enumValue = ::android::aidl::tests::LongEnum::FOO; ::android::aidl::tests::FixedSize::FixedUnion parcelableValue; inline bool operator==(const FixedParcelable& _rhs) const { return std::tie(booleanValue, byteValue, charValue, intValue, longValue, floatValue, doubleValue, enumValue, parcelableValue) == std::tie(_rhs.booleanValue, _rhs.byteValue, _rhs.charValue, _rhs.intValue, _rhs.longValue, _rhs.floatValue, _rhs.doubleValue, _rhs.enumValue, _rhs.parcelableValue); } inline bool operator<(const FixedParcelable& _rhs) const { return std::tie(booleanValue, byteValue, charValue, intValue, longValue, floatValue, doubleValue, enumValue, parcelableValue) < std::tie(_rhs.booleanValue, _rhs.byteValue, _rhs.charValue, _rhs.intValue, _rhs.longValue, _rhs.floatValue, _rhs.doubleValue, _rhs.enumValue, _rhs.parcelableValue); } inline bool operator!=(const FixedParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const FixedParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const FixedParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const FixedParcelable& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.FixedSize.FixedParcelable"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "FixedParcelable{"; _aidl_os << "booleanValue: " << ::android::internal::ToString(booleanValue); _aidl_os << ", byteValue: " << ::android::internal::ToString(byteValue); _aidl_os << ", charValue: " << ::android::internal::ToString(charValue); _aidl_os << ", intValue: " << ::android::internal::ToString(intValue); _aidl_os << ", longValue: " << ::android::internal::ToString(longValue); _aidl_os << ", floatValue: " << ::android::internal::ToString(floatValue); _aidl_os << ", doubleValue: " << ::android::internal::ToString(doubleValue); _aidl_os << ", enumValue: " << ::android::internal::ToString(enumValue); _aidl_os << ", parcelableValue: " << ::android::internal::ToString(parcelableValue); _aidl_os << "}"; return _aidl_os.str(); } }; // class FixedParcelable inline bool operator==(const FixedSize&) const { return std::tie() == std::tie(); } inline bool operator<(const FixedSize&) const { return std::tie() < std::tie(); } inline bool operator!=(const FixedSize& _rhs) const { return !(*this == _rhs); } inline bool operator>(const FixedSize& _rhs) const { return _rhs < *this; } inline bool operator>=(const FixedSize& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const FixedSize& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.FixedSize"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "FixedSize{"; _aidl_os << "}"; return _aidl_os.str(); } }; // class FixedSize } // namespace tests } // namespace aidl } // namespace android namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(FixedSize::FixedUnion::Tag val) { switch(val) { case FixedSize::FixedUnion::Tag::booleanValue: return "booleanValue"; case FixedSize::FixedUnion::Tag::byteValue: return "byteValue"; case FixedSize::FixedUnion::Tag::charValue: return "charValue"; case FixedSize::FixedUnion::Tag::intValue: return "intValue"; case FixedSize::FixedUnion::Tag::longValue: return "longValue"; case FixedSize::FixedUnion::Tag::floatValue: return "floatValue"; case FixedSize::FixedUnion::Tag::doubleValue: return "doubleValue"; case FixedSize::FixedUnion::Tag::enumValue: return "enumValue"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::tests::FixedSize::FixedUnion::Tag, 8> enum_values<::android::aidl::tests::FixedSize::FixedUnion::Tag> = { ::android::aidl::tests::FixedSize::FixedUnion::Tag::booleanValue, ::android::aidl::tests::FixedSize::FixedUnion::Tag::byteValue, ::android::aidl::tests::FixedSize::FixedUnion::Tag::charValue, ::android::aidl::tests::FixedSize::FixedUnion::Tag::intValue, ::android::aidl::tests::FixedSize::FixedUnion::Tag::longValue, ::android::aidl::tests::FixedSize::FixedUnion::Tag::floatValue, ::android::aidl::tests::FixedSize::FixedUnion::Tag::doubleValue, ::android::aidl::tests::FixedSize::FixedUnion::Tag::enumValue, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Ge0100644 0000000 0000000 00000000225 15172120304 033177 xustar000000000 0000000 121 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/GenericStructuredParcelable.h 28 mtime=1776853188.4260000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/GenericStructuredP0100644 0000000 0000000 00000011471 15172120304 033133 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/GenericStructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl */ #pragma once #include #include #include #include #include #include namespace android { namespace aidl { namespace tests { template class GenericStructuredParcelable : public ::android::Parcelable { public: int32_t a = 0; int32_t b = 0; inline bool operator==(const GenericStructuredParcelable& _rhs) const { return std::tie(a, b) == std::tie(_rhs.a, _rhs.b); } inline bool operator<(const GenericStructuredParcelable& _rhs) const { return std::tie(a, b) < std::tie(_rhs.a, _rhs.b); } inline bool operator!=(const GenericStructuredParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const GenericStructuredParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const GenericStructuredParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const GenericStructuredParcelable& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.GenericStructuredParcelable"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "GenericStructuredParcelable{"; _aidl_os << "a: " << ::android::internal::ToString(a); _aidl_os << ", b: " << ::android::internal::ToString(b); _aidl_os << "}"; return _aidl_os.str(); } }; // class GenericStructuredParcelable } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { template ::android::status_t GenericStructuredParcelable::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&a); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&b); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } template ::android::status_t GenericStructuredParcelable::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeInt32(a); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(b); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_IC0100644 0000000 0000000 00000000034 15172120304 033135 xustar000000000 0000000 28 mtime=1776853188.4270000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/ICircular.h0100644 0000000 0000000 00000003251 15172120304 031452 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ICircular.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ICircular.aidl */ #pragma once #include #include #include #include #include #include #include namespace android::aidl::tests { class ITestService; } // namespace android::aidl::tests namespace android { namespace aidl { namespace tests { class ICircularDelegator; class ICircular : public ::android::IInterface { public: typedef ICircularDelegator DefaultDelegator; DECLARE_META_INTERFACE(Circular) virtual ::android::binder::Status GetTestService(::android::sp<::android::aidl::tests::ITestService>* _aidl_return) = 0; }; // class ICircular class ICircularDefault : public ICircular { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status GetTestService(::android::sp<::android::aidl::tests::ITestService>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } }; // class ICircularDefault } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_ID0100644 0000000 0000000 00000000034 15172120304 033136 xustar000000000 0000000 28 mtime=1776853188.4270000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/IDeprecated.h0100644 0000000 0000000 00000002433 15172120304 031747 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/IDeprecated.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IDeprecated.aidl */ #pragma once #include #include #include #include #include namespace android { namespace aidl { namespace tests { class IDeprecatedDelegator; class __attribute__((deprecated("test"))) IDeprecated : public ::android::IInterface { public: typedef IDeprecatedDelegator DefaultDelegator; DECLARE_META_INTERFACE(Deprecated) }; // class IDeprecated class __attribute__((deprecated("test"))) IDeprecatedDefault : public IDeprecated { public: ::android::IBinder* onAsBinder() override { return nullptr; } }; // class IDeprecatedDefault } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_IN0100644 0000000 0000000 00000000034 15172120304 033150 xustar000000000 0000000 28 mtime=1776853188.4270000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/INamedCallback.h0100644 0000000 0000000 00000003016 15172120304 032346 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/INamedCallback.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl */ #pragma once #include #include #include #include #include #include namespace android { namespace aidl { namespace tests { class INamedCallbackDelegator; class INamedCallback : public ::android::IInterface { public: typedef INamedCallbackDelegator DefaultDelegator; DECLARE_META_INTERFACE(NamedCallback) virtual ::android::binder::Status GetName(::android::String16* _aidl_return) = 0; }; // class INamedCallback class INamedCallbackDefault : public INamedCallback { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status GetName(::android::String16* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } }; // class INamedCallbackDefault } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_IN0100644 0000000 0000000 00000000034 15172120304 033150 xustar000000000 0000000 28 mtime=1776853188.4270000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/INewName.h0100644 0000000 0000000 00000002724 15172120304 031244 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/INewName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INewName.aidl */ #pragma once #include #include #include #include #include #include namespace android { namespace aidl { namespace tests { class INewNameDelegator; class INewName : public ::android::IInterface { public: typedef INewNameDelegator DefaultDelegator; DECLARE_META_INTERFACE(NewName) virtual ::android::binder::Status RealName(::android::String16* _aidl_return) = 0; }; // class INewName class INewNameDefault : public INewName { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status RealName(::android::String16* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } }; // class INewNameDefault } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_IO0100644 0000000 0000000 00000000034 15172120304 033151 xustar000000000 0000000 28 mtime=1776853188.4270000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/IOldName.h0100644 0000000 0000000 00000002724 15172120304 031231 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/IOldName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IOldName.aidl */ #pragma once #include #include #include #include #include #include namespace android { namespace aidl { namespace tests { class IOldNameDelegator; class IOldName : public ::android::IInterface { public: typedef IOldNameDelegator DefaultDelegator; DECLARE_META_INTERFACE(OldName) virtual ::android::binder::Status RealName(::android::String16* _aidl_return) = 0; }; // class IOldName class IOldNameDefault : public IOldName { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status RealName(::android::String16* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } }; // class IOldNameDefault } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_IT0100644 0000000 0000000 00000000034 15172120304 033156 xustar000000000 0000000 28 mtime=1776853188.4270000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/ITestService.h0100644 0000000 0000000 00000156770 15172120304 032165 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ITestService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ITestService.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace android::aidl::tests { class CircularParcelable; class ICircular; class INamedCallback; class INewName; class IOldName; class RecursiveList; class StructuredParcelable; } // namespace android::aidl::tests namespace android::aidl::tests::extension { class ExtendableParcelable; } // namespace android::aidl::tests::extension namespace android { namespace aidl { namespace tests { class ITestServiceDelegator; class ITestService : public ::android::IInterface { public: typedef ITestServiceDelegator DefaultDelegator; DECLARE_META_INTERFACE(TestService) class Empty : public ::android::Parcelable { public: inline bool operator==(const Empty&) const { return std::tie() == std::tie(); } inline bool operator<(const Empty&) const { return std::tie() < std::tie(); } inline bool operator!=(const Empty& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Empty& _rhs) const { return _rhs < *this; } inline bool operator>=(const Empty& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Empty& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.ITestService.Empty"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "Empty{"; _aidl_os << "}"; return _aidl_os.str(); } }; // class Empty class CompilerChecks : public ::android::Parcelable { public: class IFooDelegator; class IFoo : public ::android::IInterface { public: typedef IFooDelegator DefaultDelegator; DECLARE_META_INTERFACE(Foo) }; // class IFoo class IFooDefault : public IFoo { public: ::android::IBinder* onAsBinder() override { return nullptr; } }; // class IFooDefault class BpFoo : public ::android::BpInterface { public: explicit BpFoo(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpFoo() = default; }; // class BpFoo class BnFoo : public ::android::BnInterface { public: explicit BnFoo(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnFoo class IFooDelegator : public BnFoo { public: explicit IFooDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } private: ::android::sp _aidl_delegate; }; // class IFooDelegator #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" class HasDeprecated : public ::android::Parcelable { public: int32_t __attribute__((deprecated("field"))) deprecated = 0; inline bool operator==(const HasDeprecated& _rhs) const { return std::tie(deprecated) == std::tie(_rhs.deprecated); } inline bool operator<(const HasDeprecated& _rhs) const { return std::tie(deprecated) < std::tie(_rhs.deprecated); } inline bool operator!=(const HasDeprecated& _rhs) const { return !(*this == _rhs); } inline bool operator>(const HasDeprecated& _rhs) const { return _rhs < *this; } inline bool operator>=(const HasDeprecated& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const HasDeprecated& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.ITestService.CompilerChecks.HasDeprecated"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "HasDeprecated{"; _aidl_os << "deprecated: " << ::android::internal::ToString(deprecated); _aidl_os << "}"; return _aidl_os.str(); } }; // class HasDeprecated #pragma clang diagnostic pop class UsingHasDeprecated : public ::android::Parcelable { public: enum class Tag : int32_t { n = 0, m = 1, }; // Expose tag symbols for legacy code static const inline Tag n = Tag::n; static const inline Tag m = Tag::m; template static constexpr bool _not_self = !std::is_same_v>, UsingHasDeprecated>; UsingHasDeprecated() : _value(std::in_place_index(n)>, int32_t(0)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr UsingHasDeprecated(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit UsingHasDeprecated(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static UsingHasDeprecated make(_Tp&&... _args) { return UsingHasDeprecated(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static UsingHasDeprecated make(std::initializer_list<_Tp> _il, _Up&&... _args) { return UsingHasDeprecated(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } inline bool operator==(const UsingHasDeprecated& _rhs) const { return _value == _rhs._value; } inline bool operator<(const UsingHasDeprecated& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const UsingHasDeprecated& _rhs) const { return !(*this == _rhs); } inline bool operator>(const UsingHasDeprecated& _rhs) const { return _rhs < *this; } inline bool operator>=(const UsingHasDeprecated& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const UsingHasDeprecated& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.ITestService.CompilerChecks.UsingHasDeprecated"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream os; os << "UsingHasDeprecated{"; switch (getTag()) { case n: os << "n: " << ::android::internal::ToString(get()); break; case m: os << "m: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant _value; }; // class UsingHasDeprecated class INoPrefixInterfaceDelegator; class INoPrefixInterface : public ::android::IInterface { public: typedef INoPrefixInterfaceDelegator DefaultDelegator; DECLARE_META_INTERFACE(NoPrefixInterface) class Nested : public ::android::Parcelable { public: inline bool operator==(const Nested&) const { return std::tie() == std::tie(); } inline bool operator<(const Nested&) const { return std::tie() < std::tie(); } inline bool operator!=(const Nested& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Nested& _rhs) const { return _rhs < *this; } inline bool operator>=(const Nested& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Nested& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.Nested"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "Nested{"; _aidl_os << "}"; return _aidl_os.str(); } }; // class Nested class INestedNoPrefixInterfaceDelegator; class INestedNoPrefixInterface : public ::android::IInterface { public: typedef INestedNoPrefixInterfaceDelegator DefaultDelegator; DECLARE_META_INTERFACE(NestedNoPrefixInterface) virtual ::android::binder::Status foo() = 0; }; // class INestedNoPrefixInterface class INestedNoPrefixInterfaceDefault : public INestedNoPrefixInterface { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status foo() override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } }; // class INestedNoPrefixInterfaceDefault class BpNestedNoPrefixInterface : public ::android::BpInterface { public: explicit BpNestedNoPrefixInterface(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpNestedNoPrefixInterface() = default; ::android::binder::Status foo() override; }; // class BpNestedNoPrefixInterface class BnNestedNoPrefixInterface : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_foo = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; explicit BnNestedNoPrefixInterface(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnNestedNoPrefixInterface class INestedNoPrefixInterfaceDelegator : public BnNestedNoPrefixInterface { public: explicit INestedNoPrefixInterfaceDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status foo() override { return _aidl_delegate->foo(); } private: ::android::sp _aidl_delegate; }; // class INestedNoPrefixInterfaceDelegator virtual ::android::binder::Status foo() = 0; }; // class INoPrefixInterface class INoPrefixInterfaceDefault : public INoPrefixInterface { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status foo() override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } }; // class INoPrefixInterfaceDefault class BpNoPrefixInterface : public ::android::BpInterface { public: explicit BpNoPrefixInterface(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpNoPrefixInterface() = default; ::android::binder::Status foo() override; }; // class BpNoPrefixInterface class BnNoPrefixInterface : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_foo = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; explicit BnNoPrefixInterface(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnNoPrefixInterface class INoPrefixInterfaceDelegator : public BnNoPrefixInterface { public: explicit INoPrefixInterfaceDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status foo() override { return _aidl_delegate->foo(); } private: ::android::sp _aidl_delegate; }; // class INoPrefixInterfaceDelegator ::android::sp<::android::IBinder> binder; ::android::sp<::android::IBinder> nullable_binder; ::std::vector<::android::sp<::android::IBinder>> binder_array; ::std::optional<::std::vector<::android::sp<::android::IBinder>>> nullable_binder_array; ::std::vector<::android::sp<::android::IBinder>> binder_list; ::std::optional<::std::vector<::android::sp<::android::IBinder>>> nullable_binder_list; ::android::os::ParcelFileDescriptor pfd; ::std::optional<::android::os::ParcelFileDescriptor> nullable_pfd; ::std::vector<::android::os::ParcelFileDescriptor> pfd_array; ::std::optional<::std::vector<::std::optional<::android::os::ParcelFileDescriptor>>> nullable_pfd_array; ::std::vector<::android::os::ParcelFileDescriptor> pfd_list; ::std::optional<::std::vector<::std::optional<::android::os::ParcelFileDescriptor>>> nullable_pfd_list; ::android::aidl::tests::ITestService::Empty parcel; ::std::optional<::android::aidl::tests::ITestService::Empty> nullable_parcel; ::std::vector<::android::aidl::tests::ITestService::Empty> parcel_array; ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>> nullable_parcel_array; ::std::vector<::android::aidl::tests::ITestService::Empty> parcel_list; ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>> nullable_parcel_list; inline bool operator==(const CompilerChecks& _rhs) const { return std::tie(binder, nullable_binder, binder_array, nullable_binder_array, binder_list, nullable_binder_list, pfd, nullable_pfd, pfd_array, nullable_pfd_array, pfd_list, nullable_pfd_list, parcel, nullable_parcel, parcel_array, nullable_parcel_array, parcel_list, nullable_parcel_list) == std::tie(_rhs.binder, _rhs.nullable_binder, _rhs.binder_array, _rhs.nullable_binder_array, _rhs.binder_list, _rhs.nullable_binder_list, _rhs.pfd, _rhs.nullable_pfd, _rhs.pfd_array, _rhs.nullable_pfd_array, _rhs.pfd_list, _rhs.nullable_pfd_list, _rhs.parcel, _rhs.nullable_parcel, _rhs.parcel_array, _rhs.nullable_parcel_array, _rhs.parcel_list, _rhs.nullable_parcel_list); } inline bool operator<(const CompilerChecks& _rhs) const { return std::tie(binder, nullable_binder, binder_array, nullable_binder_array, binder_list, nullable_binder_list, pfd, nullable_pfd, pfd_array, nullable_pfd_array, pfd_list, nullable_pfd_list, parcel, nullable_parcel, parcel_array, nullable_parcel_array, parcel_list, nullable_parcel_list) < std::tie(_rhs.binder, _rhs.nullable_binder, _rhs.binder_array, _rhs.nullable_binder_array, _rhs.binder_list, _rhs.nullable_binder_list, _rhs.pfd, _rhs.nullable_pfd, _rhs.pfd_array, _rhs.nullable_pfd_array, _rhs.pfd_list, _rhs.nullable_pfd_list, _rhs.parcel, _rhs.nullable_parcel, _rhs.parcel_array, _rhs.nullable_parcel_array, _rhs.parcel_list, _rhs.nullable_parcel_list); } inline bool operator!=(const CompilerChecks& _rhs) const { return !(*this == _rhs); } inline bool operator>(const CompilerChecks& _rhs) const { return _rhs < *this; } inline bool operator>=(const CompilerChecks& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const CompilerChecks& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.ITestService.CompilerChecks"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "CompilerChecks{"; _aidl_os << "binder: " << ::android::internal::ToString(binder); _aidl_os << ", nullable_binder: " << ::android::internal::ToString(nullable_binder); _aidl_os << ", binder_array: " << ::android::internal::ToString(binder_array); _aidl_os << ", nullable_binder_array: " << ::android::internal::ToString(nullable_binder_array); _aidl_os << ", binder_list: " << ::android::internal::ToString(binder_list); _aidl_os << ", nullable_binder_list: " << ::android::internal::ToString(nullable_binder_list); _aidl_os << ", pfd: " << ::android::internal::ToString(pfd); _aidl_os << ", nullable_pfd: " << ::android::internal::ToString(nullable_pfd); _aidl_os << ", pfd_array: " << ::android::internal::ToString(pfd_array); _aidl_os << ", nullable_pfd_array: " << ::android::internal::ToString(nullable_pfd_array); _aidl_os << ", pfd_list: " << ::android::internal::ToString(pfd_list); _aidl_os << ", nullable_pfd_list: " << ::android::internal::ToString(nullable_pfd_list); _aidl_os << ", parcel: " << ::android::internal::ToString(parcel); _aidl_os << ", nullable_parcel: " << ::android::internal::ToString(nullable_parcel); _aidl_os << ", parcel_array: " << ::android::internal::ToString(parcel_array); _aidl_os << ", nullable_parcel_array: " << ::android::internal::ToString(nullable_parcel_array); _aidl_os << ", parcel_list: " << ::android::internal::ToString(parcel_list); _aidl_os << ", nullable_parcel_list: " << ::android::internal::ToString(nullable_parcel_list); _aidl_os << "}"; return _aidl_os.str(); } }; // class CompilerChecks enum : int32_t { CONSTANT = 42 }; enum : int32_t { CONSTANT2 = -42 }; enum : int32_t { CONSTANT3 = 42 }; enum : int32_t { CONSTANT4 = 4 }; enum : int32_t { CONSTANT5 = -4 }; enum : int32_t { CONSTANT6 = 0 }; enum : int32_t { CONSTANT7 = 0 }; enum : int32_t { CONSTANT8 = 0 }; enum : int32_t { CONSTANT9 = 86 }; enum : int32_t { CONSTANT10 = 165 }; enum : int32_t { CONSTANT11 = 250 }; enum : int32_t { CONSTANT12 = -1 }; enum : int8_t { BYTE_CONSTANT = 17 }; enum : int64_t { LONG_CONSTANT = 1099511627776L }; static const ::android::String16& STRING_CONSTANT(); static const ::android::String16& STRING_CONSTANT2(); static constexpr float FLOAT_CONSTANT = 1.000000f; static constexpr float FLOAT_CONSTANT2 = -1.000000f; static constexpr float FLOAT_CONSTANT3 = 1.000000f; static constexpr float FLOAT_CONSTANT4 = 2.200000f; static constexpr float FLOAT_CONSTANT5 = -2.200000f; static constexpr float FLOAT_CONSTANT6 = -0.000000f; static constexpr float FLOAT_CONSTANT7 = 0.000000f; static constexpr double DOUBLE_CONSTANT = 1.000000; static constexpr double DOUBLE_CONSTANT2 = -1.000000; static constexpr double DOUBLE_CONSTANT3 = 1.000000; static constexpr double DOUBLE_CONSTANT4 = 2.200000; static constexpr double DOUBLE_CONSTANT5 = -2.200000; static constexpr double DOUBLE_CONSTANT6 = -0.000000; static constexpr double DOUBLE_CONSTANT7 = 0.000000; static constexpr double DOUBLE_CONSTANT8 = 1.100000; static constexpr double DOUBLE_CONSTANT9 = -1.100000; static const ::std::string& STRING_CONSTANT_UTF8(); enum : int32_t { A1 = 1 }; enum : int32_t { A2 = 1 }; enum : int32_t { A3 = 1 }; enum : int32_t { A4 = 1 }; enum : int32_t { A5 = 1 }; enum : int32_t { A6 = 1 }; enum : int32_t { A7 = 1 }; enum : int32_t { A8 = 1 }; enum : int32_t { A9 = 1 }; enum : int32_t { A10 = 1 }; enum : int32_t { A11 = 1 }; enum : int32_t { A12 = 1 }; enum : int32_t { A13 = 1 }; enum : int32_t { A14 = 1 }; enum : int32_t { A15 = 1 }; enum : int32_t { A16 = 1 }; enum : int32_t { A17 = 1 }; enum : int32_t { A18 = 1 }; enum : int32_t { A19 = 1 }; enum : int32_t { A20 = 1 }; enum : int32_t { A21 = 1 }; enum : int32_t { A22 = 1 }; enum : int32_t { A23 = 1 }; enum : int32_t { A24 = 1 }; enum : int32_t { A25 = 1 }; enum : int32_t { A26 = 1 }; enum : int32_t { A27 = 1 }; enum : int32_t { A28 = 1 }; enum : int32_t { A29 = 1 }; enum : int32_t { A30 = 1 }; enum : int32_t { A31 = 1 }; enum : int32_t { A32 = 1 }; enum : int32_t { A33 = 1 }; enum : int32_t { A34 = 1 }; enum : int32_t { A35 = 1 }; enum : int32_t { A36 = 1 }; enum : int32_t { A37 = 1 }; enum : int32_t { A38 = 1 }; enum : int32_t { A39 = 1 }; enum : int32_t { A40 = 1 }; enum : int32_t { A41 = 1 }; enum : int32_t { A42 = 1 }; enum : int32_t { A43 = 1 }; enum : int32_t { A44 = 1 }; enum : int32_t { A45 = 1 }; enum : int32_t { A46 = 1 }; enum : int32_t { A47 = 1 }; enum : int32_t { A48 = 1 }; enum : int32_t { A49 = 1 }; enum : int32_t { A50 = 1 }; enum : int32_t { A51 = 1 }; enum : int32_t { A52 = 1 }; enum : int32_t { A53 = 1 }; enum : int32_t { A54 = 1 }; enum : int32_t { A55 = 1 }; enum : int32_t { A56 = 1 }; enum : int32_t { A57 = 1 }; virtual ::android::binder::Status UnimplementedMethod(int32_t arg, int32_t* _aidl_return) = 0; virtual ::android::binder::Status Deprecated() __attribute__((deprecated("to make sure we have something in system/tools/aidl which does a compile check of deprecated and make sure this is reflected in goldens"))) = 0; virtual ::android::binder::Status TestOneway() = 0; virtual ::android::binder::Status RepeatBoolean(bool token, bool* _aidl_return) = 0; virtual ::android::binder::Status RepeatByte(int8_t token, int8_t* _aidl_return) = 0; virtual ::android::binder::Status RepeatChar(char16_t token, char16_t* _aidl_return) = 0; virtual ::android::binder::Status RepeatInt(int32_t token, int32_t* _aidl_return) = 0; virtual ::android::binder::Status RepeatLong(int64_t token, int64_t* _aidl_return) = 0; virtual ::android::binder::Status RepeatFloat(float token, float* _aidl_return) = 0; virtual ::android::binder::Status RepeatDouble(double token, double* _aidl_return) = 0; virtual ::android::binder::Status RepeatString(const ::android::String16& token, ::android::String16* _aidl_return) = 0; virtual ::android::binder::Status RepeatByteEnum(::android::aidl::tests::ByteEnum token, ::android::aidl::tests::ByteEnum* _aidl_return) = 0; virtual ::android::binder::Status RepeatIntEnum(::android::aidl::tests::IntEnum token, ::android::aidl::tests::IntEnum* _aidl_return) = 0; virtual ::android::binder::Status RepeatLongEnum(::android::aidl::tests::LongEnum token, ::android::aidl::tests::LongEnum* _aidl_return) = 0; virtual ::android::binder::Status ReverseBoolean(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) = 0; virtual ::android::binder::Status ReverseByte(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) = 0; virtual ::android::binder::Status ReverseChar(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) = 0; virtual ::android::binder::Status ReverseInt(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) = 0; virtual ::android::binder::Status ReverseLong(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) = 0; virtual ::android::binder::Status ReverseFloat(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) = 0; virtual ::android::binder::Status ReverseDouble(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) = 0; virtual ::android::binder::Status ReverseString(const ::std::vector<::android::String16>& input, ::std::vector<::android::String16>* repeated, ::std::vector<::android::String16>* _aidl_return) = 0; virtual ::android::binder::Status ReverseByteEnum(const ::std::vector<::android::aidl::tests::ByteEnum>& input, ::std::vector<::android::aidl::tests::ByteEnum>* repeated, ::std::vector<::android::aidl::tests::ByteEnum>* _aidl_return) = 0; virtual ::android::binder::Status ReverseIntEnum(const ::std::vector<::android::aidl::tests::IntEnum>& input, ::std::vector<::android::aidl::tests::IntEnum>* repeated, ::std::vector<::android::aidl::tests::IntEnum>* _aidl_return) = 0; virtual ::android::binder::Status ReverseLongEnum(const ::std::vector<::android::aidl::tests::LongEnum>& input, ::std::vector<::android::aidl::tests::LongEnum>* repeated, ::std::vector<::android::aidl::tests::LongEnum>* _aidl_return) = 0; virtual ::android::binder::Status GetOtherTestService(const ::android::String16& name, ::android::sp<::android::aidl::tests::INamedCallback>* _aidl_return) = 0; virtual ::android::binder::Status SetOtherTestService(const ::android::String16& name, const ::android::sp<::android::aidl::tests::INamedCallback>& service, bool* _aidl_return) = 0; virtual ::android::binder::Status VerifyName(const ::android::sp<::android::aidl::tests::INamedCallback>& service, const ::android::String16& name, bool* _aidl_return) = 0; virtual ::android::binder::Status GetInterfaceArray(const ::std::vector<::android::String16>& names, ::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>* _aidl_return) = 0; virtual ::android::binder::Status VerifyNamesWithInterfaceArray(const ::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>& services, const ::std::vector<::android::String16>& names, bool* _aidl_return) = 0; virtual ::android::binder::Status GetNullableInterfaceArray(const ::std::optional<::std::vector<::std::optional<::android::String16>>>& names, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>* _aidl_return) = 0; virtual ::android::binder::Status VerifyNamesWithNullableInterfaceArray(const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>& services, const ::std::optional<::std::vector<::std::optional<::android::String16>>>& names, bool* _aidl_return) = 0; virtual ::android::binder::Status GetInterfaceList(const ::std::optional<::std::vector<::std::optional<::android::String16>>>& names, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>* _aidl_return) = 0; virtual ::android::binder::Status VerifyNamesWithInterfaceList(const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>& services, const ::std::optional<::std::vector<::std::optional<::android::String16>>>& names, bool* _aidl_return) = 0; virtual ::android::binder::Status ReverseStringList(const ::std::vector<::android::String16>& input, ::std::vector<::android::String16>* repeated, ::std::vector<::android::String16>* _aidl_return) = 0; virtual ::android::binder::Status RepeatParcelFileDescriptor(const ::android::os::ParcelFileDescriptor& read, ::android::os::ParcelFileDescriptor* _aidl_return) = 0; virtual ::android::binder::Status ReverseParcelFileDescriptorArray(const ::std::vector<::android::os::ParcelFileDescriptor>& input, ::std::vector<::android::os::ParcelFileDescriptor>* repeated, ::std::vector<::android::os::ParcelFileDescriptor>* _aidl_return) = 0; virtual ::android::binder::Status ThrowServiceException(int32_t code) = 0; virtual ::android::binder::Status RepeatNullableIntArray(const ::std::optional<::std::vector>& input, ::std::optional<::std::vector>* _aidl_return) = 0; virtual ::android::binder::Status RepeatNullableByteEnumArray(const ::std::optional<::std::vector<::android::aidl::tests::ByteEnum>>& input, ::std::optional<::std::vector<::android::aidl::tests::ByteEnum>>* _aidl_return) = 0; virtual ::android::binder::Status RepeatNullableIntEnumArray(const ::std::optional<::std::vector<::android::aidl::tests::IntEnum>>& input, ::std::optional<::std::vector<::android::aidl::tests::IntEnum>>* _aidl_return) = 0; virtual ::android::binder::Status RepeatNullableLongEnumArray(const ::std::optional<::std::vector<::android::aidl::tests::LongEnum>>& input, ::std::optional<::std::vector<::android::aidl::tests::LongEnum>>* _aidl_return) = 0; virtual ::android::binder::Status RepeatNullableString(const ::std::optional<::android::String16>& input, ::std::optional<::android::String16>* _aidl_return) = 0; virtual ::android::binder::Status RepeatNullableStringList(const ::std::optional<::std::vector<::std::optional<::android::String16>>>& input, ::std::optional<::std::vector<::std::optional<::android::String16>>>* _aidl_return) = 0; virtual ::android::binder::Status RepeatNullableParcelable(const ::std::optional<::android::aidl::tests::ITestService::Empty>& input, ::std::optional<::android::aidl::tests::ITestService::Empty>* _aidl_return) = 0; virtual ::android::binder::Status RepeatNullableParcelableArray(const ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>& input, ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>* _aidl_return) = 0; virtual ::android::binder::Status RepeatNullableParcelableList(const ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>& input, ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>* _aidl_return) = 0; virtual ::android::binder::Status TakesAnIBinder(const ::android::sp<::android::IBinder>& input) = 0; virtual ::android::binder::Status TakesANullableIBinder(const ::android::sp<::android::IBinder>& input) = 0; virtual ::android::binder::Status TakesAnIBinderList(const ::std::vector<::android::sp<::android::IBinder>>& input) = 0; virtual ::android::binder::Status TakesANullableIBinderList(const ::std::optional<::std::vector<::android::sp<::android::IBinder>>>& input) = 0; virtual ::android::binder::Status RepeatUtf8CppString(const ::std::string& token, ::std::string* _aidl_return) = 0; virtual ::android::binder::Status RepeatNullableUtf8CppString(const ::std::optional<::std::string>& token, ::std::optional<::std::string>* _aidl_return) = 0; virtual ::android::binder::Status ReverseUtf8CppString(const ::std::vector<::std::string>& input, ::std::vector<::std::string>* repeated, ::std::vector<::std::string>* _aidl_return) = 0; virtual ::android::binder::Status ReverseNullableUtf8CppString(const ::std::optional<::std::vector<::std::optional<::std::string>>>& input, ::std::optional<::std::vector<::std::optional<::std::string>>>* repeated, ::std::optional<::std::vector<::std::optional<::std::string>>>* _aidl_return) = 0; virtual ::android::binder::Status ReverseUtf8CppStringList(const ::std::optional<::std::vector<::std::optional<::std::string>>>& input, ::std::optional<::std::vector<::std::optional<::std::string>>>* repeated, ::std::optional<::std::vector<::std::optional<::std::string>>>* _aidl_return) = 0; virtual ::android::binder::Status GetCallback(bool return_null, ::android::sp<::android::aidl::tests::INamedCallback>* _aidl_return) = 0; virtual ::android::binder::Status FillOutStructuredParcelable(::android::aidl::tests::StructuredParcelable* parcel) = 0; virtual ::android::binder::Status RepeatExtendableParcelable(const ::android::aidl::tests::extension::ExtendableParcelable& ep, ::android::aidl::tests::extension::ExtendableParcelable* ep2) = 0; virtual ::android::binder::Status ReverseList(const ::android::aidl::tests::RecursiveList& list, ::android::aidl::tests::RecursiveList* _aidl_return) = 0; virtual ::android::binder::Status ReverseIBinderArray(const ::std::vector<::android::sp<::android::IBinder>>& input, ::std::vector<::android::sp<::android::IBinder>>* repeated, ::std::vector<::android::sp<::android::IBinder>>* _aidl_return) = 0; virtual ::android::binder::Status ReverseNullableIBinderArray(const ::std::optional<::std::vector<::android::sp<::android::IBinder>>>& input, ::std::optional<::std::vector<::android::sp<::android::IBinder>>>* repeated, ::std::optional<::std::vector<::android::sp<::android::IBinder>>>* _aidl_return) = 0; virtual ::android::binder::Status RepeatSimpleParcelable(const ::android::aidl::tests::SimpleParcelable& input, ::android::aidl::tests::SimpleParcelable* repeat, ::android::aidl::tests::SimpleParcelable* _aidl_return) = 0; virtual ::android::binder::Status ReverseSimpleParcelables(const ::std::vector<::android::aidl::tests::SimpleParcelable>& input, ::std::vector<::android::aidl::tests::SimpleParcelable>* repeated, ::std::vector<::android::aidl::tests::SimpleParcelable>* _aidl_return) = 0; virtual ::android::binder::Status GetOldNameInterface(::android::sp<::android::aidl::tests::IOldName>* _aidl_return) = 0; virtual ::android::binder::Status GetNewNameInterface(::android::sp<::android::aidl::tests::INewName>* _aidl_return) = 0; virtual ::android::binder::Status GetUnionTags(const ::std::vector<::android::aidl::tests::Union>& input, ::std::vector<::android::aidl::tests::Union::Tag>* _aidl_return) = 0; virtual ::android::binder::Status GetCppJavaTests(::android::sp<::android::IBinder>* _aidl_return) = 0; virtual ::android::binder::Status getBackendType(::android::aidl::tests::BackendType* _aidl_return) = 0; virtual ::android::binder::Status GetCircular(::android::aidl::tests::CircularParcelable* cp, ::android::sp<::android::aidl::tests::ICircular>* _aidl_return) = 0; }; // class ITestService class ITestServiceDefault : public ITestService { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status UnimplementedMethod(int32_t /*arg*/, int32_t* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status Deprecated() override __attribute__((deprecated("to make sure we have something in system/tools/aidl which does a compile check of deprecated and make sure this is reflected in goldens"))) { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status TestOneway() override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatBoolean(bool /*token*/, bool* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatByte(int8_t /*token*/, int8_t* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatChar(char16_t /*token*/, char16_t* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatInt(int32_t /*token*/, int32_t* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatLong(int64_t /*token*/, int64_t* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatFloat(float /*token*/, float* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatDouble(double /*token*/, double* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatString(const ::android::String16& /*token*/, ::android::String16* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatByteEnum(::android::aidl::tests::ByteEnum /*token*/, ::android::aidl::tests::ByteEnum* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatIntEnum(::android::aidl::tests::IntEnum /*token*/, ::android::aidl::tests::IntEnum* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatLongEnum(::android::aidl::tests::LongEnum /*token*/, ::android::aidl::tests::LongEnum* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseBoolean(const ::std::vector& /*input*/, ::std::vector* /*repeated*/, ::std::vector* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseByte(const ::std::vector& /*input*/, ::std::vector* /*repeated*/, ::std::vector* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseChar(const ::std::vector& /*input*/, ::std::vector* /*repeated*/, ::std::vector* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseInt(const ::std::vector& /*input*/, ::std::vector* /*repeated*/, ::std::vector* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseLong(const ::std::vector& /*input*/, ::std::vector* /*repeated*/, ::std::vector* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseFloat(const ::std::vector& /*input*/, ::std::vector* /*repeated*/, ::std::vector* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseDouble(const ::std::vector& /*input*/, ::std::vector* /*repeated*/, ::std::vector* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseString(const ::std::vector<::android::String16>& /*input*/, ::std::vector<::android::String16>* /*repeated*/, ::std::vector<::android::String16>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseByteEnum(const ::std::vector<::android::aidl::tests::ByteEnum>& /*input*/, ::std::vector<::android::aidl::tests::ByteEnum>* /*repeated*/, ::std::vector<::android::aidl::tests::ByteEnum>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseIntEnum(const ::std::vector<::android::aidl::tests::IntEnum>& /*input*/, ::std::vector<::android::aidl::tests::IntEnum>* /*repeated*/, ::std::vector<::android::aidl::tests::IntEnum>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseLongEnum(const ::std::vector<::android::aidl::tests::LongEnum>& /*input*/, ::std::vector<::android::aidl::tests::LongEnum>* /*repeated*/, ::std::vector<::android::aidl::tests::LongEnum>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status GetOtherTestService(const ::android::String16& /*name*/, ::android::sp<::android::aidl::tests::INamedCallback>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status SetOtherTestService(const ::android::String16& /*name*/, const ::android::sp<::android::aidl::tests::INamedCallback>& /*service*/, bool* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status VerifyName(const ::android::sp<::android::aidl::tests::INamedCallback>& /*service*/, const ::android::String16& /*name*/, bool* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status GetInterfaceArray(const ::std::vector<::android::String16>& /*names*/, ::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status VerifyNamesWithInterfaceArray(const ::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>& /*services*/, const ::std::vector<::android::String16>& /*names*/, bool* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status GetNullableInterfaceArray(const ::std::optional<::std::vector<::std::optional<::android::String16>>>& /*names*/, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status VerifyNamesWithNullableInterfaceArray(const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>& /*services*/, const ::std::optional<::std::vector<::std::optional<::android::String16>>>& /*names*/, bool* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status GetInterfaceList(const ::std::optional<::std::vector<::std::optional<::android::String16>>>& /*names*/, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status VerifyNamesWithInterfaceList(const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>& /*services*/, const ::std::optional<::std::vector<::std::optional<::android::String16>>>& /*names*/, bool* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseStringList(const ::std::vector<::android::String16>& /*input*/, ::std::vector<::android::String16>* /*repeated*/, ::std::vector<::android::String16>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatParcelFileDescriptor(const ::android::os::ParcelFileDescriptor& /*read*/, ::android::os::ParcelFileDescriptor* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseParcelFileDescriptorArray(const ::std::vector<::android::os::ParcelFileDescriptor>& /*input*/, ::std::vector<::android::os::ParcelFileDescriptor>* /*repeated*/, ::std::vector<::android::os::ParcelFileDescriptor>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ThrowServiceException(int32_t /*code*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatNullableIntArray(const ::std::optional<::std::vector>& /*input*/, ::std::optional<::std::vector>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatNullableByteEnumArray(const ::std::optional<::std::vector<::android::aidl::tests::ByteEnum>>& /*input*/, ::std::optional<::std::vector<::android::aidl::tests::ByteEnum>>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatNullableIntEnumArray(const ::std::optional<::std::vector<::android::aidl::tests::IntEnum>>& /*input*/, ::std::optional<::std::vector<::android::aidl::tests::IntEnum>>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatNullableLongEnumArray(const ::std::optional<::std::vector<::android::aidl::tests::LongEnum>>& /*input*/, ::std::optional<::std::vector<::android::aidl::tests::LongEnum>>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatNullableString(const ::std::optional<::android::String16>& /*input*/, ::std::optional<::android::String16>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatNullableStringList(const ::std::optional<::std::vector<::std::optional<::android::String16>>>& /*input*/, ::std::optional<::std::vector<::std::optional<::android::String16>>>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatNullableParcelable(const ::std::optional<::android::aidl::tests::ITestService::Empty>& /*input*/, ::std::optional<::android::aidl::tests::ITestService::Empty>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatNullableParcelableArray(const ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>& /*input*/, ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatNullableParcelableList(const ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>& /*input*/, ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status TakesAnIBinder(const ::android::sp<::android::IBinder>& /*input*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status TakesANullableIBinder(const ::android::sp<::android::IBinder>& /*input*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status TakesAnIBinderList(const ::std::vector<::android::sp<::android::IBinder>>& /*input*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status TakesANullableIBinderList(const ::std::optional<::std::vector<::android::sp<::android::IBinder>>>& /*input*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatUtf8CppString(const ::std::string& /*token*/, ::std::string* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatNullableUtf8CppString(const ::std::optional<::std::string>& /*token*/, ::std::optional<::std::string>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseUtf8CppString(const ::std::vector<::std::string>& /*input*/, ::std::vector<::std::string>* /*repeated*/, ::std::vector<::std::string>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseNullableUtf8CppString(const ::std::optional<::std::vector<::std::optional<::std::string>>>& /*input*/, ::std::optional<::std::vector<::std::optional<::std::string>>>* /*repeated*/, ::std::optional<::std::vector<::std::optional<::std::string>>>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseUtf8CppStringList(const ::std::optional<::std::vector<::std::optional<::std::string>>>& /*input*/, ::std::optional<::std::vector<::std::optional<::std::string>>>* /*repeated*/, ::std::optional<::std::vector<::std::optional<::std::string>>>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status GetCallback(bool /*return_null*/, ::android::sp<::android::aidl::tests::INamedCallback>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status FillOutStructuredParcelable(::android::aidl::tests::StructuredParcelable* /*parcel*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatExtendableParcelable(const ::android::aidl::tests::extension::ExtendableParcelable& /*ep*/, ::android::aidl::tests::extension::ExtendableParcelable* /*ep2*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseList(const ::android::aidl::tests::RecursiveList& /*list*/, ::android::aidl::tests::RecursiveList* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseIBinderArray(const ::std::vector<::android::sp<::android::IBinder>>& /*input*/, ::std::vector<::android::sp<::android::IBinder>>* /*repeated*/, ::std::vector<::android::sp<::android::IBinder>>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseNullableIBinderArray(const ::std::optional<::std::vector<::android::sp<::android::IBinder>>>& /*input*/, ::std::optional<::std::vector<::android::sp<::android::IBinder>>>* /*repeated*/, ::std::optional<::std::vector<::android::sp<::android::IBinder>>>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatSimpleParcelable(const ::android::aidl::tests::SimpleParcelable& /*input*/, ::android::aidl::tests::SimpleParcelable* /*repeat*/, ::android::aidl::tests::SimpleParcelable* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseSimpleParcelables(const ::std::vector<::android::aidl::tests::SimpleParcelable>& /*input*/, ::std::vector<::android::aidl::tests::SimpleParcelable>* /*repeated*/, ::std::vector<::android::aidl::tests::SimpleParcelable>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status GetOldNameInterface(::android::sp<::android::aidl::tests::IOldName>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status GetNewNameInterface(::android::sp<::android::aidl::tests::INewName>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status GetUnionTags(const ::std::vector<::android::aidl::tests::Union>& /*input*/, ::std::vector<::android::aidl::tests::Union::Tag>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status GetCppJavaTests(::android::sp<::android::IBinder>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status getBackendType(::android::aidl::tests::BackendType* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status GetCircular(::android::aidl::tests::CircularParcelable* /*cp*/, ::android::sp<::android::aidl::tests::ICircular>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } }; // class ITestServiceDefault } // namespace tests } // namespace aidl } // namespace android namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(ITestService::CompilerChecks::UsingHasDeprecated::Tag val) { switch(val) { case ITestService::CompilerChecks::UsingHasDeprecated::Tag::n: return "n"; case ITestService::CompilerChecks::UsingHasDeprecated::Tag::m: return "m"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::tests::ITestService::CompilerChecks::UsingHasDeprecated::Tag, 2> enum_values<::android::aidl::tests::ITestService::CompilerChecks::UsingHasDeprecated::Tag> = { ::android::aidl::tests::ITestService::CompilerChecks::UsingHasDeprecated::Tag::n, ::android::aidl::tests::ITestService::CompilerChecks::UsingHasDeprecated::Tag::m, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_In0100644 0000000 0000000 00000000034 15172120304 033210 xustar000000000 0000000 28 mtime=1776853188.4280000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/IntEnum.h0100644 0000000 0000000 00000003772 15172120304 031164 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/IntEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { enum class IntEnum : int32_t { FOO = 1000, BAR = 2000, BAZ = 2001, QUX __attribute__((deprecated("do not use this"))) = 2002, }; } // namespace tests } // namespace aidl } // namespace android namespace android { namespace aidl { namespace tests { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" [[nodiscard]] static inline std::string toString(IntEnum val) { switch(val) { case IntEnum::FOO: return "FOO"; case IntEnum::BAR: return "BAR"; case IntEnum::BAZ: return "BAZ"; case IntEnum::QUX: return "QUX"; default: return std::to_string(static_cast(val)); } } #pragma clang diagnostic pop } // namespace tests } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" #pragma clang diagnostic ignored "-Wdeprecated-declarations" template <> constexpr inline std::array<::android::aidl::tests::IntEnum, 4> enum_values<::android::aidl::tests::IntEnum> = { ::android::aidl::tests::IntEnum::FOO, ::android::aidl::tests::IntEnum::BAR, ::android::aidl::tests::IntEnum::BAZ, ::android::aidl::tests::IntEnum::QUX, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Li0100644 0000000 0000000 00000000212 15172120304 033204 xustar000000000 0000000 110 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/ListOfInterfaces.h 28 mtime=1776853188.4280000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/ListOfInterfaces.h0100644 0000000 0000000 00000043426 15172120304 033011 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ListOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ListOfInterfaces.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace android { namespace aidl { namespace tests { class ListOfInterfaces : public ::android::Parcelable { public: class IEmptyInterfaceDelegator; class IEmptyInterface : public ::android::IInterface { public: typedef IEmptyInterfaceDelegator DefaultDelegator; DECLARE_META_INTERFACE(EmptyInterface) }; // class IEmptyInterface class IEmptyInterfaceDefault : public IEmptyInterface { public: ::android::IBinder* onAsBinder() override { return nullptr; } }; // class IEmptyInterfaceDefault class BpEmptyInterface : public ::android::BpInterface { public: explicit BpEmptyInterface(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpEmptyInterface() = default; }; // class BpEmptyInterface class BnEmptyInterface : public ::android::BnInterface { public: explicit BnEmptyInterface(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnEmptyInterface class IEmptyInterfaceDelegator : public BnEmptyInterface { public: explicit IEmptyInterfaceDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } private: ::android::sp _aidl_delegate; }; // class IEmptyInterfaceDelegator class IMyInterfaceDelegator; class IMyInterface : public ::android::IInterface { public: typedef IMyInterfaceDelegator DefaultDelegator; DECLARE_META_INTERFACE(MyInterface) virtual ::android::binder::Status methodWithInterfaces(const ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& iface, const ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& nullable_iface, const ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>& iface_list_in, ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>* iface_list_out, ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>* iface_list_inout, const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>& nullable_iface_list_in, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>* nullable_iface_list_out, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>* nullable_iface_list_inout, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>* _aidl_return) = 0; }; // class IMyInterface class IMyInterfaceDefault : public IMyInterface { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status methodWithInterfaces(const ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& /*iface*/, const ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& /*nullable_iface*/, const ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>& /*iface_list_in*/, ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>* /*iface_list_out*/, ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>* /*iface_list_inout*/, const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>& /*nullable_iface_list_in*/, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>* /*nullable_iface_list_out*/, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>* /*nullable_iface_list_inout*/, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } }; // class IMyInterfaceDefault class BpMyInterface : public ::android::BpInterface { public: explicit BpMyInterface(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpMyInterface() = default; ::android::binder::Status methodWithInterfaces(const ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& iface, const ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& nullable_iface, const ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>& iface_list_in, ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>* iface_list_out, ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>* iface_list_inout, const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>& nullable_iface_list_in, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>* nullable_iface_list_out, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>* nullable_iface_list_inout, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>* _aidl_return) override; }; // class BpMyInterface class BnMyInterface : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_methodWithInterfaces = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; explicit BnMyInterface(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnMyInterface class IMyInterfaceDelegator : public BnMyInterface { public: explicit IMyInterfaceDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status methodWithInterfaces(const ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& iface, const ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& nullable_iface, const ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>& iface_list_in, ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>* iface_list_out, ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>* iface_list_inout, const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>& nullable_iface_list_in, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>* nullable_iface_list_out, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>* nullable_iface_list_inout, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>* _aidl_return) override { ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterfaceDelegator> _iface; if (iface) { _iface = ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterfaceDelegator>::cast(delegate(iface)); } ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterfaceDelegator> _nullable_iface; if (nullable_iface) { _nullable_iface = ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterfaceDelegator>::cast(delegate(nullable_iface)); } return _aidl_delegate->methodWithInterfaces(_iface, _nullable_iface, iface_list_in, iface_list_out, iface_list_inout, nullable_iface_list_in, nullable_iface_list_out, nullable_iface_list_inout, _aidl_return); } private: ::android::sp _aidl_delegate; }; // class IMyInterfaceDelegator class MyParcelable : public ::android::Parcelable { public: ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface> iface; ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface> nullable_iface; ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>> iface_list; ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>> nullable_iface_list; inline bool operator==(const MyParcelable& _rhs) const { return std::tie(iface, nullable_iface, iface_list, nullable_iface_list) == std::tie(_rhs.iface, _rhs.nullable_iface, _rhs.iface_list, _rhs.nullable_iface_list); } inline bool operator<(const MyParcelable& _rhs) const { return std::tie(iface, nullable_iface, iface_list, nullable_iface_list) < std::tie(_rhs.iface, _rhs.nullable_iface, _rhs.iface_list, _rhs.nullable_iface_list); } inline bool operator!=(const MyParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyParcelable& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.ListOfInterfaces.MyParcelable"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "MyParcelable{"; _aidl_os << "iface: " << ::android::internal::ToString(iface); _aidl_os << ", nullable_iface: " << ::android::internal::ToString(nullable_iface); _aidl_os << ", iface_list: " << ::android::internal::ToString(iface_list); _aidl_os << ", nullable_iface_list: " << ::android::internal::ToString(nullable_iface_list); _aidl_os << "}"; return _aidl_os.str(); } }; // class MyParcelable class MyUnion : public ::android::Parcelable { public: enum class Tag : int32_t { iface = 0, nullable_iface = 1, iface_list = 2, nullable_iface_list = 3, }; // Expose tag symbols for legacy code static const inline Tag iface = Tag::iface; static const inline Tag nullable_iface = Tag::nullable_iface; static const inline Tag iface_list = Tag::iface_list; static const inline Tag nullable_iface_list = Tag::nullable_iface_list; template static constexpr bool _not_self = !std::is_same_v>, MyUnion>; MyUnion() : _value(std::in_place_index(iface)>, ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>()) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr MyUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit MyUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static MyUnion make(_Tp&&... _args) { return MyUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static MyUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return MyUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } inline bool operator==(const MyUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const MyUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const MyUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyUnion& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.ListOfInterfaces.MyUnion"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream os; os << "MyUnion{"; switch (getTag()) { case iface: os << "iface: " << ::android::internal::ToString(get()); break; case nullable_iface: os << "nullable_iface: " << ::android::internal::ToString(get()); break; case iface_list: os << "iface_list: " << ::android::internal::ToString(get()); break; case nullable_iface_list: os << "nullable_iface_list: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>, ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>, ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>> _value; }; // class MyUnion inline bool operator==(const ListOfInterfaces&) const { return std::tie() == std::tie(); } inline bool operator<(const ListOfInterfaces&) const { return std::tie() < std::tie(); } inline bool operator!=(const ListOfInterfaces& _rhs) const { return !(*this == _rhs); } inline bool operator>(const ListOfInterfaces& _rhs) const { return _rhs < *this; } inline bool operator>=(const ListOfInterfaces& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const ListOfInterfaces& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.ListOfInterfaces"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "ListOfInterfaces{"; _aidl_os << "}"; return _aidl_os.str(); } }; // class ListOfInterfaces } // namespace tests } // namespace aidl } // namespace android namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(ListOfInterfaces::MyUnion::Tag val) { switch(val) { case ListOfInterfaces::MyUnion::Tag::iface: return "iface"; case ListOfInterfaces::MyUnion::Tag::nullable_iface: return "nullable_iface"; case ListOfInterfaces::MyUnion::Tag::iface_list: return "iface_list"; case ListOfInterfaces::MyUnion::Tag::nullable_iface_list: return "nullable_iface_list"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::tests::ListOfInterfaces::MyUnion::Tag, 4> enum_values<::android::aidl::tests::ListOfInterfaces::MyUnion::Tag> = { ::android::aidl::tests::ListOfInterfaces::MyUnion::Tag::iface, ::android::aidl::tests::ListOfInterfaces::MyUnion::Tag::nullable_iface, ::android::aidl::tests::ListOfInterfaces::MyUnion::Tag::iface_list, ::android::aidl::tests::ListOfInterfaces::MyUnion::Tag::nullable_iface_list, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Lo0100644 0000000 0000000 00000000034 15172120304 033214 xustar000000000 0000000 28 mtime=1776853188.4280000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/LongEnum.h0100644 0000000 0000000 00000003340 15172120304 031320 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/LongEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { enum class LongEnum : int64_t { FOO = 100000000000L, BAR = 200000000000L, BAZ = 200000000001L, }; } // namespace tests } // namespace aidl } // namespace android namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(LongEnum val) { switch(val) { case LongEnum::FOO: return "FOO"; case LongEnum::BAR: return "BAR"; case LongEnum::BAZ: return "BAZ"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::tests::LongEnum, 3> enum_values<::android::aidl::tests::LongEnum> = { ::android::aidl::tests::LongEnum::FOO, ::android::aidl::tests::LongEnum::BAR, ::android::aidl::tests::LongEnum::BAZ, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Ot0100644 0000000 0000000 00000000224 15172120304 033225 xustar000000000 0000000 120 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/OtherParcelableForToString.h 28 mtime=1776853188.4290000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/OtherParcelableFor0100644 0000000 0000000 00000004415 15172120304 033055 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/OtherParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl */ #pragma once #include #include #include #include #include namespace android { namespace aidl { namespace tests { class OtherParcelableForToString : public ::android::Parcelable { public: ::android::String16 field; inline bool operator==(const OtherParcelableForToString& _rhs) const { return std::tie(field) == std::tie(_rhs.field); } inline bool operator<(const OtherParcelableForToString& _rhs) const { return std::tie(field) < std::tie(_rhs.field); } inline bool operator!=(const OtherParcelableForToString& _rhs) const { return !(*this == _rhs); } inline bool operator>(const OtherParcelableForToString& _rhs) const { return _rhs < *this; } inline bool operator>=(const OtherParcelableForToString& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const OtherParcelableForToString& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.OtherParcelableForToString"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "OtherParcelableForToString{"; _aidl_os << "field: " << ::android::internal::ToString(field); _aidl_os << "}"; return _aidl_os.str(); } }; // class OtherParcelableForToString } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Pa0100644 0000000 0000000 00000000217 15172120304 033205 xustar000000000 0000000 115 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/ParcelableForToString.h 28 mtime=1776853188.4290000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/ParcelableForToStr0100644 0000000 0000000 00000015460 15172120304 033051 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ParcelableForToString.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include namespace android::aidl::tests { template class GenericStructuredParcelable; class OtherParcelableForToString; class StructuredParcelable; } // namespace android::aidl::tests namespace android { namespace aidl { namespace tests { class ParcelableForToString : public ::android::Parcelable { public: int32_t intValue = 0; ::std::vector intArray; int64_t longValue = 0L; ::std::vector longArray; double doubleValue = 0.000000; ::std::vector doubleArray; float floatValue = 0.000000f; ::std::vector floatArray; int8_t byteValue = 0; ::std::vector byteArray; bool booleanValue = false; ::std::vector booleanArray; ::android::String16 stringValue; ::std::vector<::android::String16> stringArray; ::std::vector<::android::String16> stringList; ::android::aidl::tests::OtherParcelableForToString parcelableValue; ::std::vector<::android::aidl::tests::OtherParcelableForToString> parcelableArray; ::android::aidl::tests::IntEnum enumValue = ::android::aidl::tests::IntEnum::FOO; ::std::vector<::android::aidl::tests::IntEnum> enumArray; ::std::vector<::android::String16> nullArray; ::std::vector<::android::String16> nullList; ::android::aidl::tests::GenericStructuredParcelable parcelableGeneric; ::android::aidl::tests::Union unionValue; inline bool operator==(const ParcelableForToString& _rhs) const { return std::tie(intValue, intArray, longValue, longArray, doubleValue, doubleArray, floatValue, floatArray, byteValue, byteArray, booleanValue, booleanArray, stringValue, stringArray, stringList, parcelableValue, parcelableArray, enumValue, enumArray, nullArray, nullList, parcelableGeneric, unionValue) == std::tie(_rhs.intValue, _rhs.intArray, _rhs.longValue, _rhs.longArray, _rhs.doubleValue, _rhs.doubleArray, _rhs.floatValue, _rhs.floatArray, _rhs.byteValue, _rhs.byteArray, _rhs.booleanValue, _rhs.booleanArray, _rhs.stringValue, _rhs.stringArray, _rhs.stringList, _rhs.parcelableValue, _rhs.parcelableArray, _rhs.enumValue, _rhs.enumArray, _rhs.nullArray, _rhs.nullList, _rhs.parcelableGeneric, _rhs.unionValue); } inline bool operator<(const ParcelableForToString& _rhs) const { return std::tie(intValue, intArray, longValue, longArray, doubleValue, doubleArray, floatValue, floatArray, byteValue, byteArray, booleanValue, booleanArray, stringValue, stringArray, stringList, parcelableValue, parcelableArray, enumValue, enumArray, nullArray, nullList, parcelableGeneric, unionValue) < std::tie(_rhs.intValue, _rhs.intArray, _rhs.longValue, _rhs.longArray, _rhs.doubleValue, _rhs.doubleArray, _rhs.floatValue, _rhs.floatArray, _rhs.byteValue, _rhs.byteArray, _rhs.booleanValue, _rhs.booleanArray, _rhs.stringValue, _rhs.stringArray, _rhs.stringList, _rhs.parcelableValue, _rhs.parcelableArray, _rhs.enumValue, _rhs.enumArray, _rhs.nullArray, _rhs.nullList, _rhs.parcelableGeneric, _rhs.unionValue); } inline bool operator!=(const ParcelableForToString& _rhs) const { return !(*this == _rhs); } inline bool operator>(const ParcelableForToString& _rhs) const { return _rhs < *this; } inline bool operator>=(const ParcelableForToString& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const ParcelableForToString& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.ParcelableForToString"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "ParcelableForToString{"; _aidl_os << "intValue: " << ::android::internal::ToString(intValue); _aidl_os << ", intArray: " << ::android::internal::ToString(intArray); _aidl_os << ", longValue: " << ::android::internal::ToString(longValue); _aidl_os << ", longArray: " << ::android::internal::ToString(longArray); _aidl_os << ", doubleValue: " << ::android::internal::ToString(doubleValue); _aidl_os << ", doubleArray: " << ::android::internal::ToString(doubleArray); _aidl_os << ", floatValue: " << ::android::internal::ToString(floatValue); _aidl_os << ", floatArray: " << ::android::internal::ToString(floatArray); _aidl_os << ", byteValue: " << ::android::internal::ToString(byteValue); _aidl_os << ", byteArray: " << ::android::internal::ToString(byteArray); _aidl_os << ", booleanValue: " << ::android::internal::ToString(booleanValue); _aidl_os << ", booleanArray: " << ::android::internal::ToString(booleanArray); _aidl_os << ", stringValue: " << ::android::internal::ToString(stringValue); _aidl_os << ", stringArray: " << ::android::internal::ToString(stringArray); _aidl_os << ", stringList: " << ::android::internal::ToString(stringList); _aidl_os << ", parcelableValue: " << ::android::internal::ToString(parcelableValue); _aidl_os << ", parcelableArray: " << ::android::internal::ToString(parcelableArray); _aidl_os << ", enumValue: " << ::android::internal::ToString(enumValue); _aidl_os << ", enumArray: " << ::android::internal::ToString(enumArray); _aidl_os << ", nullArray: " << ::android::internal::ToString(nullArray); _aidl_os << ", nullList: " << ::android::internal::ToString(nullList); _aidl_os << ", parcelableGeneric: " << ::android::internal::ToString(parcelableGeneric); _aidl_os << ", unionValue: " << ::android::internal::ToString(unionValue); _aidl_os << "}"; return _aidl_os.str(); } }; // class ParcelableForToString } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Re0100644 0000000 0000000 00000000034 15172120304 033210 xustar000000000 0000000 28 mtime=1776853188.4290000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/RecursiveList.h0100644 0000000 0000000 00000004677 15172120304 032415 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/RecursiveList.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl */ #pragma once #include #include #include #include #include #include #include #include namespace android::aidl::tests { class RecursiveList; } // namespace android::aidl::tests namespace android { namespace aidl { namespace tests { class RecursiveList : public ::android::Parcelable { public: int32_t value = 0; ::std::unique_ptr<::android::aidl::tests::RecursiveList> next; inline bool operator==(const RecursiveList& _rhs) const { return std::tie(value, next) == std::tie(_rhs.value, _rhs.next); } inline bool operator<(const RecursiveList& _rhs) const { return std::tie(value, next) < std::tie(_rhs.value, _rhs.next); } inline bool operator!=(const RecursiveList& _rhs) const { return !(*this == _rhs); } inline bool operator>(const RecursiveList& _rhs) const { return _rhs < *this; } inline bool operator>=(const RecursiveList& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const RecursiveList& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.RecursiveList"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "RecursiveList{"; _aidl_os << "value: " << ::android::internal::ToString(value); _aidl_os << ", next: " << ::android::internal::ToString(next); _aidl_os << "}"; return _aidl_os.str(); } }; // class RecursiveList } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_St0100644 0000000 0000000 00000000216 15172120304 033232 xustar000000000 0000000 114 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/StructuredParcelable.h 28 mtime=1776853188.4310000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/StructuredParcelab0100644 0000000 0000000 00000037511 15172120304 033153 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/StructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace android { namespace aidl { namespace tests { class StructuredParcelable : public ::android::Parcelable { public: class Empty : public ::android::Parcelable { public: inline bool operator==(const Empty&) const { return std::tie() == std::tie(); } inline bool operator<(const Empty&) const { return std::tie() < std::tie(); } inline bool operator!=(const Empty& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Empty& _rhs) const { return _rhs < *this; } inline bool operator>=(const Empty& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Empty& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.StructuredParcelable.Empty"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "Empty{"; _aidl_os << "}"; return _aidl_os.str(); } }; // class Empty ::std::vector shouldContainThreeFs; int32_t f = 0; ::std::string shouldBeJerry; ::android::aidl::tests::ByteEnum shouldBeByteBar = ::android::aidl::tests::ByteEnum(0); ::android::aidl::tests::IntEnum shouldBeIntBar = ::android::aidl::tests::IntEnum(0); ::android::aidl::tests::LongEnum shouldBeLongBar = ::android::aidl::tests::LongEnum(0); ::std::vector<::android::aidl::tests::ByteEnum> shouldContainTwoByteFoos; ::std::vector<::android::aidl::tests::IntEnum> shouldContainTwoIntFoos; ::std::vector<::android::aidl::tests::LongEnum> shouldContainTwoLongFoos; ::android::String16 stringDefaultsToFoo = ::android::String16("foo"); int8_t byteDefaultsToFour = 4; int32_t intDefaultsToFive = 5; int64_t longDefaultsToNegativeSeven = -7L; bool booleanDefaultsToTrue = true; char16_t charDefaultsToC = 'C'; float floatDefaultsToPi = 3.140000f; double doubleWithDefault = -314000000000000000.000000; ::std::vector arrayDefaultsTo123 = {1, 2, 3}; ::std::vector arrayDefaultsToEmpty = {}; bool boolDefault = false; int8_t byteDefault = 0; int32_t intDefault = 0; int64_t longDefault = 0L; float floatDefault = 0.000000f; double doubleDefault = 0.000000; double checkDoubleFromFloat = 3.140000; ::std::vector<::android::String16> checkStringArray1 = {::android::String16("a"), ::android::String16("b")}; ::std::vector<::std::string> checkStringArray2 = {"a", "b"}; int32_t int32_min = -2147483648; int32_t int32_max = 2147483647; int64_t int64_max = 9223372036854775807L; int32_t hexInt32_neg_1 = -1; ::android::sp<::android::IBinder> ibinder; ::android::aidl::tests::StructuredParcelable::Empty empty; ::std::vector int8_1 = {1, 1, 1, 1, 1}; ::std::vector int32_1 = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}; ::std::vector int64_1 = {1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L}; int32_t hexInt32_pos_1 = 1; int32_t hexInt64_pos_1 = 1; ::android::aidl::tests::ConstantExpressionEnum const_exprs_1 = ::android::aidl::tests::ConstantExpressionEnum(0); ::android::aidl::tests::ConstantExpressionEnum const_exprs_2 = ::android::aidl::tests::ConstantExpressionEnum(0); ::android::aidl::tests::ConstantExpressionEnum const_exprs_3 = ::android::aidl::tests::ConstantExpressionEnum(0); ::android::aidl::tests::ConstantExpressionEnum const_exprs_4 = ::android::aidl::tests::ConstantExpressionEnum(0); ::android::aidl::tests::ConstantExpressionEnum const_exprs_5 = ::android::aidl::tests::ConstantExpressionEnum(0); ::android::aidl::tests::ConstantExpressionEnum const_exprs_6 = ::android::aidl::tests::ConstantExpressionEnum(0); ::android::aidl::tests::ConstantExpressionEnum const_exprs_7 = ::android::aidl::tests::ConstantExpressionEnum(0); ::android::aidl::tests::ConstantExpressionEnum const_exprs_8 = ::android::aidl::tests::ConstantExpressionEnum(0); ::android::aidl::tests::ConstantExpressionEnum const_exprs_9 = ::android::aidl::tests::ConstantExpressionEnum(0); ::android::aidl::tests::ConstantExpressionEnum const_exprs_10 = ::android::aidl::tests::ConstantExpressionEnum(0); ::std::string addString1 = "hello world!"; ::std::string addString2 = "The quick brown fox jumps over the lazy dog."; int32_t shouldSetBit0AndBit2 = 0; ::std::optional<::android::aidl::tests::Union> u; ::std::optional<::android::aidl::tests::Union> shouldBeConstS1; ::android::aidl::tests::IntEnum defaultWithFoo = ::android::aidl::tests::IntEnum::FOO; inline bool operator==(const StructuredParcelable& _rhs) const { return std::tie(shouldContainThreeFs, f, shouldBeJerry, shouldBeByteBar, shouldBeIntBar, shouldBeLongBar, shouldContainTwoByteFoos, shouldContainTwoIntFoos, shouldContainTwoLongFoos, stringDefaultsToFoo, byteDefaultsToFour, intDefaultsToFive, longDefaultsToNegativeSeven, booleanDefaultsToTrue, charDefaultsToC, floatDefaultsToPi, doubleWithDefault, arrayDefaultsTo123, arrayDefaultsToEmpty, boolDefault, byteDefault, intDefault, longDefault, floatDefault, doubleDefault, checkDoubleFromFloat, checkStringArray1, checkStringArray2, int32_min, int32_max, int64_max, hexInt32_neg_1, ibinder, empty, int8_1, int32_1, int64_1, hexInt32_pos_1, hexInt64_pos_1, const_exprs_1, const_exprs_2, const_exprs_3, const_exprs_4, const_exprs_5, const_exprs_6, const_exprs_7, const_exprs_8, const_exprs_9, const_exprs_10, addString1, addString2, shouldSetBit0AndBit2, u, shouldBeConstS1, defaultWithFoo) == std::tie(_rhs.shouldContainThreeFs, _rhs.f, _rhs.shouldBeJerry, _rhs.shouldBeByteBar, _rhs.shouldBeIntBar, _rhs.shouldBeLongBar, _rhs.shouldContainTwoByteFoos, _rhs.shouldContainTwoIntFoos, _rhs.shouldContainTwoLongFoos, _rhs.stringDefaultsToFoo, _rhs.byteDefaultsToFour, _rhs.intDefaultsToFive, _rhs.longDefaultsToNegativeSeven, _rhs.booleanDefaultsToTrue, _rhs.charDefaultsToC, _rhs.floatDefaultsToPi, _rhs.doubleWithDefault, _rhs.arrayDefaultsTo123, _rhs.arrayDefaultsToEmpty, _rhs.boolDefault, _rhs.byteDefault, _rhs.intDefault, _rhs.longDefault, _rhs.floatDefault, _rhs.doubleDefault, _rhs.checkDoubleFromFloat, _rhs.checkStringArray1, _rhs.checkStringArray2, _rhs.int32_min, _rhs.int32_max, _rhs.int64_max, _rhs.hexInt32_neg_1, _rhs.ibinder, _rhs.empty, _rhs.int8_1, _rhs.int32_1, _rhs.int64_1, _rhs.hexInt32_pos_1, _rhs.hexInt64_pos_1, _rhs.const_exprs_1, _rhs.const_exprs_2, _rhs.const_exprs_3, _rhs.const_exprs_4, _rhs.const_exprs_5, _rhs.const_exprs_6, _rhs.const_exprs_7, _rhs.const_exprs_8, _rhs.const_exprs_9, _rhs.const_exprs_10, _rhs.addString1, _rhs.addString2, _rhs.shouldSetBit0AndBit2, _rhs.u, _rhs.shouldBeConstS1, _rhs.defaultWithFoo); } inline bool operator<(const StructuredParcelable& _rhs) const { return std::tie(shouldContainThreeFs, f, shouldBeJerry, shouldBeByteBar, shouldBeIntBar, shouldBeLongBar, shouldContainTwoByteFoos, shouldContainTwoIntFoos, shouldContainTwoLongFoos, stringDefaultsToFoo, byteDefaultsToFour, intDefaultsToFive, longDefaultsToNegativeSeven, booleanDefaultsToTrue, charDefaultsToC, floatDefaultsToPi, doubleWithDefault, arrayDefaultsTo123, arrayDefaultsToEmpty, boolDefault, byteDefault, intDefault, longDefault, floatDefault, doubleDefault, checkDoubleFromFloat, checkStringArray1, checkStringArray2, int32_min, int32_max, int64_max, hexInt32_neg_1, ibinder, empty, int8_1, int32_1, int64_1, hexInt32_pos_1, hexInt64_pos_1, const_exprs_1, const_exprs_2, const_exprs_3, const_exprs_4, const_exprs_5, const_exprs_6, const_exprs_7, const_exprs_8, const_exprs_9, const_exprs_10, addString1, addString2, shouldSetBit0AndBit2, u, shouldBeConstS1, defaultWithFoo) < std::tie(_rhs.shouldContainThreeFs, _rhs.f, _rhs.shouldBeJerry, _rhs.shouldBeByteBar, _rhs.shouldBeIntBar, _rhs.shouldBeLongBar, _rhs.shouldContainTwoByteFoos, _rhs.shouldContainTwoIntFoos, _rhs.shouldContainTwoLongFoos, _rhs.stringDefaultsToFoo, _rhs.byteDefaultsToFour, _rhs.intDefaultsToFive, _rhs.longDefaultsToNegativeSeven, _rhs.booleanDefaultsToTrue, _rhs.charDefaultsToC, _rhs.floatDefaultsToPi, _rhs.doubleWithDefault, _rhs.arrayDefaultsTo123, _rhs.arrayDefaultsToEmpty, _rhs.boolDefault, _rhs.byteDefault, _rhs.intDefault, _rhs.longDefault, _rhs.floatDefault, _rhs.doubleDefault, _rhs.checkDoubleFromFloat, _rhs.checkStringArray1, _rhs.checkStringArray2, _rhs.int32_min, _rhs.int32_max, _rhs.int64_max, _rhs.hexInt32_neg_1, _rhs.ibinder, _rhs.empty, _rhs.int8_1, _rhs.int32_1, _rhs.int64_1, _rhs.hexInt32_pos_1, _rhs.hexInt64_pos_1, _rhs.const_exprs_1, _rhs.const_exprs_2, _rhs.const_exprs_3, _rhs.const_exprs_4, _rhs.const_exprs_5, _rhs.const_exprs_6, _rhs.const_exprs_7, _rhs.const_exprs_8, _rhs.const_exprs_9, _rhs.const_exprs_10, _rhs.addString1, _rhs.addString2, _rhs.shouldSetBit0AndBit2, _rhs.u, _rhs.shouldBeConstS1, _rhs.defaultWithFoo); } inline bool operator!=(const StructuredParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const StructuredParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const StructuredParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const StructuredParcelable& _rhs) const { return !(_rhs < *this); } enum : int32_t { BIT0 = 1 }; enum : int32_t { BIT1 = 2 }; enum : int32_t { BIT2 = 4 }; ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.StructuredParcelable"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "StructuredParcelable{"; _aidl_os << "shouldContainThreeFs: " << ::android::internal::ToString(shouldContainThreeFs); _aidl_os << ", f: " << ::android::internal::ToString(f); _aidl_os << ", shouldBeJerry: " << ::android::internal::ToString(shouldBeJerry); _aidl_os << ", shouldBeByteBar: " << ::android::internal::ToString(shouldBeByteBar); _aidl_os << ", shouldBeIntBar: " << ::android::internal::ToString(shouldBeIntBar); _aidl_os << ", shouldBeLongBar: " << ::android::internal::ToString(shouldBeLongBar); _aidl_os << ", shouldContainTwoByteFoos: " << ::android::internal::ToString(shouldContainTwoByteFoos); _aidl_os << ", shouldContainTwoIntFoos: " << ::android::internal::ToString(shouldContainTwoIntFoos); _aidl_os << ", shouldContainTwoLongFoos: " << ::android::internal::ToString(shouldContainTwoLongFoos); _aidl_os << ", stringDefaultsToFoo: " << ::android::internal::ToString(stringDefaultsToFoo); _aidl_os << ", byteDefaultsToFour: " << ::android::internal::ToString(byteDefaultsToFour); _aidl_os << ", intDefaultsToFive: " << ::android::internal::ToString(intDefaultsToFive); _aidl_os << ", longDefaultsToNegativeSeven: " << ::android::internal::ToString(longDefaultsToNegativeSeven); _aidl_os << ", booleanDefaultsToTrue: " << ::android::internal::ToString(booleanDefaultsToTrue); _aidl_os << ", charDefaultsToC: " << ::android::internal::ToString(charDefaultsToC); _aidl_os << ", floatDefaultsToPi: " << ::android::internal::ToString(floatDefaultsToPi); _aidl_os << ", doubleWithDefault: " << ::android::internal::ToString(doubleWithDefault); _aidl_os << ", arrayDefaultsTo123: " << ::android::internal::ToString(arrayDefaultsTo123); _aidl_os << ", arrayDefaultsToEmpty: " << ::android::internal::ToString(arrayDefaultsToEmpty); _aidl_os << ", boolDefault: " << ::android::internal::ToString(boolDefault); _aidl_os << ", byteDefault: " << ::android::internal::ToString(byteDefault); _aidl_os << ", intDefault: " << ::android::internal::ToString(intDefault); _aidl_os << ", longDefault: " << ::android::internal::ToString(longDefault); _aidl_os << ", floatDefault: " << ::android::internal::ToString(floatDefault); _aidl_os << ", doubleDefault: " << ::android::internal::ToString(doubleDefault); _aidl_os << ", checkDoubleFromFloat: " << ::android::internal::ToString(checkDoubleFromFloat); _aidl_os << ", checkStringArray1: " << ::android::internal::ToString(checkStringArray1); _aidl_os << ", checkStringArray2: " << ::android::internal::ToString(checkStringArray2); _aidl_os << ", int32_min: " << ::android::internal::ToString(int32_min); _aidl_os << ", int32_max: " << ::android::internal::ToString(int32_max); _aidl_os << ", int64_max: " << ::android::internal::ToString(int64_max); _aidl_os << ", hexInt32_neg_1: " << ::android::internal::ToString(hexInt32_neg_1); _aidl_os << ", ibinder: " << ::android::internal::ToString(ibinder); _aidl_os << ", empty: " << ::android::internal::ToString(empty); _aidl_os << ", int8_1: " << ::android::internal::ToString(int8_1); _aidl_os << ", int32_1: " << ::android::internal::ToString(int32_1); _aidl_os << ", int64_1: " << ::android::internal::ToString(int64_1); _aidl_os << ", hexInt32_pos_1: " << ::android::internal::ToString(hexInt32_pos_1); _aidl_os << ", hexInt64_pos_1: " << ::android::internal::ToString(hexInt64_pos_1); _aidl_os << ", const_exprs_1: " << ::android::internal::ToString(const_exprs_1); _aidl_os << ", const_exprs_2: " << ::android::internal::ToString(const_exprs_2); _aidl_os << ", const_exprs_3: " << ::android::internal::ToString(const_exprs_3); _aidl_os << ", const_exprs_4: " << ::android::internal::ToString(const_exprs_4); _aidl_os << ", const_exprs_5: " << ::android::internal::ToString(const_exprs_5); _aidl_os << ", const_exprs_6: " << ::android::internal::ToString(const_exprs_6); _aidl_os << ", const_exprs_7: " << ::android::internal::ToString(const_exprs_7); _aidl_os << ", const_exprs_8: " << ::android::internal::ToString(const_exprs_8); _aidl_os << ", const_exprs_9: " << ::android::internal::ToString(const_exprs_9); _aidl_os << ", const_exprs_10: " << ::android::internal::ToString(const_exprs_10); _aidl_os << ", addString1: " << ::android::internal::ToString(addString1); _aidl_os << ", addString2: " << ::android::internal::ToString(addString2); _aidl_os << ", shouldSetBit0AndBit2: " << ::android::internal::ToString(shouldSetBit0AndBit2); _aidl_os << ", u: " << ::android::internal::ToString(u); _aidl_os << ", shouldBeConstS1: " << ::android::internal::ToString(shouldBeConstS1); _aidl_os << ", defaultWithFoo: " << ::android::internal::ToString(defaultWithFoo); _aidl_os << "}"; return _aidl_os.str(); } }; // class StructuredParcelable } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Un0100644 0000000 0000000 00000000034 15172120304 033224 xustar000000000 0000000 28 mtime=1776853188.4320000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/Union.h0100644 0000000 0000000 00000014265 15172120304 030674 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/Union.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/Union.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace android { namespace aidl { namespace tests { class Union : public ::android::Parcelable { public: enum class Tag : int32_t { ns = 0, n = 1, m = 2, s = 3, ibinder = 4, ss = 5, be = 6, }; // Expose tag symbols for legacy code static const inline Tag ns = Tag::ns; static const inline Tag n = Tag::n; static const inline Tag m = Tag::m; static const inline Tag s = Tag::s; static const inline Tag ibinder = Tag::ibinder; static const inline Tag ss = Tag::ss; static const inline Tag be = Tag::be; template static constexpr bool _not_self = !std::is_same_v>, Union>; Union() : _value(std::in_place_index(ns)>, ::std::vector({})) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr Union(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit Union(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static Union make(_Tp&&... _args) { return Union(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static Union make(std::initializer_list<_Tp> _il, _Up&&... _args) { return Union(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } inline bool operator==(const Union& _rhs) const { return _value == _rhs._value; } inline bool operator<(const Union& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const Union& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Union& _rhs) const { return _rhs < *this; } inline bool operator>=(const Union& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Union& _rhs) const { return !(_rhs < *this); } static const ::std::string& S1(); ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.Union"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream os; os << "Union{"; switch (getTag()) { case ns: os << "ns: " << ::android::internal::ToString(get()); break; case n: os << "n: " << ::android::internal::ToString(get()); break; case m: os << "m: " << ::android::internal::ToString(get()); break; case s: os << "s: " << ::android::internal::ToString(get()); break; case ibinder: os << "ibinder: " << ::android::internal::ToString(get()); break; case ss: os << "ss: " << ::android::internal::ToString(get()); break; case be: os << "be: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant<::std::vector, int32_t, int32_t, ::std::string, ::android::sp<::android::IBinder>, ::std::vector<::std::string>, ::android::aidl::tests::ByteEnum> _value; }; // class Union } // namespace tests } // namespace aidl } // namespace android namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(Union::Tag val) { switch(val) { case Union::Tag::ns: return "ns"; case Union::Tag::n: return "n"; case Union::Tag::m: return "m"; case Union::Tag::s: return "s"; case Union::Tag::ibinder: return "ibinder"; case Union::Tag::ss: return "ss"; case Union::Tag::be: return "be"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::tests::Union::Tag, 7> enum_values<::android::aidl::tests::Union::Tag> = { ::android::aidl::tests::Union::Tag::ns, ::android::aidl::tests::Union::Tag::n, ::android::aidl::tests::Union::Tag::m, ::android::aidl::tests::Union::Tag::s, ::android::aidl::tests::Union::Tag::ibinder, ::android::aidl::tests::Union::Tag::ss, ::android::aidl::tests::Union::Tag::be, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_Un0100644 0000000 0000000 00000000034 15172120304 033224 xustar000000000 0000000 28 mtime=1776853188.4320000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/UnionWithFd.h0100644 0000000 0000000 00000012144 15172120304 031774 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/UnionWithFd.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/UnionWithFd.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace android { namespace aidl { namespace tests { class UnionWithFd : public ::android::Parcelable { public: enum class Tag : int32_t { num = 0, pfd = 1, }; // Expose tag symbols for legacy code static const inline Tag num = Tag::num; static const inline Tag pfd = Tag::pfd; template static constexpr bool _not_self = !std::is_same_v>, UnionWithFd>; UnionWithFd() : _value(std::in_place_index(num)>, int32_t(0)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr UnionWithFd(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit UnionWithFd(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static UnionWithFd make(_Tp&&... _args) { return UnionWithFd(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static UnionWithFd make(std::initializer_list<_Tp> _il, _Up&&... _args) { return UnionWithFd(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } inline bool operator==(const UnionWithFd& _rhs) const { return _value == _rhs._value; } inline bool operator<(const UnionWithFd& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const UnionWithFd& _rhs) const { return !(*this == _rhs); } inline bool operator>(const UnionWithFd& _rhs) const { return _rhs < *this; } inline bool operator>=(const UnionWithFd& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const UnionWithFd& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.UnionWithFd"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream os; os << "UnionWithFd{"; switch (getTag()) { case num: os << "num: " << ::android::internal::ToString(get()); break; case pfd: os << "pfd: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant _value; }; // class UnionWithFd } // namespace tests } // namespace aidl } // namespace android namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(UnionWithFd::Tag val) { switch(val) { case UnionWithFd::Tag::num: return "num"; case UnionWithFd::Tag::pfd: return "pfd"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::tests::UnionWithFd::Tag, 2> enum_values<::android::aidl::tests::UnionWithFd::Tag> = { ::android::aidl::tests::UnionWithFd::Tag::num, ::android::aidl::tests::UnionWithFd::Tag::pfd, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_ex0100644 0000000 0000000 00000000034 15172120304 033256 xustar000000000 0000000 28 mtime=1776853188.4320000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/0040755 0000000 0000000 00000000000 15172120304 031442 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_ex0100644 0000000 0000000 00000000232 15172120304 033256 xustar000000000 0000000 126 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/BnExtendableParcelable.h 28 mtime=1776853188.4320000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/BnExtend0100644 0000000 0000000 00000001264 15172120304 033074 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/extension/ExtendableParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_ex0100644 0000000 0000000 00000000213 15172120304 033255 xustar000000000 0000000 111 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/BnMyExt.h 28 mtime=1776853188.4320000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/BnMyExt.0100644 0000000 0000000 00000001226 15172120304 032767 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/extension/MyExt.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_ex0100644 0000000 0000000 00000000214 15172120304 033256 xustar000000000 0000000 112 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/BnMyExt2.h 28 mtime=1776853188.4330000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/BnMyExt20100644 0000000 0000000 00000001230 15172120304 032766 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/extension/MyExt2.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt2.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_ex0100644 0000000 0000000 00000000217 15172120304 033261 xustar000000000 0000000 115 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/BnMyExtLike.h 28 mtime=1776853188.4330000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/BnMyExtL0100644 0000000 0000000 00000001236 15172120304 033026 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/extension/MyExtLike.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExtLike.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_ex0100644 0000000 0000000 00000000232 15172120304 033256 xustar000000000 0000000 126 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/BpExtendableParcelable.h 28 mtime=1776853188.4330000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/BpExtend0100644 0000000 0000000 00000001264 15172120304 033076 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/extension/ExtendableParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_ex0100644 0000000 0000000 00000000213 15172120304 033255 xustar000000000 0000000 111 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/BpMyExt.h 28 mtime=1776853188.4330000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/BpMyExt.0100644 0000000 0000000 00000001226 15172120304 032771 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/extension/MyExt.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_ex0100644 0000000 0000000 00000000214 15172120304 033256 xustar000000000 0000000 112 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/BpMyExt2.h 28 mtime=1776853188.4330000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/BpMyExt20100644 0000000 0000000 00000001230 15172120304 032770 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/extension/MyExt2.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt2.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_ex0100644 0000000 0000000 00000000217 15172120304 033261 xustar000000000 0000000 115 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/BpMyExtLike.h 28 mtime=1776853188.4330000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/BpMyExtL0100644 0000000 0000000 00000001236 15172120304 033030 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/extension/MyExtLike.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExtLike.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_ex0100644 0000000 0000000 00000000230 15172120304 033254 xustar000000000 0000000 124 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/ExtendableParcelable.h 28 mtime=1776853188.4330000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/Extendab0100644 0000000 0000000 00000005603 15172120304 033120 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/extension/ExtendableParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl */ #pragma once #include #include #include #include #include #include #include #include namespace android { namespace aidl { namespace tests { namespace extension { class ExtendableParcelable : public ::android::Parcelable { public: int32_t a = 0; ::std::string b; ::android::os::ParcelableHolder ext { ::android::Parcelable::Stability::STABILITY_LOCAL }; int64_t c = 0L; ::android::os::ParcelableHolder ext2 { ::android::Parcelable::Stability::STABILITY_LOCAL }; inline bool operator==(const ExtendableParcelable& _rhs) const { return std::tie(a, b, ext, c, ext2) == std::tie(_rhs.a, _rhs.b, _rhs.ext, _rhs.c, _rhs.ext2); } inline bool operator<(const ExtendableParcelable& _rhs) const { return std::tie(a, b, ext, c, ext2) < std::tie(_rhs.a, _rhs.b, _rhs.ext, _rhs.c, _rhs.ext2); } inline bool operator!=(const ExtendableParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const ExtendableParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const ExtendableParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const ExtendableParcelable& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.extension.ExtendableParcelable"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "ExtendableParcelable{"; _aidl_os << "a: " << ::android::internal::ToString(a); _aidl_os << ", b: " << ::android::internal::ToString(b); _aidl_os << ", ext: " << ::android::internal::ToString(ext); _aidl_os << ", c: " << ::android::internal::ToString(c); _aidl_os << ", ext2: " << ::android::internal::ToString(ext2); _aidl_os << "}"; return _aidl_os.str(); } }; // class ExtendableParcelable } // namespace extension } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_ex0100644 0000000 0000000 00000000034 15172120304 033256 xustar000000000 0000000 28 mtime=1776853188.4330000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/MyExt.h0100644 0000000 0000000 00000004306 15172120304 032661 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/extension/MyExt.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl */ #pragma once #include #include #include #include #include #include #include namespace android { namespace aidl { namespace tests { namespace extension { class MyExt : public ::android::Parcelable { public: int32_t a = 0; ::std::string b; inline bool operator==(const MyExt& _rhs) const { return std::tie(a, b) == std::tie(_rhs.a, _rhs.b); } inline bool operator<(const MyExt& _rhs) const { return std::tie(a, b) < std::tie(_rhs.a, _rhs.b); } inline bool operator!=(const MyExt& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyExt& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyExt& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyExt& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.extension.MyExt"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "MyExt{"; _aidl_os << "a: " << ::android::internal::ToString(a); _aidl_os << ", b: " << ::android::internal::ToString(b); _aidl_os << "}"; return _aidl_os.str(); } }; // class MyExt } // namespace extension } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_ex0100644 0000000 0000000 00000000212 15172120304 033254 xustar000000000 0000000 110 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/MyExt2.h 28 mtime=1776853188.4330000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/MyExt2.h0100644 0000000 0000000 00000004754 15172120304 032752 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/extension/MyExt2.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt2.aidl */ #pragma once #include #include #include #include #include #include #include #include namespace android::aidl::tests::extension { class MyExt; } // namespace android::aidl::tests::extension namespace android { namespace aidl { namespace tests { namespace extension { class MyExt2 : public ::android::Parcelable { public: int32_t a = 0; ::android::aidl::tests::extension::MyExt b; ::std::string c; inline bool operator==(const MyExt2& _rhs) const { return std::tie(a, b, c) == std::tie(_rhs.a, _rhs.b, _rhs.c); } inline bool operator<(const MyExt2& _rhs) const { return std::tie(a, b, c) < std::tie(_rhs.a, _rhs.b, _rhs.c); } inline bool operator!=(const MyExt2& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyExt2& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyExt2& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyExt2& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.extension.MyExt2"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "MyExt2{"; _aidl_os << "a: " << ::android::internal::ToString(a); _aidl_os << ", b: " << ::android::internal::ToString(b); _aidl_os << ", c: " << ::android::internal::ToString(c); _aidl_os << "}"; return _aidl_os.str(); } }; // class MyExt2 } // namespace extension } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_ex0100644 0000000 0000000 00000000215 15172120304 033257 xustar000000000 0000000 113 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/MyExtLike.h 28 mtime=1776853188.4330000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/MyExtLik0100644 0000000 0000000 00000004352 15172120304 033074 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/extension/MyExtLike.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExtLike.aidl */ #pragma once #include #include #include #include #include #include namespace android { namespace aidl { namespace tests { namespace extension { class MyExtLike : public ::android::Parcelable { public: int32_t a = 0; ::android::String16 b; inline bool operator==(const MyExtLike& _rhs) const { return std::tie(a, b) == std::tie(_rhs.a, _rhs.b); } inline bool operator<(const MyExtLike& _rhs) const { return std::tie(a, b) < std::tie(_rhs.a, _rhs.b); } inline bool operator!=(const MyExtLike& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyExtLike& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyExtLike& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyExtLike& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.extension.MyExtLike"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "MyExtLike{"; _aidl_os << "a: " << ::android::internal::ToString(a); _aidl_os << ", b: " << ::android::internal::ToString(b); _aidl_os << "}"; return _aidl_os.str(); } }; // class MyExtLike } // namespace extension } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_ne0100644 0000000 0000000 00000000034 15172120304 033244 xustar000000000 0000000 28 mtime=1776853188.4330000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/0040755 0000000 0000000 00000000000 15172120304 030710 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_ne0100644 0000000 0000000 00000000217 15172120304 033247 xustar000000000 0000000 115 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/BnDeeplyNested.h 28 mtime=1776853188.4330000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/BnDeeplyNes0100644 0000000 0000000 00000001236 15172120304 033002 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/nested/DeeplyNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/DeeplyNested.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_ne0100644 0000000 0000000 00000000220 15172120304 033241 xustar000000000 0000000 116 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/BnNestedService.h 28 mtime=1776853188.4330000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/BnNestedSer0100644 0000000 0000000 00000005064 15172120304 033011 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/nested/INestedService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/INestedService.aidl */ #pragma once #include #include #include #include #include namespace android { namespace aidl { namespace tests { namespace nested { class BnNestedService : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_flipStatus = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_flipStatusWithCallback = ::android::IBinder::FIRST_CALL_TRANSACTION + 1; explicit BnNestedService(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnNestedService class INestedServiceDelegator : public BnNestedService { public: explicit INestedServiceDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status flipStatus(const ::android::aidl::tests::nested::ParcelableWithNested& p, ::android::aidl::tests::nested::INestedService::Result* _aidl_return) override { return _aidl_delegate->flipStatus(p, _aidl_return); } ::android::binder::Status flipStatusWithCallback(::android::aidl::tests::nested::ParcelableWithNested::Status status, const ::android::sp<::android::aidl::tests::nested::INestedService::ICallback>& cb) override { ::android::sp<::android::aidl::tests::nested::INestedService::ICallbackDelegator> _cb; if (cb) { _cb = ::android::sp<::android::aidl::tests::nested::INestedService::ICallbackDelegator>::cast(delegate(cb)); } return _aidl_delegate->flipStatusWithCallback(status, _cb); } private: ::android::sp _aidl_delegate; }; // class INestedServiceDelegator } // namespace nested } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_ne0100644 0000000 0000000 00000000227 15172120304 033250 xustar000000000 0000000 123 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/BnParcelableWithNested.h 28 mtime=1776853188.4330000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/BnParcelabl0100644 0000000 0000000 00000001256 15172120304 033001 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/nested/ParcelableWithNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_ne0100644 0000000 0000000 00000000217 15172120304 033247 xustar000000000 0000000 115 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/BpDeeplyNested.h 28 mtime=1776853188.4340000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/BpDeeplyNes0100644 0000000 0000000 00000001236 15172120304 033004 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/nested/DeeplyNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/DeeplyNested.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_ne0100644 0000000 0000000 00000000220 15172120304 033241 xustar000000000 0000000 116 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/BpNestedService.h 28 mtime=1776853188.4340000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/BpNestedSer0100644 0000000 0000000 00000003027 15172120304 033010 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/nested/INestedService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/INestedService.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { namespace nested { class BpNestedService : public ::android::BpInterface { public: explicit BpNestedService(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpNestedService() = default; ::android::binder::Status flipStatus(const ::android::aidl::tests::nested::ParcelableWithNested& p, ::android::aidl::tests::nested::INestedService::Result* _aidl_return) override; ::android::binder::Status flipStatusWithCallback(::android::aidl::tests::nested::ParcelableWithNested::Status status, const ::android::sp<::android::aidl::tests::nested::INestedService::ICallback>& cb) override; }; // class BpNestedService } // namespace nested } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_ne0100644 0000000 0000000 00000000227 15172120304 033250 xustar000000000 0000000 123 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/BpParcelableWithNested.h 28 mtime=1776853188.4340000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/BpParcelabl0100644 0000000 0000000 00000001256 15172120304 033003 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/nested/ParcelableWithNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_ne0100644 0000000 0000000 00000000215 15172120304 033245 xustar000000000 0000000 113 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/DeeplyNested.h 28 mtime=1776853188.4340000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/DeeplyNeste0100644 0000000 0000000 00000017463 15172120304 033064 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/nested/DeeplyNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/DeeplyNested.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include namespace android { namespace aidl { namespace tests { namespace nested { class DeeplyNested : public ::android::Parcelable { public: class B : public ::android::Parcelable { public: class C : public ::android::Parcelable { public: class D : public ::android::Parcelable { public: enum class E : int8_t { OK = 0, }; inline bool operator==(const D&) const { return std::tie() == std::tie(); } inline bool operator<(const D&) const { return std::tie() < std::tie(); } inline bool operator!=(const D& _rhs) const { return !(*this == _rhs); } inline bool operator>(const D& _rhs) const { return _rhs < *this; } inline bool operator>=(const D& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const D& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.nested.DeeplyNested.B.C.D"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "D{"; _aidl_os << "}"; return _aidl_os.str(); } }; // class D inline bool operator==(const C&) const { return std::tie() == std::tie(); } inline bool operator<(const C&) const { return std::tie() < std::tie(); } inline bool operator!=(const C& _rhs) const { return !(*this == _rhs); } inline bool operator>(const C& _rhs) const { return _rhs < *this; } inline bool operator>=(const C& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const C& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.nested.DeeplyNested.B.C"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "C{"; _aidl_os << "}"; return _aidl_os.str(); } }; // class C inline bool operator==(const B&) const { return std::tie() == std::tie(); } inline bool operator<(const B&) const { return std::tie() < std::tie(); } inline bool operator!=(const B& _rhs) const { return !(*this == _rhs); } inline bool operator>(const B& _rhs) const { return _rhs < *this; } inline bool operator>=(const B& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const B& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.nested.DeeplyNested.B"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "B{"; _aidl_os << "}"; return _aidl_os.str(); } }; // class B class A : public ::android::Parcelable { public: ::android::aidl::tests::nested::DeeplyNested::B::C::D::E e = ::android::aidl::tests::nested::DeeplyNested::B::C::D::E::OK; inline bool operator==(const A& _rhs) const { return std::tie(e) == std::tie(_rhs.e); } inline bool operator<(const A& _rhs) const { return std::tie(e) < std::tie(_rhs.e); } inline bool operator!=(const A& _rhs) const { return !(*this == _rhs); } inline bool operator>(const A& _rhs) const { return _rhs < *this; } inline bool operator>=(const A& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const A& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.nested.DeeplyNested.A"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "A{"; _aidl_os << "e: " << ::android::internal::ToString(e); _aidl_os << "}"; return _aidl_os.str(); } }; // class A inline bool operator==(const DeeplyNested&) const { return std::tie() == std::tie(); } inline bool operator<(const DeeplyNested&) const { return std::tie() < std::tie(); } inline bool operator!=(const DeeplyNested& _rhs) const { return !(*this == _rhs); } inline bool operator>(const DeeplyNested& _rhs) const { return _rhs < *this; } inline bool operator>=(const DeeplyNested& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const DeeplyNested& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.nested.DeeplyNested"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "DeeplyNested{"; _aidl_os << "}"; return _aidl_os.str(); } }; // class DeeplyNested } // namespace nested } // namespace tests } // namespace aidl } // namespace android namespace android { namespace aidl { namespace tests { namespace nested { [[nodiscard]] static inline std::string toString(DeeplyNested::B::C::D::E val) { switch(val) { case DeeplyNested::B::C::D::E::OK: return "OK"; default: return std::to_string(static_cast(val)); } } } // namespace nested } // namespace tests } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::tests::nested::DeeplyNested::B::C::D::E, 1> enum_values<::android::aidl::tests::nested::DeeplyNested::B::C::D::E> = { ::android::aidl::tests::nested::DeeplyNested::B::C::D::E::OK, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_ne0100644 0000000 0000000 00000000217 15172120304 033247 xustar000000000 0000000 115 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/INestedService.h 28 mtime=1776853188.4340000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/INestedServ0100644 0000000 0000000 00000013537 15172120304 033034 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/nested/INestedService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/INestedService.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include namespace android::aidl::tests::nested { class ParcelableWithNested; } // namespace android::aidl::tests::nested namespace android { namespace aidl { namespace tests { namespace nested { class INestedServiceDelegator; class INestedService : public ::android::IInterface { public: typedef INestedServiceDelegator DefaultDelegator; DECLARE_META_INTERFACE(NestedService) class Result : public ::android::Parcelable { public: ::android::aidl::tests::nested::ParcelableWithNested::Status status = ::android::aidl::tests::nested::ParcelableWithNested::Status::OK; inline bool operator==(const Result& _rhs) const { return std::tie(status) == std::tie(_rhs.status); } inline bool operator<(const Result& _rhs) const { return std::tie(status) < std::tie(_rhs.status); } inline bool operator!=(const Result& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Result& _rhs) const { return _rhs < *this; } inline bool operator>=(const Result& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Result& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.nested.INestedService.Result"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "Result{"; _aidl_os << "status: " << ::android::internal::ToString(status); _aidl_os << "}"; return _aidl_os.str(); } }; // class Result class ICallbackDelegator; class ICallback : public ::android::IInterface { public: typedef ICallbackDelegator DefaultDelegator; DECLARE_META_INTERFACE(Callback) virtual ::android::binder::Status done(::android::aidl::tests::nested::ParcelableWithNested::Status status) = 0; }; // class ICallback class ICallbackDefault : public ICallback { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status done(::android::aidl::tests::nested::ParcelableWithNested::Status /*status*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } }; // class ICallbackDefault class BpCallback : public ::android::BpInterface { public: explicit BpCallback(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpCallback() = default; ::android::binder::Status done(::android::aidl::tests::nested::ParcelableWithNested::Status status) override; }; // class BpCallback class BnCallback : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_done = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; explicit BnCallback(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnCallback class ICallbackDelegator : public BnCallback { public: explicit ICallbackDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status done(::android::aidl::tests::nested::ParcelableWithNested::Status status) override { return _aidl_delegate->done(status); } private: ::android::sp _aidl_delegate; }; // class ICallbackDelegator virtual ::android::binder::Status flipStatus(const ::android::aidl::tests::nested::ParcelableWithNested& p, ::android::aidl::tests::nested::INestedService::Result* _aidl_return) = 0; virtual ::android::binder::Status flipStatusWithCallback(::android::aidl::tests::nested::ParcelableWithNested::Status status, const ::android::sp<::android::aidl::tests::nested::INestedService::ICallback>& cb) = 0; }; // class INestedService class INestedServiceDefault : public INestedService { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status flipStatus(const ::android::aidl::tests::nested::ParcelableWithNested& /*p*/, ::android::aidl::tests::nested::INestedService::Result* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status flipStatusWithCallback(::android::aidl::tests::nested::ParcelableWithNested::Status /*status*/, const ::android::sp<::android::aidl::tests::nested::INestedService::ICallback>& /*cb*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } }; // class INestedServiceDefault } // namespace nested } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_ne0100644 0000000 0000000 00000000225 15172120304 033246 xustar000000000 0000000 121 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/ParcelableWithNested.h 28 mtime=1776853188.4350000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/ParcelableW0100644 0000000 0000000 00000007037 15172120304 033020 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/nested/ParcelableWithNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include namespace android { namespace aidl { namespace tests { namespace nested { class ParcelableWithNested : public ::android::Parcelable { public: enum class Status : int8_t { OK = 0, NOT_OK = 1, }; ::android::aidl::tests::nested::ParcelableWithNested::Status status = ::android::aidl::tests::nested::ParcelableWithNested::Status::OK; inline bool operator==(const ParcelableWithNested& _rhs) const { return std::tie(status) == std::tie(_rhs.status); } inline bool operator<(const ParcelableWithNested& _rhs) const { return std::tie(status) < std::tie(_rhs.status); } inline bool operator!=(const ParcelableWithNested& _rhs) const { return !(*this == _rhs); } inline bool operator>(const ParcelableWithNested& _rhs) const { return _rhs < *this; } inline bool operator>=(const ParcelableWithNested& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const ParcelableWithNested& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.nested.ParcelableWithNested"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "ParcelableWithNested{"; _aidl_os << "status: " << ::android::internal::ToString(status); _aidl_os << "}"; return _aidl_os.str(); } }; // class ParcelableWithNested } // namespace nested } // namespace tests } // namespace aidl } // namespace android namespace android { namespace aidl { namespace tests { namespace nested { [[nodiscard]] static inline std::string toString(ParcelableWithNested::Status val) { switch(val) { case ParcelableWithNested::Status::OK: return "OK"; case ParcelableWithNested::Status::NOT_OK: return "NOT_OK"; default: return std::to_string(static_cast(val)); } } } // namespace nested } // namespace tests } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::tests::nested::ParcelableWithNested::Status, 2> enum_values<::android::aidl::tests::nested::ParcelableWithNested::Status> = { ::android::aidl::tests::nested::ParcelableWithNested::Status::OK, ::android::aidl::tests::nested::ParcelableWithNested::Status::NOT_OK, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_un0100644 0000000 0000000 00000000034 15172120304 033264 xustar000000000 0000000 28 mtime=1776853188.4350000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/unions/0040755 0000000 0000000 00000000000 15172120304 030741 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_un0100644 0000000 0000000 00000000214 15172120304 033264 xustar000000000 0000000 112 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/unions/BnEnumUnion.h 28 mtime=1776853188.4350000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/unions/BnEnumUnion0100644 0000000 0000000 00000001230 15172120304 033052 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/unions/EnumUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_un0100644 0000000 0000000 00000000217 15172120304 033267 xustar000000000 0000000 115 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/unions/BnUnionInUnion.h 28 mtime=1776853188.4350000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/unions/BnUnionInUn0100644 0000000 0000000 00000001236 15172120304 033025 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/unions/UnionInUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/UnionInUnion.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_un0100644 0000000 0000000 00000000214 15172120304 033264 xustar000000000 0000000 112 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/unions/BpEnumUnion.h 28 mtime=1776853188.4350000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/unions/BpEnumUnion0100644 0000000 0000000 00000001230 15172120304 033054 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/unions/EnumUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_un0100644 0000000 0000000 00000000217 15172120304 033267 xustar000000000 0000000 115 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/unions/BpUnionInUnion.h 28 mtime=1776853188.4350000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/unions/BpUnionInUn0100644 0000000 0000000 00000001236 15172120304 033027 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/unions/UnionInUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/UnionInUnion.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_un0100644 0000000 0000000 00000000212 15172120304 033262 xustar000000000 0000000 110 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/unions/EnumUnion.h 28 mtime=1776853188.4350000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/unions/EnumUnion.h0100644 0000000 0000000 00000014161 15172120304 033027 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/unions/EnumUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace android { namespace aidl { namespace tests { namespace unions { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" class EnumUnion : public ::android::Parcelable { public: enum class Tag : int32_t { intEnum = 0, longEnum = 1, deprecatedField __attribute__((deprecated("do not use this"))) = 2, }; // Expose tag symbols for legacy code static const inline Tag intEnum = Tag::intEnum; static const inline Tag longEnum = Tag::longEnum; static const inline Tag __attribute__((deprecated("do not use this"))) deprecatedField = Tag::deprecatedField; template static constexpr bool _not_self = !std::is_same_v>, EnumUnion>; EnumUnion() : _value(std::in_place_index(intEnum)>, ::android::aidl::tests::IntEnum(::android::aidl::tests::IntEnum::FOO)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr EnumUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit EnumUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static EnumUnion make(_Tp&&... _args) { return EnumUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static EnumUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return EnumUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } inline bool operator==(const EnumUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const EnumUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const EnumUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const EnumUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const EnumUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const EnumUnion& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.unions.EnumUnion"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream os; os << "EnumUnion{"; switch (getTag()) { case intEnum: os << "intEnum: " << ::android::internal::ToString(get()); break; case longEnum: os << "longEnum: " << ::android::internal::ToString(get()); break; case deprecatedField: os << "deprecatedField: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant<::android::aidl::tests::IntEnum, ::android::aidl::tests::LongEnum, int32_t> _value; }; // class EnumUnion #pragma clang diagnostic pop } // namespace unions } // namespace tests } // namespace aidl } // namespace android namespace android { namespace aidl { namespace tests { namespace unions { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" [[nodiscard]] static inline std::string toString(EnumUnion::Tag val) { switch(val) { case EnumUnion::Tag::intEnum: return "intEnum"; case EnumUnion::Tag::longEnum: return "longEnum"; case EnumUnion::Tag::deprecatedField: return "deprecatedField"; default: return std::to_string(static_cast(val)); } } #pragma clang diagnostic pop } // namespace unions } // namespace tests } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" #pragma clang diagnostic ignored "-Wdeprecated-declarations" template <> constexpr inline std::array<::android::aidl::tests::unions::EnumUnion::Tag, 3> enum_values<::android::aidl::tests::unions::EnumUnion::Tag> = { ::android::aidl::tests::unions::EnumUnion::Tag::intEnum, ::android::aidl::tests::unions::EnumUnion::Tag::longEnum, ::android::aidl::tests::unions::EnumUnion::Tag::deprecatedField, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_include_android_aidl_tests_un0100644 0000000 0000000 00000000215 15172120304 033265 xustar000000000 0000000 113 path=tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/unions/UnionInUnion.h 28 mtime=1776853188.4360000 tests/golden_output/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/unions/UnionInUnio0100644 0000000 0000000 00000012546 15172120304 033103 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/unions/UnionInUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/UnionInUnion.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace android { namespace aidl { namespace tests { namespace unions { class UnionInUnion : public ::android::Parcelable { public: enum class Tag : int32_t { first = 0, second = 1, }; // Expose tag symbols for legacy code static const inline Tag first = Tag::first; static const inline Tag second = Tag::second; template static constexpr bool _not_self = !std::is_same_v>, UnionInUnion>; UnionInUnion() : _value(std::in_place_index(first)>, ::android::aidl::tests::unions::EnumUnion()) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr UnionInUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit UnionInUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static UnionInUnion make(_Tp&&... _args) { return UnionInUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static UnionInUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return UnionInUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } inline bool operator==(const UnionInUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const UnionInUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const UnionInUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const UnionInUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const UnionInUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const UnionInUnion& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.unions.UnionInUnion"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream os; os << "UnionInUnion{"; switch (getTag()) { case first: os << "first: " << ::android::internal::ToString(get()); break; case second: os << "second: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant<::android::aidl::tests::unions::EnumUnion, int32_t> _value; }; // class UnionInUnion } // namespace unions } // namespace tests } // namespace aidl } // namespace android namespace android { namespace aidl { namespace tests { namespace unions { [[nodiscard]] static inline std::string toString(UnionInUnion::Tag val) { switch(val) { case UnionInUnion::Tag::first: return "first"; case UnionInUnion::Tag::second: return "second"; default: return std::to_string(static_cast(val)); } } } // namespace unions } // namespace tests } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::tests::unions::UnionInUnion::Tag, 2> enum_values<::android::aidl::tests::unions::UnionInUnion::Tag> = { ::android::aidl::tests::unions::UnionInUnion::Tag::first, ::android::aidl::tests::unions::UnionInUnion::Tag::second, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-interface-cpp-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 027227 xustar000000000 0000000 28 mtime=1776853188.4360000 tests/golden_output/aidl-test-interface-cpp-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 024221 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_0100644 0000000 0000000 00000000034 15172120304 024611 xustar000000000 0000000 28 mtime=1776853188.4360000 tests/golden_output/aidl-test-interface-java-source/0040755 0000000 0000000 00000000000 15172120304 021676 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_0100644 0000000 0000000 00000000034 15172120304 025442 xustar000000000 0000000 28 mtime=1776853188.4360000 tests/golden_output/aidl-test-interface-java-source/gen/0040755 0000000 0000000 00000000000 15172120304 022447 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 027142 xustar000000000 0000000 28 mtime=1776853188.4360000 tests/golden_output/aidl-test-interface-java-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 024067 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 030133 xustar000000000 0000000 28 mtime=1776853188.4360000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 025000 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_0100644 0000000 0000000 00000000034 15172120304 031355 xustar000000000 0000000 28 mtime=1776853188.4360000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/0040755 0000000 0000000 00000000000 15172120304 026142 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_ArrayOfIn0100644 0000000 0000000 00000000034 15172120304 033130 xustar000000000 0000000 28 mtime=1776853188.4360000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/ArrayOfInterfaces.java0100644 0000000 0000000 00000066041 15172120304 032360 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/ArrayOfInterfaces.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ArrayOfInterfaces.aidl */ package android.aidl.tests; public class ArrayOfInterfaces implements android.os.Parcelable { public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public ArrayOfInterfaces createFromParcel(android.os.Parcel _aidl_source) { ArrayOfInterfaces _aidl_out = new ArrayOfInterfaces(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public ArrayOfInterfaces[] newArray(int _aidl_size) { return new ArrayOfInterfaces[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } public interface IEmptyInterface extends android.os.IInterface { /** Default implementation for IEmptyInterface. */ public static class Default implements android.aidl.tests.ArrayOfInterfaces.IEmptyInterface { @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.ArrayOfInterfaces.IEmptyInterface { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.ArrayOfInterfaces.IEmptyInterface interface, * generating a proxy if needed. */ public static android.aidl.tests.ArrayOfInterfaces.IEmptyInterface asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.ArrayOfInterfaces.IEmptyInterface))) { return ((android.aidl.tests.ArrayOfInterfaces.IEmptyInterface)iin); } return new android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { default: { return super.onTransact(code, data, reply, flags); } } } private static class Proxy implements android.aidl.tests.ArrayOfInterfaces.IEmptyInterface { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } } /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.ArrayOfInterfaces.IEmptyInterface"; } public interface IMyInterface extends android.os.IInterface { /** Default implementation for IMyInterface. */ public static class Default implements android.aidl.tests.ArrayOfInterfaces.IMyInterface { @Override public android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] methodWithInterfaces(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface iface, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface nullable_iface, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] iface_array_in, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] iface_array_out, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] iface_array_inout, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] nullable_iface_array_in, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] nullable_iface_array_out, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] nullable_iface_array_inout) throws android.os.RemoteException { return null; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.ArrayOfInterfaces.IMyInterface { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.ArrayOfInterfaces.IMyInterface interface, * generating a proxy if needed. */ public static android.aidl.tests.ArrayOfInterfaces.IMyInterface asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.ArrayOfInterfaces.IMyInterface))) { return ((android.aidl.tests.ArrayOfInterfaces.IMyInterface)iin); } return new android.aidl.tests.ArrayOfInterfaces.IMyInterface.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_methodWithInterfaces: { return "methodWithInterfaces"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_methodWithInterfaces: { android.aidl.tests.ArrayOfInterfaces.IEmptyInterface _arg0; _arg0 = android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub.asInterface(data.readStrongBinder()); android.aidl.tests.ArrayOfInterfaces.IEmptyInterface _arg1; _arg1 = android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub.asInterface(data.readStrongBinder()); android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] _arg2; _arg2 = data.createInterfaceArray(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[]::new, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub::asInterface); android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] _arg3; int _arg3_length = data.readInt(); if (_arg3_length < 0) { _arg3 = null; } else { _arg3 = new android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[_arg3_length]; } android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] _arg4; _arg4 = data.createInterfaceArray(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[]::new, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub::asInterface); android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] _arg5; _arg5 = data.createInterfaceArray(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[]::new, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub::asInterface); android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] _arg6; int _arg6_length = data.readInt(); if (_arg6_length < 0) { _arg6 = null; } else { _arg6 = new android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[_arg6_length]; } android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] _arg7; _arg7 = data.createInterfaceArray(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[]::new, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub::asInterface); data.enforceNoDataAvail(); android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] _result = this.methodWithInterfaces(_arg0, _arg1, _arg2, _arg3, _arg4, _arg5, _arg6, _arg7); reply.writeNoException(); reply.writeInterfaceArray(_result); reply.writeInterfaceArray(_arg3); reply.writeInterfaceArray(_arg4); reply.writeInterfaceArray(_arg6); reply.writeInterfaceArray(_arg7); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.ArrayOfInterfaces.IMyInterface { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] methodWithInterfaces(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface iface, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface nullable_iface, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] iface_array_in, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] iface_array_out, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] iface_array_inout, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] nullable_iface_array_in, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] nullable_iface_array_out, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] nullable_iface_array_inout) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeStrongInterface(iface); _data.writeStrongInterface(nullable_iface); _data.writeInterfaceArray(iface_array_in); _data.writeInt(iface_array_out.length); _data.writeInterfaceArray(iface_array_inout); _data.writeInterfaceArray(nullable_iface_array_in); _data.writeInt(nullable_iface_array_out.length); _data.writeInterfaceArray(nullable_iface_array_inout); boolean _status = mRemote.transact(Stub.TRANSACTION_methodWithInterfaces, _data, _reply, 0); _reply.readException(); _result = _reply.createInterfaceArray(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[]::new, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub::asInterface); _reply.readInterfaceArray(iface_array_out, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub::asInterface); _reply.readInterfaceArray(iface_array_inout, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub::asInterface); _reply.readInterfaceArray(nullable_iface_array_out, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub::asInterface); _reply.readInterfaceArray(nullable_iface_array_inout, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub::asInterface); } finally { _reply.recycle(); _data.recycle(); } return _result; } } static final int TRANSACTION_methodWithInterfaces = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.ArrayOfInterfaces.IMyInterface"; public android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] methodWithInterfaces(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface iface, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface nullable_iface, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] iface_array_in, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] iface_array_out, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] iface_array_inout, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] nullable_iface_array_in, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] nullable_iface_array_out, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] nullable_iface_array_inout) throws android.os.RemoteException; } public static class MyParcelable implements android.os.Parcelable { public android.aidl.tests.ArrayOfInterfaces.IEmptyInterface iface; public android.aidl.tests.ArrayOfInterfaces.IEmptyInterface nullable_iface; public android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] iface_array; public android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] nullable_iface_array; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public MyParcelable createFromParcel(android.os.Parcel _aidl_source) { MyParcelable _aidl_out = new MyParcelable(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public MyParcelable[] newArray(int _aidl_size) { return new MyParcelable[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeStrongInterface(iface); _aidl_parcel.writeStrongInterface(nullable_iface); _aidl_parcel.writeInterfaceArray(iface_array); _aidl_parcel.writeInterfaceArray(nullable_iface_array); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; iface = android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub.asInterface(_aidl_parcel.readStrongBinder()); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; nullable_iface = android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub.asInterface(_aidl_parcel.readStrongBinder()); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; iface_array = _aidl_parcel.createInterfaceArray(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[]::new, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub::asInterface); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; nullable_iface_array = _aidl_parcel.createInterfaceArray(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[]::new, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub::asInterface); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public String toString() { java.util.StringJoiner _aidl_sj = new java.util.StringJoiner(", ", "{", "}"); _aidl_sj.add("iface: " + (java.util.Objects.toString(iface))); _aidl_sj.add("nullable_iface: " + (java.util.Objects.toString(nullable_iface))); _aidl_sj.add("iface_array: " + (java.util.Arrays.toString(iface_array))); _aidl_sj.add("nullable_iface_array: " + (java.util.Arrays.toString(nullable_iface_array))); return "MyParcelable" + _aidl_sj.toString() ; } @Override public boolean equals(Object other) { if (this == other) return true; if (other == null) return false; if (!(other instanceof MyParcelable)) return false; MyParcelable that = (MyParcelable)other; if (!java.util.Objects.deepEquals(iface, that.iface)) return false; if (!java.util.Objects.deepEquals(nullable_iface, that.nullable_iface)) return false; if (!java.util.Objects.deepEquals(iface_array, that.iface_array)) return false; if (!java.util.Objects.deepEquals(nullable_iface_array, that.nullable_iface_array)) return false; return true; } @Override public int hashCode() { return java.util.Arrays.deepHashCode(java.util.Arrays.asList(iface, nullable_iface, iface_array, nullable_iface_array).toArray()); } @Override public int describeContents() { int _mask = 0; return _mask; } } public static final class MyUnion implements android.os.Parcelable { // tags for union fields public final static int iface = 0; // android.aidl.tests.ArrayOfInterfaces.IEmptyInterface iface; public final static int nullable_iface = 1; // android.aidl.tests.ArrayOfInterfaces.IEmptyInterface nullable_iface; public final static int iface_array = 2; // android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] iface_array; public final static int nullable_iface_array = 3; // android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] nullable_iface_array; private int _tag; private Object _value; public MyUnion() { android.aidl.tests.ArrayOfInterfaces.IEmptyInterface _value = null; this._tag = iface; this._value = _value; } private MyUnion(android.os.Parcel _aidl_parcel) { readFromParcel(_aidl_parcel); } private MyUnion(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public int getTag() { return _tag; } // android.aidl.tests.ArrayOfInterfaces.IEmptyInterface iface; public static MyUnion iface(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface _value) { return new MyUnion(iface, _value); } public android.aidl.tests.ArrayOfInterfaces.IEmptyInterface getIface() { _assertTag(iface); return (android.aidl.tests.ArrayOfInterfaces.IEmptyInterface) _value; } public void setIface(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface _value) { _set(iface, _value); } // android.aidl.tests.ArrayOfInterfaces.IEmptyInterface nullable_iface; public static MyUnion nullable_iface(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface _value) { return new MyUnion(nullable_iface, _value); } public android.aidl.tests.ArrayOfInterfaces.IEmptyInterface getNullable_iface() { _assertTag(nullable_iface); return (android.aidl.tests.ArrayOfInterfaces.IEmptyInterface) _value; } public void setNullable_iface(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface _value) { _set(nullable_iface, _value); } // android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] iface_array; public static MyUnion iface_array(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] _value) { return new MyUnion(iface_array, _value); } public android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] getIface_array() { _assertTag(iface_array); return (android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[]) _value; } public void setIface_array(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] _value) { _set(iface_array, _value); } // android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] nullable_iface_array; public static MyUnion nullable_iface_array(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] _value) { return new MyUnion(nullable_iface_array, _value); } public android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] getNullable_iface_array() { _assertTag(nullable_iface_array); return (android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[]) _value; } public void setNullable_iface_array(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] _value) { _set(nullable_iface_array, _value); } public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public MyUnion createFromParcel(android.os.Parcel _aidl_source) { return new MyUnion(_aidl_source); } @Override public MyUnion[] newArray(int _aidl_size) { return new MyUnion[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { _aidl_parcel.writeInt(_tag); switch (_tag) { case iface: _aidl_parcel.writeStrongInterface(getIface()); break; case nullable_iface: _aidl_parcel.writeStrongInterface(getNullable_iface()); break; case iface_array: _aidl_parcel.writeInterfaceArray(getIface_array()); break; case nullable_iface_array: _aidl_parcel.writeInterfaceArray(getNullable_iface_array()); break; } } public void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_tag; _aidl_tag = _aidl_parcel.readInt(); switch (_aidl_tag) { case iface: { android.aidl.tests.ArrayOfInterfaces.IEmptyInterface _aidl_value; _aidl_value = android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub.asInterface(_aidl_parcel.readStrongBinder()); _set(_aidl_tag, _aidl_value); return; } case nullable_iface: { android.aidl.tests.ArrayOfInterfaces.IEmptyInterface _aidl_value; _aidl_value = android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub.asInterface(_aidl_parcel.readStrongBinder()); _set(_aidl_tag, _aidl_value); return; } case iface_array: { android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] _aidl_value; _aidl_value = _aidl_parcel.createInterfaceArray(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[]::new, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub::asInterface); _set(_aidl_tag, _aidl_value); return; } case nullable_iface_array: { android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] _aidl_value; _aidl_value = _aidl_parcel.createInterfaceArray(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[]::new, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub::asInterface); _set(_aidl_tag, _aidl_value); return; } } throw new IllegalArgumentException("union: unknown tag: " + _aidl_tag); } @Override public int describeContents() { int _mask = 0; switch (getTag()) { } return _mask; } @Override public String toString() { switch (_tag) { case iface: return "MyUnion.iface(" + (java.util.Objects.toString(getIface())) + ")"; case nullable_iface: return "MyUnion.nullable_iface(" + (java.util.Objects.toString(getNullable_iface())) + ")"; case iface_array: return "MyUnion.iface_array(" + (java.util.Arrays.toString(getIface_array())) + ")"; case nullable_iface_array: return "MyUnion.nullable_iface_array(" + (java.util.Arrays.toString(getNullable_iface_array())) + ")"; } throw new IllegalStateException("unknown field: " + _tag); } @Override public boolean equals(Object other) { if (this == other) return true; if (other == null) return false; if (!(other instanceof MyUnion)) return false; MyUnion that = (MyUnion)other; if (_tag != that._tag) return false; if (!java.util.Objects.deepEquals(_value, that._value)) return false; return true; } @Override public int hashCode() { return java.util.Arrays.deepHashCode(java.util.Arrays.asList(_tag, _value).toArray()); } private void _assertTag(int tag) { if (getTag() != tag) { throw new IllegalStateException("bad access: " + _tagString(tag) + ", " + _tagString(getTag()) + " is available."); } } private String _tagString(int _tag) { switch (_tag) { case iface: return "iface"; case nullable_iface: return "nullable_iface"; case iface_array: return "iface_array"; case nullable_iface_array: return "nullable_iface_array"; } throw new IllegalStateException("unknown field: " + _tag); } private void _set(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public static @interface Tag { public static final int iface = 0; public static final int nullable_iface = 1; public static final int iface_array = 2; public static final int nullable_iface_array = 3; } } } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_ArrayOfIn0100644 0000000 0000000 00000000034 15172120304 033130 xustar000000000 0000000 28 mtime=1776853188.4360000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/ArrayOfInterfaces.java.d0100644 0000000 0000000 00000000301 15172120304 032565 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/ArrayOfInterfaces.java : \ system/tools/aidl/tests/android/aidl/tests/ArrayOfInterfaces.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_BackendTy0100644 0000000 0000000 00000000034 15172120304 033142 xustar000000000 0000000 28 mtime=1776853188.4370000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/BackendType.java0100644 0000000 0000000 00000001274 15172120304 031177 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/BackendType.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/BackendType.aidl */ package android.aidl.tests; public @interface BackendType { public static final byte CPP = 0; public static final byte JAVA = 1; public static final byte NDK = 2; public static final byte RUST = 3; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_BackendTy0100644 0000000 0000000 00000000034 15172120304 033142 xustar000000000 0000000 28 mtime=1776853188.4370000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/BackendType.java.d0100644 0000000 0000000 00000000265 15172120304 031420 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/BackendType.java : \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_ByteEnum.0100644 0000000 0000000 00000000034 15172120304 033104 xustar000000000 0000000 28 mtime=1776853188.4370000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/ByteEnum.java0100644 0000000 0000000 00000001272 15172120304 030534 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/ByteEnum.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl */ package android.aidl.tests; /** Hello, world! */ public @interface ByteEnum { // Comment about FOO. public static final byte FOO = 1; public static final byte BAR = 2; public static final byte BAZ = 3; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_ByteEnum.0100644 0000000 0000000 00000000034 15172120304 033104 xustar000000000 0000000 28 mtime=1776853188.4370000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/ByteEnum.java.d0100644 0000000 0000000 00000000257 15172120304 030760 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/ByteEnum.java : \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_CircularP0100644 0000000 0000000 00000000034 15172120304 033162 xustar000000000 0000000 28 mtime=1776853188.4370000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/CircularParcelable.java0100644 0000000 0000000 00000004646 15172120304 032533 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/CircularParcelable.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl */ package android.aidl.tests; public class CircularParcelable implements android.os.Parcelable { public android.aidl.tests.ITestService testService; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public CircularParcelable createFromParcel(android.os.Parcel _aidl_source) { CircularParcelable _aidl_out = new CircularParcelable(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public CircularParcelable[] newArray(int _aidl_size) { return new CircularParcelable[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeStrongInterface(testService); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; testService = android.aidl.tests.ITestService.Stub.asInterface(_aidl_parcel.readStrongBinder()); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_CircularP0100644 0000000 0000000 00000000212 15172120304 033160 xustar000000000 0000000 110 path=tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/CircularParcelable.java.d 28 mtime=1776853188.4370000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/CircularParcelable.java.d0100644 0000000 0000000 00000002235 15172120304 032745 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/CircularParcelable.java : \ system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ITestService.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl \ system/tools/aidl/tests/android/aidl/tests/SimpleParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl \ system/tools/aidl/tests/android/aidl/tests/ICircular.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_ConstantE0100644 0000000 0000000 00000000214 15172120304 033174 xustar000000000 0000000 112 path=tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/ConstantExpressionEnum.java 28 mtime=1776853188.4370000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/ConstantExpressionEnum.ja0100644 0000000 0000000 00000002467 15172120304 033162 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/ConstantExpressionEnum.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl */ package android.aidl.tests; public @interface ConstantExpressionEnum { // Should be all true / ones. // dec literals are either int or long public static final int decInt32_1 = 1; public static final int decInt32_2 = 1; public static final int decInt64_1 = 1; public static final int decInt64_2 = 1; public static final int decInt64_3 = 1; public static final int decInt64_4 = 1; // hex literals could be int or long // 0x7fffffff is int, hence can be negated public static final int hexInt32_1 = 1; // 0x80000000 is int32_t max + 1 public static final int hexInt32_2 = 1; // 0xFFFFFFFF is int32_t, not long; if it were long then ~(long)0xFFFFFFFF != 0 public static final int hexInt32_3 = 1; // 0x7FFFFFFFFFFFFFFF is long, hence can be negated public static final int hexInt64_1 = 1; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_ConstantE0100644 0000000 0000000 00000000216 15172120304 033176 xustar000000000 0000000 114 path=tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/ConstantExpressionEnum.java.d 28 mtime=1776853188.4370000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/ConstantExpressionEnum.ja0100644 0000000 0000000 00000000313 15172120304 033146 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/ConstantExpressionEnum.java : \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_Deprecate0100644 0000000 0000000 00000000034 15172120304 033172 xustar000000000 0000000 28 mtime=1776853188.4370000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/DeprecatedEnum.java0100644 0000000 0000000 00000001272 15172120304 031671 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/DeprecatedEnum.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedEnum.aidl */ package android.aidl.tests; /** @deprecated test */ @Deprecated public @interface DeprecatedEnum { public static final int A = 0; public static final int B = 1; public static final int C = 2; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_Deprecate0100644 0000000 0000000 00000000034 15172120304 033172 xustar000000000 0000000 28 mtime=1776853188.4370000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/DeprecatedEnum.java.d0100644 0000000 0000000 00000000273 15172120304 032113 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/DeprecatedEnum.java : \ system/tools/aidl/tests/android/aidl/tests/DeprecatedEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_Deprecate0100644 0000000 0000000 00000000212 15172120304 033170 xustar000000000 0000000 110 path=tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/DeprecatedParcelable.java 28 mtime=1776853188.4370000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/DeprecatedParcelable.java0100644 0000000 0000000 00000004263 15172120304 033022 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/DeprecatedParcelable.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedParcelable.aidl */ package android.aidl.tests; /** @deprecated test */ @Deprecated public class DeprecatedParcelable implements android.os.Parcelable { public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public DeprecatedParcelable createFromParcel(android.os.Parcel _aidl_source) { DeprecatedParcelable _aidl_out = new DeprecatedParcelable(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public DeprecatedParcelable[] newArray(int _aidl_size) { return new DeprecatedParcelable[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_Deprecate0100644 0000000 0000000 00000000214 15172120304 033172 xustar000000000 0000000 112 path=tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/DeprecatedParcelable.java.d 28 mtime=1776853188.4370000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/DeprecatedParcelable.java0100644 0000000 0000000 00000000307 15172120304 033015 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/DeprecatedParcelable.java : \ system/tools/aidl/tests/android/aidl/tests/DeprecatedParcelable.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_FixedSize0100644 0000000 0000000 00000000034 15172120304 033170 xustar000000000 0000000 28 mtime=1776853188.4410000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/FixedSize.java0100644 0000000 0000000 00000033151 15172120304 030677 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/FixedSize.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/FixedSize.aidl */ package android.aidl.tests; public class FixedSize implements android.os.Parcelable { public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public FixedSize createFromParcel(android.os.Parcel _aidl_source) { FixedSize _aidl_out = new FixedSize(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public FixedSize[] newArray(int _aidl_size) { return new FixedSize[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } public static class FixedParcelable implements android.os.Parcelable { public boolean booleanValue = false; public byte byteValue = 0; public char charValue = '\0'; public int intValue = 0; public long longValue = 0L; public float floatValue = 0.000000f; public double doubleValue = 0.000000; public long enumValue = android.aidl.tests.LongEnum.FOO; public android.aidl.tests.FixedSize.FixedUnion parcelableValue; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public FixedParcelable createFromParcel(android.os.Parcel _aidl_source) { FixedParcelable _aidl_out = new FixedParcelable(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public FixedParcelable[] newArray(int _aidl_size) { return new FixedParcelable[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeBoolean(booleanValue); _aidl_parcel.writeByte(byteValue); _aidl_parcel.writeInt(((int)charValue)); _aidl_parcel.writeInt(intValue); _aidl_parcel.writeLong(longValue); _aidl_parcel.writeFloat(floatValue); _aidl_parcel.writeDouble(doubleValue); _aidl_parcel.writeLong(enumValue); _aidl_parcel.writeTypedObject(parcelableValue, _aidl_flag); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; booleanValue = _aidl_parcel.readBoolean(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; byteValue = _aidl_parcel.readByte(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; charValue = (char)_aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; intValue = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; longValue = _aidl_parcel.readLong(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; floatValue = _aidl_parcel.readFloat(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; doubleValue = _aidl_parcel.readDouble(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; enumValue = _aidl_parcel.readLong(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; parcelableValue = _aidl_parcel.readTypedObject(android.aidl.tests.FixedSize.FixedUnion.CREATOR); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; _mask |= describeContents(parcelableValue); return _mask; } private int describeContents(Object _v) { if (_v == null) return 0; if (_v instanceof android.os.Parcelable) { return ((android.os.Parcelable) _v).describeContents(); } return 0; } } public static final class FixedUnion implements android.os.Parcelable { // tags for union fields public final static int booleanValue = 0; // boolean booleanValue; public final static int byteValue = 1; // byte byteValue; public final static int charValue = 2; // char charValue; public final static int intValue = 3; // int intValue; public final static int longValue = 4; // long longValue; public final static int floatValue = 5; // float floatValue; public final static int doubleValue = 6; // double doubleValue; public final static int enumValue = 7; // android.aidl.tests.LongEnum enumValue; private int _tag; private Object _value; public FixedUnion() { boolean _value = false; this._tag = booleanValue; this._value = _value; } private FixedUnion(android.os.Parcel _aidl_parcel) { readFromParcel(_aidl_parcel); } private FixedUnion(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public int getTag() { return _tag; } // boolean booleanValue; public static FixedUnion booleanValue(boolean _value) { return new FixedUnion(booleanValue, _value); } public boolean getBooleanValue() { _assertTag(booleanValue); return (boolean) _value; } public void setBooleanValue(boolean _value) { _set(booleanValue, _value); } // byte byteValue; public static FixedUnion byteValue(byte _value) { return new FixedUnion(byteValue, _value); } public byte getByteValue() { _assertTag(byteValue); return (byte) _value; } public void setByteValue(byte _value) { _set(byteValue, _value); } // char charValue; public static FixedUnion charValue(char _value) { return new FixedUnion(charValue, _value); } public char getCharValue() { _assertTag(charValue); return (char) _value; } public void setCharValue(char _value) { _set(charValue, _value); } // int intValue; public static FixedUnion intValue(int _value) { return new FixedUnion(intValue, _value); } public int getIntValue() { _assertTag(intValue); return (int) _value; } public void setIntValue(int _value) { _set(intValue, _value); } // long longValue; public static FixedUnion longValue(long _value) { return new FixedUnion(longValue, _value); } public long getLongValue() { _assertTag(longValue); return (long) _value; } public void setLongValue(long _value) { _set(longValue, _value); } // float floatValue; public static FixedUnion floatValue(float _value) { return new FixedUnion(floatValue, _value); } public float getFloatValue() { _assertTag(floatValue); return (float) _value; } public void setFloatValue(float _value) { _set(floatValue, _value); } // double doubleValue; public static FixedUnion doubleValue(double _value) { return new FixedUnion(doubleValue, _value); } public double getDoubleValue() { _assertTag(doubleValue); return (double) _value; } public void setDoubleValue(double _value) { _set(doubleValue, _value); } // android.aidl.tests.LongEnum enumValue; public static FixedUnion enumValue(long _value) { return new FixedUnion(enumValue, _value); } public long getEnumValue() { _assertTag(enumValue); return (long) _value; } public void setEnumValue(long _value) { _set(enumValue, _value); } public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public FixedUnion createFromParcel(android.os.Parcel _aidl_source) { return new FixedUnion(_aidl_source); } @Override public FixedUnion[] newArray(int _aidl_size) { return new FixedUnion[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { _aidl_parcel.writeInt(_tag); switch (_tag) { case booleanValue: _aidl_parcel.writeBoolean(getBooleanValue()); break; case byteValue: _aidl_parcel.writeByte(getByteValue()); break; case charValue: _aidl_parcel.writeInt(((int)getCharValue())); break; case intValue: _aidl_parcel.writeInt(getIntValue()); break; case longValue: _aidl_parcel.writeLong(getLongValue()); break; case floatValue: _aidl_parcel.writeFloat(getFloatValue()); break; case doubleValue: _aidl_parcel.writeDouble(getDoubleValue()); break; case enumValue: _aidl_parcel.writeLong(getEnumValue()); break; } } public void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_tag; _aidl_tag = _aidl_parcel.readInt(); switch (_aidl_tag) { case booleanValue: { boolean _aidl_value; _aidl_value = _aidl_parcel.readBoolean(); _set(_aidl_tag, _aidl_value); return; } case byteValue: { byte _aidl_value; _aidl_value = _aidl_parcel.readByte(); _set(_aidl_tag, _aidl_value); return; } case charValue: { char _aidl_value; _aidl_value = (char)_aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } case intValue: { int _aidl_value; _aidl_value = _aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } case longValue: { long _aidl_value; _aidl_value = _aidl_parcel.readLong(); _set(_aidl_tag, _aidl_value); return; } case floatValue: { float _aidl_value; _aidl_value = _aidl_parcel.readFloat(); _set(_aidl_tag, _aidl_value); return; } case doubleValue: { double _aidl_value; _aidl_value = _aidl_parcel.readDouble(); _set(_aidl_tag, _aidl_value); return; } case enumValue: { long _aidl_value; _aidl_value = _aidl_parcel.readLong(); _set(_aidl_tag, _aidl_value); return; } } throw new IllegalArgumentException("union: unknown tag: " + _aidl_tag); } @Override public int describeContents() { int _mask = 0; switch (getTag()) { } return _mask; } private void _assertTag(int tag) { if (getTag() != tag) { throw new IllegalStateException("bad access: " + _tagString(tag) + ", " + _tagString(getTag()) + " is available."); } } private String _tagString(int _tag) { switch (_tag) { case booleanValue: return "booleanValue"; case byteValue: return "byteValue"; case charValue: return "charValue"; case intValue: return "intValue"; case longValue: return "longValue"; case floatValue: return "floatValue"; case doubleValue: return "doubleValue"; case enumValue: return "enumValue"; } throw new IllegalStateException("unknown field: " + _tag); } private void _set(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public static @interface Tag { public static final byte booleanValue = 0; public static final byte byteValue = 1; public static final byte charValue = 2; public static final byte intValue = 3; public static final byte longValue = 4; public static final byte floatValue = 5; public static final byte doubleValue = 6; public static final byte enumValue = 7; } } } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_FixedSize0100644 0000000 0000000 00000000034 15172120304 033170 xustar000000000 0000000 28 mtime=1776853188.4420000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/FixedSize.java.d0100644 0000000 0000000 00000000356 15172120304 031122 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/FixedSize.java : \ system/tools/aidl/tests/android/aidl/tests/FixedSize.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_GenericSt0100644 0000000 0000000 00000000221 15172120304 033157 xustar000000000 0000000 117 path=tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/GenericStructuredParcelable.java 28 mtime=1776853188.4420000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/GenericStructuredParcelab0100644 0000000 0000000 00000005467 15172120304 033171 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/GenericStructuredParcelable.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl */ package android.aidl.tests; public class GenericStructuredParcelable implements android.os.Parcelable { public int a = 0; public int b = 0; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public GenericStructuredParcelable createFromParcel(android.os.Parcel _aidl_source) { GenericStructuredParcelable _aidl_out = new GenericStructuredParcelable(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public GenericStructuredParcelable[] newArray(int _aidl_size) { return new GenericStructuredParcelable[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(a); _aidl_parcel.writeInt(b); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; a = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; b = _aidl_parcel.readInt(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public String toString() { java.util.StringJoiner _aidl_sj = new java.util.StringJoiner(", ", "{", "}"); _aidl_sj.add("a: " + (a)); _aidl_sj.add("b: " + (b)); return "GenericStructuredParcelable" + _aidl_sj.toString() ; } @Override public int describeContents() { int _mask = 0; return _mask; } } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_GenericSt0100644 0000000 0000000 00000000223 15172120304 033161 xustar000000000 0000000 119 path=tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/GenericStructuredParcelable.java.d 28 mtime=1776853188.4420000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/GenericStructuredParcelab0100644 0000000 0000000 00000000325 15172120304 033155 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/GenericStructuredParcelable.java : \ system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_ICircular0100644 0000000 0000000 00000000034 15172120304 033153 xustar000000000 0000000 28 mtime=1776853188.4420000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/ICircular.java0100644 0000000 0000000 00000011147 15172120304 030663 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/ICircular.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ICircular.aidl */ package android.aidl.tests; public interface ICircular extends android.os.IInterface { /** Default implementation for ICircular. */ public static class Default implements android.aidl.tests.ICircular { @Override public android.aidl.tests.ITestService GetTestService() throws android.os.RemoteException { return null; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.ICircular { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.ICircular interface, * generating a proxy if needed. */ public static android.aidl.tests.ICircular asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.ICircular))) { return ((android.aidl.tests.ICircular)iin); } return new android.aidl.tests.ICircular.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_GetTestService: { return "GetTestService"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_GetTestService: { android.aidl.tests.ITestService _result = this.GetTestService(); reply.writeNoException(); reply.writeStrongInterface(_result); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.ICircular { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public android.aidl.tests.ITestService GetTestService() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.ITestService _result; try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_GetTestService, _data, _reply, 0); _reply.readException(); _result = android.aidl.tests.ITestService.Stub.asInterface(_reply.readStrongBinder()); } finally { _reply.recycle(); _data.recycle(); } return _result; } } static final int TRANSACTION_GetTestService = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.ICircular"; public android.aidl.tests.ITestService GetTestService() throws android.os.RemoteException; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_ICircular0100644 0000000 0000000 00000000034 15172120304 033153 xustar000000000 0000000 28 mtime=1776853188.4420000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/ICircular.java.d0100644 0000000 0000000 00000002224 15172120304 031101 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/ICircular.java : \ system/tools/aidl/tests/android/aidl/tests/ICircular.aidl \ system/tools/aidl/tests/android/aidl/tests/ITestService.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl \ system/tools/aidl/tests/android/aidl/tests/SimpleParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl \ system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_IDeprecat0100644 0000000 0000000 00000000034 15172120304 033136 xustar000000000 0000000 28 mtime=1776853188.4420000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/IDeprecated.java0100644 0000000 0000000 00000006217 15172120304 031161 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/IDeprecated.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IDeprecated.aidl */ package android.aidl.tests; /** @deprecated test */ @Deprecated public interface IDeprecated extends android.os.IInterface { /** Default implementation for IDeprecated. */ public static class Default implements android.aidl.tests.IDeprecated { @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.IDeprecated { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.IDeprecated interface, * generating a proxy if needed. */ public static android.aidl.tests.IDeprecated asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.IDeprecated))) { return ((android.aidl.tests.IDeprecated)iin); } return new android.aidl.tests.IDeprecated.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { default: { return super.onTransact(code, data, reply, flags); } } } private static class Proxy implements android.aidl.tests.IDeprecated { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } } /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.IDeprecated"; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_IDeprecat0100644 0000000 0000000 00000000034 15172120304 033136 xustar000000000 0000000 28 mtime=1776853188.4420000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/IDeprecated.java.d0100644 0000000 0000000 00000000265 15172120304 031400 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/IDeprecated.java : \ system/tools/aidl/tests/android/aidl/tests/IDeprecated.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_INamedCal0100644 0000000 0000000 00000000034 15172120304 033053 xustar000000000 0000000 28 mtime=1776853188.4420000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/INamedCallback.java0100644 0000000 0000000 00000010735 15172120304 031562 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/INamedCallback.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl */ package android.aidl.tests; public interface INamedCallback extends android.os.IInterface { /** Default implementation for INamedCallback. */ public static class Default implements android.aidl.tests.INamedCallback { @Override public java.lang.String GetName() throws android.os.RemoteException { return null; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.INamedCallback { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.INamedCallback interface, * generating a proxy if needed. */ public static android.aidl.tests.INamedCallback asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.INamedCallback))) { return ((android.aidl.tests.INamedCallback)iin); } return new android.aidl.tests.INamedCallback.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_GetName: { return "GetName"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_GetName: { java.lang.String _result = this.GetName(); reply.writeNoException(); reply.writeString(_result); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.INamedCallback { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public java.lang.String GetName() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.lang.String _result; try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_GetName, _data, _reply, 0); _reply.readException(); _result = _reply.readString(); } finally { _reply.recycle(); _data.recycle(); } return _result; } } static final int TRANSACTION_GetName = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.INamedCallback"; public java.lang.String GetName() throws android.os.RemoteException; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_INamedCal0100644 0000000 0000000 00000000034 15172120304 033053 xustar000000000 0000000 28 mtime=1776853188.4420000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/INamedCallback.java.d0100644 0000000 0000000 00000000273 15172120304 032000 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/INamedCallback.java : \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_INewName.0100644 0000000 0000000 00000000034 15172120304 033017 xustar000000000 0000000 28 mtime=1776853188.4420000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/INewName.java0100644 0000000 0000000 00000010630 15172120304 030445 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/INewName.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INewName.aidl */ package android.aidl.tests; public interface INewName extends android.os.IInterface { /** Default implementation for INewName. */ public static class Default implements android.aidl.tests.INewName { @Override public java.lang.String RealName() throws android.os.RemoteException { return null; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.INewName { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.INewName interface, * generating a proxy if needed. */ public static android.aidl.tests.INewName asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.INewName))) { return ((android.aidl.tests.INewName)iin); } return new android.aidl.tests.INewName.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_RealName: { return "RealName"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_RealName: { java.lang.String _result = this.RealName(); reply.writeNoException(); reply.writeString(_result); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.INewName { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public java.lang.String RealName() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.lang.String _result; try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_RealName, _data, _reply, 0); _reply.readException(); _result = _reply.readString(); } finally { _reply.recycle(); _data.recycle(); } return _result; } } static final int TRANSACTION_RealName = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.IOldName"; public java.lang.String RealName() throws android.os.RemoteException; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_INewName.0100644 0000000 0000000 00000000034 15172120304 033017 xustar000000000 0000000 28 mtime=1776853188.4430000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/INewName.java.d0100644 0000000 0000000 00000000257 15172120304 030673 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/INewName.java : \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_IOldName.0100644 0000000 0000000 00000000034 15172120304 033004 xustar000000000 0000000 28 mtime=1776853188.4430000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/IOldName.java0100644 0000000 0000000 00000010630 15172120304 030432 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/IOldName.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IOldName.aidl */ package android.aidl.tests; public interface IOldName extends android.os.IInterface { /** Default implementation for IOldName. */ public static class Default implements android.aidl.tests.IOldName { @Override public java.lang.String RealName() throws android.os.RemoteException { return null; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.IOldName { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.IOldName interface, * generating a proxy if needed. */ public static android.aidl.tests.IOldName asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.IOldName))) { return ((android.aidl.tests.IOldName)iin); } return new android.aidl.tests.IOldName.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_RealName: { return "RealName"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_RealName: { java.lang.String _result = this.RealName(); reply.writeNoException(); reply.writeString(_result); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.IOldName { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public java.lang.String RealName() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.lang.String _result; try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_RealName, _data, _reply, 0); _reply.readException(); _result = _reply.readString(); } finally { _reply.recycle(); _data.recycle(); } return _result; } } static final int TRANSACTION_RealName = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.IOldName"; public java.lang.String RealName() throws android.os.RemoteException; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_IOldName.0100644 0000000 0000000 00000000034 15172120304 033004 xustar000000000 0000000 28 mtime=1776853188.4430000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/IOldName.java.d0100644 0000000 0000000 00000000257 15172120304 030660 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/IOldName.java : \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_ITestServ0100644 0000000 0000000 00000000034 15172120304 033166 xustar000000000 0000000 28 mtime=1776853188.4430000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/ITestService.java0100644 0000000 0000000 00000563307 15172120304 031371 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/ITestService.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ITestService.aidl */ package android.aidl.tests; /** interface comment */ /** interface comment 2 */ // interface comment 3 // interface comment 4 public interface ITestService extends android.os.IInterface { /** Default implementation for ITestService. */ public static class Default implements android.aidl.tests.ITestService { // This is to emulate a method that is added after the service is implemented. // So the client cannot assume that a call to this method will be successful // or not. However, inside the test environment, we can't build client and // the server with different version of this AIDL file. So, we let the server // actually implement this and intercept the dispatch to the method // inside onTransact(). // WARNING: Must be first method. // This requires hard coding the transaction number. As long as this method is // the first in this interface, it can keep the // "::android::IBinder::FIRST_CALL_TRANSACTION + 0" value and allow // methods to be added and removed. @Override public int UnimplementedMethod(int arg) throws android.os.RemoteException { return 0; } /** * @deprecated to make sure we have something in system/tools/aidl which does a compile check * of deprecated and make sure this is reflected in goldens */ @Override public void Deprecated() throws android.os.RemoteException { } @Override public void TestOneway() throws android.os.RemoteException { } // Test that primitives work as parameters and return types. @Override public boolean RepeatBoolean(boolean token) throws android.os.RemoteException { return false; } @Override public byte RepeatByte(byte token) throws android.os.RemoteException { return 0; } @Override public char RepeatChar(char token) throws android.os.RemoteException { return '\u0000'; } @Override public int RepeatInt(int token) throws android.os.RemoteException { return 0; } @Override public long RepeatLong(long token) throws android.os.RemoteException { return 0L; } @Override public float RepeatFloat(float token) throws android.os.RemoteException { return 0.0f; } @Override public double RepeatDouble(double token) throws android.os.RemoteException { return 0.0d; } @Override public java.lang.String RepeatString(java.lang.String token) throws android.os.RemoteException { return null; } @Override public byte RepeatByteEnum(byte token) throws android.os.RemoteException { return 0; } @Override public int RepeatIntEnum(int token) throws android.os.RemoteException { return 0; } @Override public long RepeatLongEnum(long token) throws android.os.RemoteException { return 0L; } // Test that arrays work as parameters and return types. @Override public boolean[] ReverseBoolean(boolean[] input, boolean[] repeated) throws android.os.RemoteException { return null; } @Override public byte[] ReverseByte(byte[] input, byte[] repeated) throws android.os.RemoteException { return null; } @Override public char[] ReverseChar(char[] input, char[] repeated) throws android.os.RemoteException { return null; } @Override public int[] ReverseInt(int[] input, int[] repeated) throws android.os.RemoteException { return null; } @Override public long[] ReverseLong(long[] input, long[] repeated) throws android.os.RemoteException { return null; } @Override public float[] ReverseFloat(float[] input, float[] repeated) throws android.os.RemoteException { return null; } @Override public double[] ReverseDouble(double[] input, double[] repeated) throws android.os.RemoteException { return null; } @Override public java.lang.String[] ReverseString(java.lang.String[] input, java.lang.String[] repeated) throws android.os.RemoteException { return null; } @Override public byte[] ReverseByteEnum(byte[] input, byte[] repeated) throws android.os.RemoteException { return null; } @Override public int[] ReverseIntEnum(int[] input, int[] repeated) throws android.os.RemoteException { return null; } @Override public long[] ReverseLongEnum(long[] input, long[] repeated) throws android.os.RemoteException { return null; } // Test that clients can send and receive Binders. @Override public android.aidl.tests.INamedCallback GetOtherTestService(java.lang.String name) throws android.os.RemoteException { return null; } // returns true if the same service is already registered with the same name @Override public boolean SetOtherTestService(java.lang.String name, android.aidl.tests.INamedCallback service) throws android.os.RemoteException { return false; } @Override public boolean VerifyName(android.aidl.tests.INamedCallback service, java.lang.String name) throws android.os.RemoteException { return false; } @Override public android.aidl.tests.INamedCallback[] GetInterfaceArray(java.lang.String[] names) throws android.os.RemoteException { return null; } @Override public boolean VerifyNamesWithInterfaceArray(android.aidl.tests.INamedCallback[] services, java.lang.String[] names) throws android.os.RemoteException { return false; } @Override public android.aidl.tests.INamedCallback[] GetNullableInterfaceArray(java.lang.String[] names) throws android.os.RemoteException { return null; } @Override public boolean VerifyNamesWithNullableInterfaceArray(android.aidl.tests.INamedCallback[] services, java.lang.String[] names) throws android.os.RemoteException { return false; } @Override public java.util.List GetInterfaceList(java.lang.String[] names) throws android.os.RemoteException { return null; } @Override public boolean VerifyNamesWithInterfaceList(java.util.List services, java.lang.String[] names) throws android.os.RemoteException { return false; } // Test that List types work correctly. @Override public java.util.List ReverseStringList(java.util.List input, java.util.List repeated) throws android.os.RemoteException { return null; } @Override public android.os.ParcelFileDescriptor RepeatParcelFileDescriptor(android.os.ParcelFileDescriptor read) throws android.os.RemoteException { return null; } @Override public android.os.ParcelFileDescriptor[] ReverseParcelFileDescriptorArray(android.os.ParcelFileDescriptor[] input, android.os.ParcelFileDescriptor[] repeated) throws android.os.RemoteException { return null; } // Test that service specific exceptions work correctly. @Override public void ThrowServiceException(int code) throws android.os.RemoteException { } // Test nullability @Override public int[] RepeatNullableIntArray(int[] input) throws android.os.RemoteException { return null; } @Override public byte[] RepeatNullableByteEnumArray(byte[] input) throws android.os.RemoteException { return null; } @Override public int[] RepeatNullableIntEnumArray(int[] input) throws android.os.RemoteException { return null; } @Override public long[] RepeatNullableLongEnumArray(long[] input) throws android.os.RemoteException { return null; } @Override public java.lang.String RepeatNullableString(java.lang.String input) throws android.os.RemoteException { return null; } @Override public java.util.List RepeatNullableStringList(java.util.List input) throws android.os.RemoteException { return null; } @Override public android.aidl.tests.ITestService.Empty RepeatNullableParcelable(android.aidl.tests.ITestService.Empty input) throws android.os.RemoteException { return null; } @Override public android.aidl.tests.ITestService.Empty[] RepeatNullableParcelableArray(android.aidl.tests.ITestService.Empty[] input) throws android.os.RemoteException { return null; } @Override public java.util.List RepeatNullableParcelableList(java.util.List input) throws android.os.RemoteException { return null; } @Override public void TakesAnIBinder(android.os.IBinder input) throws android.os.RemoteException { } @Override public void TakesANullableIBinder(android.os.IBinder input) throws android.os.RemoteException { } @Override public void TakesAnIBinderList(java.util.List input) throws android.os.RemoteException { } @Override public void TakesANullableIBinderList(java.util.List input) throws android.os.RemoteException { } // Test utf8 decoding from utf16 wire format @Override public java.lang.String RepeatUtf8CppString(java.lang.String token) throws android.os.RemoteException { return null; } @Override public java.lang.String RepeatNullableUtf8CppString(java.lang.String token) throws android.os.RemoteException { return null; } @Override public java.lang.String[] ReverseUtf8CppString(java.lang.String[] input, java.lang.String[] repeated) throws android.os.RemoteException { return null; } @Override public java.lang.String[] ReverseNullableUtf8CppString(java.lang.String[] input, java.lang.String[] repeated) throws android.os.RemoteException { return null; } @Override public java.util.List ReverseUtf8CppStringList(java.util.List input, java.util.List repeated) throws android.os.RemoteException { return null; } /** comment before annotation */ @Override public android.aidl.tests.INamedCallback GetCallback(boolean return_null) throws android.os.RemoteException { return null; } // Since this paracelable has clearly defined default values, it would be // inefficient to use an IPC to fill it out in practice. @Override public void FillOutStructuredParcelable(android.aidl.tests.StructuredParcelable parcel) throws android.os.RemoteException { } @Override public void RepeatExtendableParcelable(android.aidl.tests.extension.ExtendableParcelable ep, android.aidl.tests.extension.ExtendableParcelable ep2) throws android.os.RemoteException { } @Override public android.aidl.tests.RecursiveList ReverseList(android.aidl.tests.RecursiveList list) throws android.os.RemoteException { return null; } @Override public android.os.IBinder[] ReverseIBinderArray(android.os.IBinder[] input, android.os.IBinder[] repeated) throws android.os.RemoteException { return null; } @Override public android.os.IBinder[] ReverseNullableIBinderArray(android.os.IBinder[] input, android.os.IBinder[] repeated) throws android.os.RemoteException { return null; } @Override public android.aidl.tests.SimpleParcelable RepeatSimpleParcelable(android.aidl.tests.SimpleParcelable input, android.aidl.tests.SimpleParcelable repeat) throws android.os.RemoteException { return null; } @Override public android.aidl.tests.SimpleParcelable[] ReverseSimpleParcelables(android.aidl.tests.SimpleParcelable[] input, android.aidl.tests.SimpleParcelable[] repeated) throws android.os.RemoteException { return null; } @Override public android.aidl.tests.IOldName GetOldNameInterface() throws android.os.RemoteException { return null; } @Override public android.aidl.tests.INewName GetNewNameInterface() throws android.os.RemoteException { return null; } @Override public int[] GetUnionTags(android.aidl.tests.Union[] input) throws android.os.RemoteException { return null; } // Retrieve the ICppJavaTests if the server supports it @Override public android.os.IBinder GetCppJavaTests() throws android.os.RemoteException { return null; } @Override public byte getBackendType() throws android.os.RemoteException { return 0; } @Override public android.aidl.tests.ICircular GetCircular(android.aidl.tests.CircularParcelable cp) throws android.os.RemoteException { return null; } @Override public android.os.IBinder asBinder() { return null; } } /** Delegator implementation for ITestService. */ public static class Delegator extends android.aidl.tests.ITestService.Stub { public Delegator(android.aidl.tests.ITestService impl) { this.mImpl = impl; } // This is to emulate a method that is added after the service is implemented. // So the client cannot assume that a call to this method will be successful // or not. However, inside the test environment, we can't build client and // the server with different version of this AIDL file. So, we let the server // actually implement this and intercept the dispatch to the method // inside onTransact(). // WARNING: Must be first method. // This requires hard coding the transaction number. As long as this method is // the first in this interface, it can keep the // "::android::IBinder::FIRST_CALL_TRANSACTION + 0" value and allow // methods to be added and removed. @Override public int UnimplementedMethod(int arg) throws android.os.RemoteException { return mImpl.UnimplementedMethod(arg); } /** * @deprecated to make sure we have something in system/tools/aidl which does a compile check * of deprecated and make sure this is reflected in goldens */ @Override public void Deprecated() throws android.os.RemoteException { mImpl.Deprecated(); } @Override public void TestOneway() throws android.os.RemoteException { mImpl.TestOneway(); } // Test that primitives work as parameters and return types. @Override public boolean RepeatBoolean(boolean token) throws android.os.RemoteException { return mImpl.RepeatBoolean(token); } @Override public byte RepeatByte(byte token) throws android.os.RemoteException { return mImpl.RepeatByte(token); } @Override public char RepeatChar(char token) throws android.os.RemoteException { return mImpl.RepeatChar(token); } @Override public int RepeatInt(int token) throws android.os.RemoteException { return mImpl.RepeatInt(token); } @Override public long RepeatLong(long token) throws android.os.RemoteException { return mImpl.RepeatLong(token); } @Override public float RepeatFloat(float token) throws android.os.RemoteException { return mImpl.RepeatFloat(token); } @Override public double RepeatDouble(double token) throws android.os.RemoteException { return mImpl.RepeatDouble(token); } @Override public java.lang.String RepeatString(java.lang.String token) throws android.os.RemoteException { return mImpl.RepeatString(token); } @Override public byte RepeatByteEnum(byte token) throws android.os.RemoteException { return mImpl.RepeatByteEnum(token); } @Override public int RepeatIntEnum(int token) throws android.os.RemoteException { return mImpl.RepeatIntEnum(token); } @Override public long RepeatLongEnum(long token) throws android.os.RemoteException { return mImpl.RepeatLongEnum(token); } // Test that arrays work as parameters and return types. @Override public boolean[] ReverseBoolean(boolean[] input, boolean[] repeated) throws android.os.RemoteException { return mImpl.ReverseBoolean(input,repeated); } @Override public byte[] ReverseByte(byte[] input, byte[] repeated) throws android.os.RemoteException { return mImpl.ReverseByte(input,repeated); } @Override public char[] ReverseChar(char[] input, char[] repeated) throws android.os.RemoteException { return mImpl.ReverseChar(input,repeated); } @Override public int[] ReverseInt(int[] input, int[] repeated) throws android.os.RemoteException { return mImpl.ReverseInt(input,repeated); } @Override public long[] ReverseLong(long[] input, long[] repeated) throws android.os.RemoteException { return mImpl.ReverseLong(input,repeated); } @Override public float[] ReverseFloat(float[] input, float[] repeated) throws android.os.RemoteException { return mImpl.ReverseFloat(input,repeated); } @Override public double[] ReverseDouble(double[] input, double[] repeated) throws android.os.RemoteException { return mImpl.ReverseDouble(input,repeated); } @Override public java.lang.String[] ReverseString(java.lang.String[] input, java.lang.String[] repeated) throws android.os.RemoteException { return mImpl.ReverseString(input,repeated); } @Override public byte[] ReverseByteEnum(byte[] input, byte[] repeated) throws android.os.RemoteException { return mImpl.ReverseByteEnum(input,repeated); } @Override public int[] ReverseIntEnum(int[] input, int[] repeated) throws android.os.RemoteException { return mImpl.ReverseIntEnum(input,repeated); } @Override public long[] ReverseLongEnum(long[] input, long[] repeated) throws android.os.RemoteException { return mImpl.ReverseLongEnum(input,repeated); } // Test that clients can send and receive Binders. @Override public android.aidl.tests.INamedCallback GetOtherTestService(java.lang.String name) throws android.os.RemoteException { return mImpl.GetOtherTestService(name); } // returns true if the same service is already registered with the same name @Override public boolean SetOtherTestService(java.lang.String name, android.aidl.tests.INamedCallback service) throws android.os.RemoteException { return mImpl.SetOtherTestService(name,service); } @Override public boolean VerifyName(android.aidl.tests.INamedCallback service, java.lang.String name) throws android.os.RemoteException { return mImpl.VerifyName(service,name); } @Override public android.aidl.tests.INamedCallback[] GetInterfaceArray(java.lang.String[] names) throws android.os.RemoteException { return mImpl.GetInterfaceArray(names); } @Override public boolean VerifyNamesWithInterfaceArray(android.aidl.tests.INamedCallback[] services, java.lang.String[] names) throws android.os.RemoteException { return mImpl.VerifyNamesWithInterfaceArray(services,names); } @Override public android.aidl.tests.INamedCallback[] GetNullableInterfaceArray(java.lang.String[] names) throws android.os.RemoteException { return mImpl.GetNullableInterfaceArray(names); } @Override public boolean VerifyNamesWithNullableInterfaceArray(android.aidl.tests.INamedCallback[] services, java.lang.String[] names) throws android.os.RemoteException { return mImpl.VerifyNamesWithNullableInterfaceArray(services,names); } @Override public java.util.List GetInterfaceList(java.lang.String[] names) throws android.os.RemoteException { return mImpl.GetInterfaceList(names); } @Override public boolean VerifyNamesWithInterfaceList(java.util.List services, java.lang.String[] names) throws android.os.RemoteException { return mImpl.VerifyNamesWithInterfaceList(services,names); } // Test that List types work correctly. @Override public java.util.List ReverseStringList(java.util.List input, java.util.List repeated) throws android.os.RemoteException { return mImpl.ReverseStringList(input,repeated); } @Override public android.os.ParcelFileDescriptor RepeatParcelFileDescriptor(android.os.ParcelFileDescriptor read) throws android.os.RemoteException { return mImpl.RepeatParcelFileDescriptor(read); } @Override public android.os.ParcelFileDescriptor[] ReverseParcelFileDescriptorArray(android.os.ParcelFileDescriptor[] input, android.os.ParcelFileDescriptor[] repeated) throws android.os.RemoteException { return mImpl.ReverseParcelFileDescriptorArray(input,repeated); } // Test that service specific exceptions work correctly. @Override public void ThrowServiceException(int code) throws android.os.RemoteException { mImpl.ThrowServiceException(code); } // Test nullability @Override public int[] RepeatNullableIntArray(int[] input) throws android.os.RemoteException { return mImpl.RepeatNullableIntArray(input); } @Override public byte[] RepeatNullableByteEnumArray(byte[] input) throws android.os.RemoteException { return mImpl.RepeatNullableByteEnumArray(input); } @Override public int[] RepeatNullableIntEnumArray(int[] input) throws android.os.RemoteException { return mImpl.RepeatNullableIntEnumArray(input); } @Override public long[] RepeatNullableLongEnumArray(long[] input) throws android.os.RemoteException { return mImpl.RepeatNullableLongEnumArray(input); } @Override public java.lang.String RepeatNullableString(java.lang.String input) throws android.os.RemoteException { return mImpl.RepeatNullableString(input); } @Override public java.util.List RepeatNullableStringList(java.util.List input) throws android.os.RemoteException { return mImpl.RepeatNullableStringList(input); } @Override public android.aidl.tests.ITestService.Empty RepeatNullableParcelable(android.aidl.tests.ITestService.Empty input) throws android.os.RemoteException { return mImpl.RepeatNullableParcelable(input); } @Override public android.aidl.tests.ITestService.Empty[] RepeatNullableParcelableArray(android.aidl.tests.ITestService.Empty[] input) throws android.os.RemoteException { return mImpl.RepeatNullableParcelableArray(input); } @Override public java.util.List RepeatNullableParcelableList(java.util.List input) throws android.os.RemoteException { return mImpl.RepeatNullableParcelableList(input); } @Override public void TakesAnIBinder(android.os.IBinder input) throws android.os.RemoteException { mImpl.TakesAnIBinder(input); } @Override public void TakesANullableIBinder(android.os.IBinder input) throws android.os.RemoteException { mImpl.TakesANullableIBinder(input); } @Override public void TakesAnIBinderList(java.util.List input) throws android.os.RemoteException { mImpl.TakesAnIBinderList(input); } @Override public void TakesANullableIBinderList(java.util.List input) throws android.os.RemoteException { mImpl.TakesANullableIBinderList(input); } // Test utf8 decoding from utf16 wire format @Override public java.lang.String RepeatUtf8CppString(java.lang.String token) throws android.os.RemoteException { return mImpl.RepeatUtf8CppString(token); } @Override public java.lang.String RepeatNullableUtf8CppString(java.lang.String token) throws android.os.RemoteException { return mImpl.RepeatNullableUtf8CppString(token); } @Override public java.lang.String[] ReverseUtf8CppString(java.lang.String[] input, java.lang.String[] repeated) throws android.os.RemoteException { return mImpl.ReverseUtf8CppString(input,repeated); } @Override public java.lang.String[] ReverseNullableUtf8CppString(java.lang.String[] input, java.lang.String[] repeated) throws android.os.RemoteException { return mImpl.ReverseNullableUtf8CppString(input,repeated); } @Override public java.util.List ReverseUtf8CppStringList(java.util.List input, java.util.List repeated) throws android.os.RemoteException { return mImpl.ReverseUtf8CppStringList(input,repeated); } /** comment before annotation */ @Override public android.aidl.tests.INamedCallback GetCallback(boolean return_null) throws android.os.RemoteException { return mImpl.GetCallback(return_null); } // Since this paracelable has clearly defined default values, it would be // inefficient to use an IPC to fill it out in practice. @Override public void FillOutStructuredParcelable(android.aidl.tests.StructuredParcelable parcel) throws android.os.RemoteException { mImpl.FillOutStructuredParcelable(parcel); } @Override public void RepeatExtendableParcelable(android.aidl.tests.extension.ExtendableParcelable ep, android.aidl.tests.extension.ExtendableParcelable ep2) throws android.os.RemoteException { mImpl.RepeatExtendableParcelable(ep,ep2); } @Override public android.aidl.tests.RecursiveList ReverseList(android.aidl.tests.RecursiveList list) throws android.os.RemoteException { return mImpl.ReverseList(list); } @Override public android.os.IBinder[] ReverseIBinderArray(android.os.IBinder[] input, android.os.IBinder[] repeated) throws android.os.RemoteException { return mImpl.ReverseIBinderArray(input,repeated); } @Override public android.os.IBinder[] ReverseNullableIBinderArray(android.os.IBinder[] input, android.os.IBinder[] repeated) throws android.os.RemoteException { return mImpl.ReverseNullableIBinderArray(input,repeated); } @Override public android.aidl.tests.SimpleParcelable RepeatSimpleParcelable(android.aidl.tests.SimpleParcelable input, android.aidl.tests.SimpleParcelable repeat) throws android.os.RemoteException { return mImpl.RepeatSimpleParcelable(input,repeat); } @Override public android.aidl.tests.SimpleParcelable[] ReverseSimpleParcelables(android.aidl.tests.SimpleParcelable[] input, android.aidl.tests.SimpleParcelable[] repeated) throws android.os.RemoteException { return mImpl.ReverseSimpleParcelables(input,repeated); } @Override public android.aidl.tests.IOldName GetOldNameInterface() throws android.os.RemoteException { return mImpl.GetOldNameInterface(); } @Override public android.aidl.tests.INewName GetNewNameInterface() throws android.os.RemoteException { return mImpl.GetNewNameInterface(); } @Override public int[] GetUnionTags(android.aidl.tests.Union[] input) throws android.os.RemoteException { return mImpl.GetUnionTags(input); } // Retrieve the ICppJavaTests if the server supports it @Override public android.os.IBinder GetCppJavaTests() throws android.os.RemoteException { return mImpl.GetCppJavaTests(); } @Override public byte getBackendType() throws android.os.RemoteException { return mImpl.getBackendType(); } @Override public android.aidl.tests.ICircular GetCircular(android.aidl.tests.CircularParcelable cp) throws android.os.RemoteException { return mImpl.GetCircular(cp); } android.aidl.tests.ITestService mImpl; } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.ITestService { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.ITestService interface, * generating a proxy if needed. */ public static android.aidl.tests.ITestService asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.ITestService))) { return ((android.aidl.tests.ITestService)iin); } return new android.aidl.tests.ITestService.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_UnimplementedMethod: { return "UnimplementedMethod"; } case TRANSACTION_Deprecated: { return "Deprecated"; } case TRANSACTION_TestOneway: { return "TestOneway"; } case TRANSACTION_RepeatBoolean: { return "RepeatBoolean"; } case TRANSACTION_RepeatByte: { return "RepeatByte"; } case TRANSACTION_RepeatChar: { return "RepeatChar"; } case TRANSACTION_RepeatInt: { return "RepeatInt"; } case TRANSACTION_RepeatLong: { return "RepeatLong"; } case TRANSACTION_RepeatFloat: { return "RepeatFloat"; } case TRANSACTION_RepeatDouble: { return "RepeatDouble"; } case TRANSACTION_RepeatString: { return "RepeatString"; } case TRANSACTION_RepeatByteEnum: { return "RepeatByteEnum"; } case TRANSACTION_RepeatIntEnum: { return "RepeatIntEnum"; } case TRANSACTION_RepeatLongEnum: { return "RepeatLongEnum"; } case TRANSACTION_ReverseBoolean: { return "ReverseBoolean"; } case TRANSACTION_ReverseByte: { return "ReverseByte"; } case TRANSACTION_ReverseChar: { return "ReverseChar"; } case TRANSACTION_ReverseInt: { return "ReverseInt"; } case TRANSACTION_ReverseLong: { return "ReverseLong"; } case TRANSACTION_ReverseFloat: { return "ReverseFloat"; } case TRANSACTION_ReverseDouble: { return "ReverseDouble"; } case TRANSACTION_ReverseString: { return "ReverseString"; } case TRANSACTION_ReverseByteEnum: { return "ReverseByteEnum"; } case TRANSACTION_ReverseIntEnum: { return "ReverseIntEnum"; } case TRANSACTION_ReverseLongEnum: { return "ReverseLongEnum"; } case TRANSACTION_GetOtherTestService: { return "GetOtherTestService"; } case TRANSACTION_SetOtherTestService: { return "SetOtherTestService"; } case TRANSACTION_VerifyName: { return "VerifyName"; } case TRANSACTION_GetInterfaceArray: { return "GetInterfaceArray"; } case TRANSACTION_VerifyNamesWithInterfaceArray: { return "VerifyNamesWithInterfaceArray"; } case TRANSACTION_GetNullableInterfaceArray: { return "GetNullableInterfaceArray"; } case TRANSACTION_VerifyNamesWithNullableInterfaceArray: { return "VerifyNamesWithNullableInterfaceArray"; } case TRANSACTION_GetInterfaceList: { return "GetInterfaceList"; } case TRANSACTION_VerifyNamesWithInterfaceList: { return "VerifyNamesWithInterfaceList"; } case TRANSACTION_ReverseStringList: { return "ReverseStringList"; } case TRANSACTION_RepeatParcelFileDescriptor: { return "RepeatParcelFileDescriptor"; } case TRANSACTION_ReverseParcelFileDescriptorArray: { return "ReverseParcelFileDescriptorArray"; } case TRANSACTION_ThrowServiceException: { return "ThrowServiceException"; } case TRANSACTION_RepeatNullableIntArray: { return "RepeatNullableIntArray"; } case TRANSACTION_RepeatNullableByteEnumArray: { return "RepeatNullableByteEnumArray"; } case TRANSACTION_RepeatNullableIntEnumArray: { return "RepeatNullableIntEnumArray"; } case TRANSACTION_RepeatNullableLongEnumArray: { return "RepeatNullableLongEnumArray"; } case TRANSACTION_RepeatNullableString: { return "RepeatNullableString"; } case TRANSACTION_RepeatNullableStringList: { return "RepeatNullableStringList"; } case TRANSACTION_RepeatNullableParcelable: { return "RepeatNullableParcelable"; } case TRANSACTION_RepeatNullableParcelableArray: { return "RepeatNullableParcelableArray"; } case TRANSACTION_RepeatNullableParcelableList: { return "RepeatNullableParcelableList"; } case TRANSACTION_TakesAnIBinder: { return "TakesAnIBinder"; } case TRANSACTION_TakesANullableIBinder: { return "TakesANullableIBinder"; } case TRANSACTION_TakesAnIBinderList: { return "TakesAnIBinderList"; } case TRANSACTION_TakesANullableIBinderList: { return "TakesANullableIBinderList"; } case TRANSACTION_RepeatUtf8CppString: { return "RepeatUtf8CppString"; } case TRANSACTION_RepeatNullableUtf8CppString: { return "RepeatNullableUtf8CppString"; } case TRANSACTION_ReverseUtf8CppString: { return "ReverseUtf8CppString"; } case TRANSACTION_ReverseNullableUtf8CppString: { return "ReverseNullableUtf8CppString"; } case TRANSACTION_ReverseUtf8CppStringList: { return "ReverseUtf8CppStringList"; } case TRANSACTION_GetCallback: { return "GetCallback"; } case TRANSACTION_FillOutStructuredParcelable: { return "FillOutStructuredParcelable"; } case TRANSACTION_RepeatExtendableParcelable: { return "RepeatExtendableParcelable"; } case TRANSACTION_ReverseList: { return "ReverseList"; } case TRANSACTION_ReverseIBinderArray: { return "ReverseIBinderArray"; } case TRANSACTION_ReverseNullableIBinderArray: { return "ReverseNullableIBinderArray"; } case TRANSACTION_RepeatSimpleParcelable: { return "RepeatSimpleParcelable"; } case TRANSACTION_ReverseSimpleParcelables: { return "ReverseSimpleParcelables"; } case TRANSACTION_GetOldNameInterface: { return "GetOldNameInterface"; } case TRANSACTION_GetNewNameInterface: { return "GetNewNameInterface"; } case TRANSACTION_GetUnionTags: { return "GetUnionTags"; } case TRANSACTION_GetCppJavaTests: { return "GetCppJavaTests"; } case TRANSACTION_getBackendType: { return "getBackendType"; } case TRANSACTION_GetCircular: { return "GetCircular"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_UnimplementedMethod: { int _arg0; _arg0 = data.readInt(); data.enforceNoDataAvail(); int _result = this.UnimplementedMethod(_arg0); reply.writeNoException(); reply.writeInt(_result); break; } case TRANSACTION_Deprecated: { this.Deprecated(); reply.writeNoException(); break; } case TRANSACTION_TestOneway: { this.TestOneway(); break; } case TRANSACTION_RepeatBoolean: { boolean _arg0; _arg0 = data.readBoolean(); data.enforceNoDataAvail(); boolean _result = this.RepeatBoolean(_arg0); reply.writeNoException(); reply.writeBoolean(_result); break; } case TRANSACTION_RepeatByte: { byte _arg0; _arg0 = data.readByte(); data.enforceNoDataAvail(); byte _result = this.RepeatByte(_arg0); reply.writeNoException(); reply.writeByte(_result); break; } case TRANSACTION_RepeatChar: { char _arg0; _arg0 = (char)data.readInt(); data.enforceNoDataAvail(); char _result = this.RepeatChar(_arg0); reply.writeNoException(); reply.writeInt(((int)_result)); break; } case TRANSACTION_RepeatInt: { int _arg0; _arg0 = data.readInt(); data.enforceNoDataAvail(); int _result = this.RepeatInt(_arg0); reply.writeNoException(); reply.writeInt(_result); break; } case TRANSACTION_RepeatLong: { long _arg0; _arg0 = data.readLong(); data.enforceNoDataAvail(); long _result = this.RepeatLong(_arg0); reply.writeNoException(); reply.writeLong(_result); break; } case TRANSACTION_RepeatFloat: { float _arg0; _arg0 = data.readFloat(); data.enforceNoDataAvail(); float _result = this.RepeatFloat(_arg0); reply.writeNoException(); reply.writeFloat(_result); break; } case TRANSACTION_RepeatDouble: { double _arg0; _arg0 = data.readDouble(); data.enforceNoDataAvail(); double _result = this.RepeatDouble(_arg0); reply.writeNoException(); reply.writeDouble(_result); break; } case TRANSACTION_RepeatString: { java.lang.String _arg0; _arg0 = data.readString(); data.enforceNoDataAvail(); java.lang.String _result = this.RepeatString(_arg0); reply.writeNoException(); reply.writeString(_result); break; } case TRANSACTION_RepeatByteEnum: { byte _arg0; _arg0 = data.readByte(); data.enforceNoDataAvail(); byte _result = this.RepeatByteEnum(_arg0); reply.writeNoException(); reply.writeByte(_result); break; } case TRANSACTION_RepeatIntEnum: { int _arg0; _arg0 = data.readInt(); data.enforceNoDataAvail(); int _result = this.RepeatIntEnum(_arg0); reply.writeNoException(); reply.writeInt(_result); break; } case TRANSACTION_RepeatLongEnum: { long _arg0; _arg0 = data.readLong(); data.enforceNoDataAvail(); long _result = this.RepeatLongEnum(_arg0); reply.writeNoException(); reply.writeLong(_result); break; } case TRANSACTION_ReverseBoolean: { boolean[] _arg0; _arg0 = data.createBooleanArray(); boolean[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new boolean[_arg1_length]; } data.enforceNoDataAvail(); boolean[] _result = this.ReverseBoolean(_arg0, _arg1); reply.writeNoException(); reply.writeBooleanArray(_result); reply.writeBooleanArray(_arg1); break; } case TRANSACTION_ReverseByte: { byte[] _arg0; _arg0 = data.createByteArray(); byte[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new byte[_arg1_length]; } data.enforceNoDataAvail(); byte[] _result = this.ReverseByte(_arg0, _arg1); reply.writeNoException(); reply.writeByteArray(_result); reply.writeByteArray(_arg1); break; } case TRANSACTION_ReverseChar: { char[] _arg0; _arg0 = data.createCharArray(); char[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new char[_arg1_length]; } data.enforceNoDataAvail(); char[] _result = this.ReverseChar(_arg0, _arg1); reply.writeNoException(); reply.writeCharArray(_result); reply.writeCharArray(_arg1); break; } case TRANSACTION_ReverseInt: { int[] _arg0; _arg0 = data.createIntArray(); int[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new int[_arg1_length]; } data.enforceNoDataAvail(); int[] _result = this.ReverseInt(_arg0, _arg1); reply.writeNoException(); reply.writeIntArray(_result); reply.writeIntArray(_arg1); break; } case TRANSACTION_ReverseLong: { long[] _arg0; _arg0 = data.createLongArray(); long[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new long[_arg1_length]; } data.enforceNoDataAvail(); long[] _result = this.ReverseLong(_arg0, _arg1); reply.writeNoException(); reply.writeLongArray(_result); reply.writeLongArray(_arg1); break; } case TRANSACTION_ReverseFloat: { float[] _arg0; _arg0 = data.createFloatArray(); float[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new float[_arg1_length]; } data.enforceNoDataAvail(); float[] _result = this.ReverseFloat(_arg0, _arg1); reply.writeNoException(); reply.writeFloatArray(_result); reply.writeFloatArray(_arg1); break; } case TRANSACTION_ReverseDouble: { double[] _arg0; _arg0 = data.createDoubleArray(); double[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new double[_arg1_length]; } data.enforceNoDataAvail(); double[] _result = this.ReverseDouble(_arg0, _arg1); reply.writeNoException(); reply.writeDoubleArray(_result); reply.writeDoubleArray(_arg1); break; } case TRANSACTION_ReverseString: { java.lang.String[] _arg0; _arg0 = data.createStringArray(); java.lang.String[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new java.lang.String[_arg1_length]; } data.enforceNoDataAvail(); java.lang.String[] _result = this.ReverseString(_arg0, _arg1); reply.writeNoException(); reply.writeStringArray(_result); reply.writeStringArray(_arg1); break; } case TRANSACTION_ReverseByteEnum: { byte[] _arg0; _arg0 = data.createByteArray(); byte[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new byte[_arg1_length]; } data.enforceNoDataAvail(); byte[] _result = this.ReverseByteEnum(_arg0, _arg1); reply.writeNoException(); reply.writeByteArray(_result); reply.writeByteArray(_arg1); break; } case TRANSACTION_ReverseIntEnum: { int[] _arg0; _arg0 = data.createIntArray(); int[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new int[_arg1_length]; } data.enforceNoDataAvail(); int[] _result = this.ReverseIntEnum(_arg0, _arg1); reply.writeNoException(); reply.writeIntArray(_result); reply.writeIntArray(_arg1); break; } case TRANSACTION_ReverseLongEnum: { long[] _arg0; _arg0 = data.createLongArray(); long[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new long[_arg1_length]; } data.enforceNoDataAvail(); long[] _result = this.ReverseLongEnum(_arg0, _arg1); reply.writeNoException(); reply.writeLongArray(_result); reply.writeLongArray(_arg1); break; } case TRANSACTION_GetOtherTestService: { java.lang.String _arg0; _arg0 = data.readString(); data.enforceNoDataAvail(); android.aidl.tests.INamedCallback _result = this.GetOtherTestService(_arg0); reply.writeNoException(); reply.writeStrongInterface(_result); break; } case TRANSACTION_SetOtherTestService: { java.lang.String _arg0; _arg0 = data.readString(); android.aidl.tests.INamedCallback _arg1; _arg1 = android.aidl.tests.INamedCallback.Stub.asInterface(data.readStrongBinder()); data.enforceNoDataAvail(); boolean _result = this.SetOtherTestService(_arg0, _arg1); reply.writeNoException(); reply.writeBoolean(_result); break; } case TRANSACTION_VerifyName: { android.aidl.tests.INamedCallback _arg0; _arg0 = android.aidl.tests.INamedCallback.Stub.asInterface(data.readStrongBinder()); java.lang.String _arg1; _arg1 = data.readString(); data.enforceNoDataAvail(); boolean _result = this.VerifyName(_arg0, _arg1); reply.writeNoException(); reply.writeBoolean(_result); break; } case TRANSACTION_GetInterfaceArray: { java.lang.String[] _arg0; _arg0 = data.createStringArray(); data.enforceNoDataAvail(); android.aidl.tests.INamedCallback[] _result = this.GetInterfaceArray(_arg0); reply.writeNoException(); reply.writeInterfaceArray(_result); break; } case TRANSACTION_VerifyNamesWithInterfaceArray: { android.aidl.tests.INamedCallback[] _arg0; _arg0 = data.createInterfaceArray(android.aidl.tests.INamedCallback[]::new, android.aidl.tests.INamedCallback.Stub::asInterface); java.lang.String[] _arg1; _arg1 = data.createStringArray(); data.enforceNoDataAvail(); boolean _result = this.VerifyNamesWithInterfaceArray(_arg0, _arg1); reply.writeNoException(); reply.writeBoolean(_result); break; } case TRANSACTION_GetNullableInterfaceArray: { java.lang.String[] _arg0; _arg0 = data.createStringArray(); data.enforceNoDataAvail(); android.aidl.tests.INamedCallback[] _result = this.GetNullableInterfaceArray(_arg0); reply.writeNoException(); reply.writeInterfaceArray(_result); break; } case TRANSACTION_VerifyNamesWithNullableInterfaceArray: { android.aidl.tests.INamedCallback[] _arg0; _arg0 = data.createInterfaceArray(android.aidl.tests.INamedCallback[]::new, android.aidl.tests.INamedCallback.Stub::asInterface); java.lang.String[] _arg1; _arg1 = data.createStringArray(); data.enforceNoDataAvail(); boolean _result = this.VerifyNamesWithNullableInterfaceArray(_arg0, _arg1); reply.writeNoException(); reply.writeBoolean(_result); break; } case TRANSACTION_GetInterfaceList: { java.lang.String[] _arg0; _arg0 = data.createStringArray(); data.enforceNoDataAvail(); java.util.List _result = this.GetInterfaceList(_arg0); reply.writeNoException(); reply.writeInterfaceList(_result); break; } case TRANSACTION_VerifyNamesWithInterfaceList: { java.util.List _arg0; _arg0 = data.createInterfaceArrayList(android.aidl.tests.INamedCallback.Stub::asInterface); java.lang.String[] _arg1; _arg1 = data.createStringArray(); data.enforceNoDataAvail(); boolean _result = this.VerifyNamesWithInterfaceList(_arg0, _arg1); reply.writeNoException(); reply.writeBoolean(_result); break; } case TRANSACTION_ReverseStringList: { java.util.List _arg0; _arg0 = data.createStringArrayList(); java.util.List _arg1; _arg1 = new java.util.ArrayList(); data.enforceNoDataAvail(); java.util.List _result = this.ReverseStringList(_arg0, _arg1); reply.writeNoException(); reply.writeStringList(_result); reply.writeStringList(_arg1); break; } case TRANSACTION_RepeatParcelFileDescriptor: { android.os.ParcelFileDescriptor _arg0; _arg0 = data.readTypedObject(android.os.ParcelFileDescriptor.CREATOR); data.enforceNoDataAvail(); android.os.ParcelFileDescriptor _result = this.RepeatParcelFileDescriptor(_arg0); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_ReverseParcelFileDescriptorArray: { android.os.ParcelFileDescriptor[] _arg0; _arg0 = data.createTypedArray(android.os.ParcelFileDescriptor.CREATOR); android.os.ParcelFileDescriptor[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new android.os.ParcelFileDescriptor[_arg1_length]; } data.enforceNoDataAvail(); android.os.ParcelFileDescriptor[] _result = this.ReverseParcelFileDescriptorArray(_arg0, _arg1); reply.writeNoException(); reply.writeTypedArray(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); reply.writeTypedArray(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_ThrowServiceException: { int _arg0; _arg0 = data.readInt(); data.enforceNoDataAvail(); this.ThrowServiceException(_arg0); reply.writeNoException(); break; } case TRANSACTION_RepeatNullableIntArray: { int[] _arg0; _arg0 = data.createIntArray(); data.enforceNoDataAvail(); int[] _result = this.RepeatNullableIntArray(_arg0); reply.writeNoException(); reply.writeIntArray(_result); break; } case TRANSACTION_RepeatNullableByteEnumArray: { byte[] _arg0; _arg0 = data.createByteArray(); data.enforceNoDataAvail(); byte[] _result = this.RepeatNullableByteEnumArray(_arg0); reply.writeNoException(); reply.writeByteArray(_result); break; } case TRANSACTION_RepeatNullableIntEnumArray: { int[] _arg0; _arg0 = data.createIntArray(); data.enforceNoDataAvail(); int[] _result = this.RepeatNullableIntEnumArray(_arg0); reply.writeNoException(); reply.writeIntArray(_result); break; } case TRANSACTION_RepeatNullableLongEnumArray: { long[] _arg0; _arg0 = data.createLongArray(); data.enforceNoDataAvail(); long[] _result = this.RepeatNullableLongEnumArray(_arg0); reply.writeNoException(); reply.writeLongArray(_result); break; } case TRANSACTION_RepeatNullableString: { java.lang.String _arg0; _arg0 = data.readString(); data.enforceNoDataAvail(); java.lang.String _result = this.RepeatNullableString(_arg0); reply.writeNoException(); reply.writeString(_result); break; } case TRANSACTION_RepeatNullableStringList: { java.util.List _arg0; _arg0 = data.createStringArrayList(); data.enforceNoDataAvail(); java.util.List _result = this.RepeatNullableStringList(_arg0); reply.writeNoException(); reply.writeStringList(_result); break; } case TRANSACTION_RepeatNullableParcelable: { android.aidl.tests.ITestService.Empty _arg0; _arg0 = data.readTypedObject(android.aidl.tests.ITestService.Empty.CREATOR); data.enforceNoDataAvail(); android.aidl.tests.ITestService.Empty _result = this.RepeatNullableParcelable(_arg0); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_RepeatNullableParcelableArray: { android.aidl.tests.ITestService.Empty[] _arg0; _arg0 = data.createTypedArray(android.aidl.tests.ITestService.Empty.CREATOR); data.enforceNoDataAvail(); android.aidl.tests.ITestService.Empty[] _result = this.RepeatNullableParcelableArray(_arg0); reply.writeNoException(); reply.writeTypedArray(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_RepeatNullableParcelableList: { java.util.List _arg0; _arg0 = data.createTypedArrayList(android.aidl.tests.ITestService.Empty.CREATOR); data.enforceNoDataAvail(); java.util.List _result = this.RepeatNullableParcelableList(_arg0); reply.writeNoException(); reply.writeTypedList(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_TakesAnIBinder: { android.os.IBinder _arg0; _arg0 = data.readStrongBinder(); data.enforceNoDataAvail(); this.TakesAnIBinder(_arg0); reply.writeNoException(); break; } case TRANSACTION_TakesANullableIBinder: { android.os.IBinder _arg0; _arg0 = data.readStrongBinder(); data.enforceNoDataAvail(); this.TakesANullableIBinder(_arg0); reply.writeNoException(); break; } case TRANSACTION_TakesAnIBinderList: { java.util.List _arg0; _arg0 = data.createBinderArrayList(); data.enforceNoDataAvail(); this.TakesAnIBinderList(_arg0); reply.writeNoException(); break; } case TRANSACTION_TakesANullableIBinderList: { java.util.List _arg0; _arg0 = data.createBinderArrayList(); data.enforceNoDataAvail(); this.TakesANullableIBinderList(_arg0); reply.writeNoException(); break; } case TRANSACTION_RepeatUtf8CppString: { java.lang.String _arg0; _arg0 = data.readString(); data.enforceNoDataAvail(); java.lang.String _result = this.RepeatUtf8CppString(_arg0); reply.writeNoException(); reply.writeString(_result); break; } case TRANSACTION_RepeatNullableUtf8CppString: { java.lang.String _arg0; _arg0 = data.readString(); data.enforceNoDataAvail(); java.lang.String _result = this.RepeatNullableUtf8CppString(_arg0); reply.writeNoException(); reply.writeString(_result); break; } case TRANSACTION_ReverseUtf8CppString: { java.lang.String[] _arg0; _arg0 = data.createStringArray(); java.lang.String[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new java.lang.String[_arg1_length]; } data.enforceNoDataAvail(); java.lang.String[] _result = this.ReverseUtf8CppString(_arg0, _arg1); reply.writeNoException(); reply.writeStringArray(_result); reply.writeStringArray(_arg1); break; } case TRANSACTION_ReverseNullableUtf8CppString: { java.lang.String[] _arg0; _arg0 = data.createStringArray(); java.lang.String[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new java.lang.String[_arg1_length]; } data.enforceNoDataAvail(); java.lang.String[] _result = this.ReverseNullableUtf8CppString(_arg0, _arg1); reply.writeNoException(); reply.writeStringArray(_result); reply.writeStringArray(_arg1); break; } case TRANSACTION_ReverseUtf8CppStringList: { java.util.List _arg0; _arg0 = data.createStringArrayList(); java.util.List _arg1; _arg1 = new java.util.ArrayList(); data.enforceNoDataAvail(); java.util.List _result = this.ReverseUtf8CppStringList(_arg0, _arg1); reply.writeNoException(); reply.writeStringList(_result); reply.writeStringList(_arg1); break; } case TRANSACTION_GetCallback: { boolean _arg0; _arg0 = data.readBoolean(); data.enforceNoDataAvail(); android.aidl.tests.INamedCallback _result = this.GetCallback(_arg0); reply.writeNoException(); reply.writeStrongInterface(_result); break; } case TRANSACTION_FillOutStructuredParcelable: { android.aidl.tests.StructuredParcelable _arg0; _arg0 = data.readTypedObject(android.aidl.tests.StructuredParcelable.CREATOR); data.enforceNoDataAvail(); this.FillOutStructuredParcelable(_arg0); reply.writeNoException(); reply.writeTypedObject(_arg0, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_RepeatExtendableParcelable: { android.aidl.tests.extension.ExtendableParcelable _arg0; _arg0 = data.readTypedObject(android.aidl.tests.extension.ExtendableParcelable.CREATOR); android.aidl.tests.extension.ExtendableParcelable _arg1; _arg1 = new android.aidl.tests.extension.ExtendableParcelable(); data.enforceNoDataAvail(); this.RepeatExtendableParcelable(_arg0, _arg1); reply.writeNoException(); reply.writeTypedObject(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_ReverseList: { android.aidl.tests.RecursiveList _arg0; _arg0 = data.readTypedObject(android.aidl.tests.RecursiveList.CREATOR); data.enforceNoDataAvail(); android.aidl.tests.RecursiveList _result = this.ReverseList(_arg0); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_ReverseIBinderArray: { android.os.IBinder[] _arg0; _arg0 = data.createBinderArray(); android.os.IBinder[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new android.os.IBinder[_arg1_length]; } data.enforceNoDataAvail(); android.os.IBinder[] _result = this.ReverseIBinderArray(_arg0, _arg1); reply.writeNoException(); reply.writeBinderArray(_result); reply.writeBinderArray(_arg1); break; } case TRANSACTION_ReverseNullableIBinderArray: { android.os.IBinder[] _arg0; _arg0 = data.createBinderArray(); android.os.IBinder[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new android.os.IBinder[_arg1_length]; } data.enforceNoDataAvail(); android.os.IBinder[] _result = this.ReverseNullableIBinderArray(_arg0, _arg1); reply.writeNoException(); reply.writeBinderArray(_result); reply.writeBinderArray(_arg1); break; } case TRANSACTION_RepeatSimpleParcelable: { android.aidl.tests.SimpleParcelable _arg0; _arg0 = data.readTypedObject(android.aidl.tests.SimpleParcelable.CREATOR); android.aidl.tests.SimpleParcelable _arg1; _arg1 = new android.aidl.tests.SimpleParcelable(); data.enforceNoDataAvail(); android.aidl.tests.SimpleParcelable _result = this.RepeatSimpleParcelable(_arg0, _arg1); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); reply.writeTypedObject(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_ReverseSimpleParcelables: { android.aidl.tests.SimpleParcelable[] _arg0; _arg0 = data.createTypedArray(android.aidl.tests.SimpleParcelable.CREATOR); android.aidl.tests.SimpleParcelable[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new android.aidl.tests.SimpleParcelable[_arg1_length]; } data.enforceNoDataAvail(); android.aidl.tests.SimpleParcelable[] _result = this.ReverseSimpleParcelables(_arg0, _arg1); reply.writeNoException(); reply.writeTypedArray(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); reply.writeTypedArray(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_GetOldNameInterface: { android.aidl.tests.IOldName _result = this.GetOldNameInterface(); reply.writeNoException(); reply.writeStrongInterface(_result); break; } case TRANSACTION_GetNewNameInterface: { android.aidl.tests.INewName _result = this.GetNewNameInterface(); reply.writeNoException(); reply.writeStrongInterface(_result); break; } case TRANSACTION_GetUnionTags: { android.aidl.tests.Union[] _arg0; _arg0 = data.createTypedArray(android.aidl.tests.Union.CREATOR); data.enforceNoDataAvail(); int[] _result = this.GetUnionTags(_arg0); reply.writeNoException(); reply.writeIntArray(_result); break; } case TRANSACTION_GetCppJavaTests: { android.os.IBinder _result = this.GetCppJavaTests(); reply.writeNoException(); reply.writeStrongBinder(_result); break; } case TRANSACTION_getBackendType: { byte _result = this.getBackendType(); reply.writeNoException(); reply.writeByte(_result); break; } case TRANSACTION_GetCircular: { android.aidl.tests.CircularParcelable _arg0; _arg0 = new android.aidl.tests.CircularParcelable(); data.enforceNoDataAvail(); android.aidl.tests.ICircular _result = this.GetCircular(_arg0); reply.writeNoException(); reply.writeStrongInterface(_result); reply.writeTypedObject(_arg0, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.ITestService { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } // This is to emulate a method that is added after the service is implemented. // So the client cannot assume that a call to this method will be successful // or not. However, inside the test environment, we can't build client and // the server with different version of this AIDL file. So, we let the server // actually implement this and intercept the dispatch to the method // inside onTransact(). // WARNING: Must be first method. // This requires hard coding the transaction number. As long as this method is // the first in this interface, it can keep the // "::android::IBinder::FIRST_CALL_TRANSACTION + 0" value and allow // methods to be added and removed. @Override public int UnimplementedMethod(int arg) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); int _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeInt(arg); boolean _status = mRemote.transact(Stub.TRANSACTION_UnimplementedMethod, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().UnimplementedMethod(arg); } } _reply.readException(); _result = _reply.readInt(); } finally { _reply.recycle(); _data.recycle(); } return _result; } /** * @deprecated to make sure we have something in system/tools/aidl which does a compile check * of deprecated and make sure this is reflected in goldens */ @Override public void Deprecated() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_Deprecated, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { getDefaultImpl().Deprecated(); return; } } _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } @Override public void TestOneway() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_TestOneway, _data, null, android.os.IBinder.FLAG_ONEWAY | android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { getDefaultImpl().TestOneway(); return; } } } finally { _data.recycle(); } } // Test that primitives work as parameters and return types. @Override public boolean RepeatBoolean(boolean token) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); boolean _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeBoolean(token); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatBoolean, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatBoolean(token); } } _reply.readException(); _result = _reply.readBoolean(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public byte RepeatByte(byte token) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); byte _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeByte(token); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatByte, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatByte(token); } } _reply.readException(); _result = _reply.readByte(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public char RepeatChar(char token) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); char _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeInt(((int)token)); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatChar, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatChar(token); } } _reply.readException(); _result = (char)_reply.readInt(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int RepeatInt(int token) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); int _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeInt(token); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatInt, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatInt(token); } } _reply.readException(); _result = _reply.readInt(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public long RepeatLong(long token) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); long _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeLong(token); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatLong, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatLong(token); } } _reply.readException(); _result = _reply.readLong(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public float RepeatFloat(float token) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); float _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeFloat(token); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatFloat, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatFloat(token); } } _reply.readException(); _result = _reply.readFloat(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public double RepeatDouble(double token) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); double _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeDouble(token); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatDouble, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatDouble(token); } } _reply.readException(); _result = _reply.readDouble(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.lang.String RepeatString(java.lang.String token) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); java.lang.String _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeString(token); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatString, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatString(token); } } _reply.readException(); _result = _reply.readString(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public byte RepeatByteEnum(byte token) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); byte _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeByte(token); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatByteEnum, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatByteEnum(token); } } _reply.readException(); _result = _reply.readByte(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int RepeatIntEnum(int token) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); int _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeInt(token); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatIntEnum, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatIntEnum(token); } } _reply.readException(); _result = _reply.readInt(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public long RepeatLongEnum(long token) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); long _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeLong(token); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatLongEnum, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatLongEnum(token); } } _reply.readException(); _result = _reply.readLong(); } finally { _reply.recycle(); _data.recycle(); } return _result; } // Test that arrays work as parameters and return types. @Override public boolean[] ReverseBoolean(boolean[] input, boolean[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); boolean[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeBooleanArray(input); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseBoolean, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseBoolean(input, repeated); } } _reply.readException(); _result = _reply.createBooleanArray(); _reply.readBooleanArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public byte[] ReverseByte(byte[] input, byte[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); byte[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeByteArray(input); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseByte, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseByte(input, repeated); } } _reply.readException(); _result = _reply.createByteArray(); _reply.readByteArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public char[] ReverseChar(char[] input, char[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); char[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeCharArray(input); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseChar, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseChar(input, repeated); } } _reply.readException(); _result = _reply.createCharArray(); _reply.readCharArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int[] ReverseInt(int[] input, int[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); int[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeIntArray(input); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseInt, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseInt(input, repeated); } } _reply.readException(); _result = _reply.createIntArray(); _reply.readIntArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public long[] ReverseLong(long[] input, long[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); long[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeLongArray(input); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseLong, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseLong(input, repeated); } } _reply.readException(); _result = _reply.createLongArray(); _reply.readLongArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public float[] ReverseFloat(float[] input, float[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); float[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeFloatArray(input); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseFloat, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseFloat(input, repeated); } } _reply.readException(); _result = _reply.createFloatArray(); _reply.readFloatArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public double[] ReverseDouble(double[] input, double[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); double[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeDoubleArray(input); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseDouble, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseDouble(input, repeated); } } _reply.readException(); _result = _reply.createDoubleArray(); _reply.readDoubleArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.lang.String[] ReverseString(java.lang.String[] input, java.lang.String[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); java.lang.String[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeStringArray(input); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseString, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseString(input, repeated); } } _reply.readException(); _result = _reply.createStringArray(); _reply.readStringArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public byte[] ReverseByteEnum(byte[] input, byte[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); byte[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeByteArray(input); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseByteEnum, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseByteEnum(input, repeated); } } _reply.readException(); _result = _reply.createByteArray(); _reply.readByteArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int[] ReverseIntEnum(int[] input, int[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); int[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeIntArray(input); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseIntEnum, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseIntEnum(input, repeated); } } _reply.readException(); _result = _reply.createIntArray(); _reply.readIntArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public long[] ReverseLongEnum(long[] input, long[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); long[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeLongArray(input); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseLongEnum, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseLongEnum(input, repeated); } } _reply.readException(); _result = _reply.createLongArray(); _reply.readLongArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } // Test that clients can send and receive Binders. @Override public android.aidl.tests.INamedCallback GetOtherTestService(java.lang.String name) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.INamedCallback _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeString(name); boolean _status = mRemote.transact(Stub.TRANSACTION_GetOtherTestService, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); _reply.setPropagateAllowBlocking(); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().GetOtherTestService(name); } } _reply.readException(); _result = android.aidl.tests.INamedCallback.Stub.asInterface(_reply.readStrongBinder()); } finally { _reply.recycle(); _data.recycle(); } return _result; } // returns true if the same service is already registered with the same name @Override public boolean SetOtherTestService(java.lang.String name, android.aidl.tests.INamedCallback service) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); boolean _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeString(name); _data.writeStrongInterface(service); boolean _status = mRemote.transact(Stub.TRANSACTION_SetOtherTestService, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().SetOtherTestService(name, service); } } _reply.readException(); _result = _reply.readBoolean(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public boolean VerifyName(android.aidl.tests.INamedCallback service, java.lang.String name) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); boolean _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeStrongInterface(service); _data.writeString(name); boolean _status = mRemote.transact(Stub.TRANSACTION_VerifyName, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().VerifyName(service, name); } } _reply.readException(); _result = _reply.readBoolean(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.tests.INamedCallback[] GetInterfaceArray(java.lang.String[] names) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.INamedCallback[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeStringArray(names); boolean _status = mRemote.transact(Stub.TRANSACTION_GetInterfaceArray, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().GetInterfaceArray(names); } } _reply.readException(); _result = _reply.createInterfaceArray(android.aidl.tests.INamedCallback[]::new, android.aidl.tests.INamedCallback.Stub::asInterface); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public boolean VerifyNamesWithInterfaceArray(android.aidl.tests.INamedCallback[] services, java.lang.String[] names) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); boolean _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeInterfaceArray(services); _data.writeStringArray(names); boolean _status = mRemote.transact(Stub.TRANSACTION_VerifyNamesWithInterfaceArray, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().VerifyNamesWithInterfaceArray(services, names); } } _reply.readException(); _result = _reply.readBoolean(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.tests.INamedCallback[] GetNullableInterfaceArray(java.lang.String[] names) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.INamedCallback[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeStringArray(names); boolean _status = mRemote.transact(Stub.TRANSACTION_GetNullableInterfaceArray, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().GetNullableInterfaceArray(names); } } _reply.readException(); _result = _reply.createInterfaceArray(android.aidl.tests.INamedCallback[]::new, android.aidl.tests.INamedCallback.Stub::asInterface); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public boolean VerifyNamesWithNullableInterfaceArray(android.aidl.tests.INamedCallback[] services, java.lang.String[] names) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); boolean _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeInterfaceArray(services); _data.writeStringArray(names); boolean _status = mRemote.transact(Stub.TRANSACTION_VerifyNamesWithNullableInterfaceArray, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().VerifyNamesWithNullableInterfaceArray(services, names); } } _reply.readException(); _result = _reply.readBoolean(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.util.List GetInterfaceList(java.lang.String[] names) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); java.util.List _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeStringArray(names); boolean _status = mRemote.transact(Stub.TRANSACTION_GetInterfaceList, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().GetInterfaceList(names); } } _reply.readException(); _result = _reply.createInterfaceArrayList(android.aidl.tests.INamedCallback.Stub::asInterface); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public boolean VerifyNamesWithInterfaceList(java.util.List services, java.lang.String[] names) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); boolean _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeInterfaceList(services); _data.writeStringArray(names); boolean _status = mRemote.transact(Stub.TRANSACTION_VerifyNamesWithInterfaceList, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().VerifyNamesWithInterfaceList(services, names); } } _reply.readException(); _result = _reply.readBoolean(); } finally { _reply.recycle(); _data.recycle(); } return _result; } // Test that List types work correctly. @Override public java.util.List ReverseStringList(java.util.List input, java.util.List repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); java.util.List _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeStringList(input); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseStringList, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseStringList(input, repeated); } } _reply.readException(); _result = _reply.createStringArrayList(); _reply.readStringList(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.os.ParcelFileDescriptor RepeatParcelFileDescriptor(android.os.ParcelFileDescriptor read) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); android.os.ParcelFileDescriptor _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(read, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatParcelFileDescriptor, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatParcelFileDescriptor(read); } } _reply.readException(); _result = _reply.readTypedObject(android.os.ParcelFileDescriptor.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.os.ParcelFileDescriptor[] ReverseParcelFileDescriptorArray(android.os.ParcelFileDescriptor[] input, android.os.ParcelFileDescriptor[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); android.os.ParcelFileDescriptor[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedArray(input, 0); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseParcelFileDescriptorArray, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseParcelFileDescriptorArray(input, repeated); } } _reply.readException(); _result = _reply.createTypedArray(android.os.ParcelFileDescriptor.CREATOR); _reply.readTypedArray(repeated, android.os.ParcelFileDescriptor.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } // Test that service specific exceptions work correctly. @Override public void ThrowServiceException(int code) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeInt(code); boolean _status = mRemote.transact(Stub.TRANSACTION_ThrowServiceException, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { getDefaultImpl().ThrowServiceException(code); return; } } _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } // Test nullability @Override public int[] RepeatNullableIntArray(int[] input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); int[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeIntArray(input); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatNullableIntArray, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatNullableIntArray(input); } } _reply.readException(); _result = _reply.createIntArray(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public byte[] RepeatNullableByteEnumArray(byte[] input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); byte[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeByteArray(input); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatNullableByteEnumArray, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatNullableByteEnumArray(input); } } _reply.readException(); _result = _reply.createByteArray(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int[] RepeatNullableIntEnumArray(int[] input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); int[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeIntArray(input); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatNullableIntEnumArray, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatNullableIntEnumArray(input); } } _reply.readException(); _result = _reply.createIntArray(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public long[] RepeatNullableLongEnumArray(long[] input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); long[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeLongArray(input); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatNullableLongEnumArray, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatNullableLongEnumArray(input); } } _reply.readException(); _result = _reply.createLongArray(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.lang.String RepeatNullableString(java.lang.String input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); java.lang.String _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeString(input); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatNullableString, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatNullableString(input); } } _reply.readException(); _result = _reply.readString(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.util.List RepeatNullableStringList(java.util.List input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); java.util.List _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeStringList(input); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatNullableStringList, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatNullableStringList(input); } } _reply.readException(); _result = _reply.createStringArrayList(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.tests.ITestService.Empty RepeatNullableParcelable(android.aidl.tests.ITestService.Empty input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.ITestService.Empty _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatNullableParcelable, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatNullableParcelable(input); } } _reply.readException(); _result = _reply.readTypedObject(android.aidl.tests.ITestService.Empty.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.tests.ITestService.Empty[] RepeatNullableParcelableArray(android.aidl.tests.ITestService.Empty[] input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.ITestService.Empty[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedArray(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatNullableParcelableArray, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatNullableParcelableArray(input); } } _reply.readException(); _result = _reply.createTypedArray(android.aidl.tests.ITestService.Empty.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.util.List RepeatNullableParcelableList(java.util.List input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); java.util.List _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedList(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatNullableParcelableList, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatNullableParcelableList(input); } } _reply.readException(); _result = _reply.createTypedArrayList(android.aidl.tests.ITestService.Empty.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public void TakesAnIBinder(android.os.IBinder input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeStrongBinder(input); boolean _status = mRemote.transact(Stub.TRANSACTION_TakesAnIBinder, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { getDefaultImpl().TakesAnIBinder(input); return; } } _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } @Override public void TakesANullableIBinder(android.os.IBinder input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeStrongBinder(input); boolean _status = mRemote.transact(Stub.TRANSACTION_TakesANullableIBinder, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { getDefaultImpl().TakesANullableIBinder(input); return; } } _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } @Override public void TakesAnIBinderList(java.util.List input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeBinderList(input); boolean _status = mRemote.transact(Stub.TRANSACTION_TakesAnIBinderList, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { getDefaultImpl().TakesAnIBinderList(input); return; } } _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } @Override public void TakesANullableIBinderList(java.util.List input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeBinderList(input); boolean _status = mRemote.transact(Stub.TRANSACTION_TakesANullableIBinderList, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { getDefaultImpl().TakesANullableIBinderList(input); return; } } _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } // Test utf8 decoding from utf16 wire format @Override public java.lang.String RepeatUtf8CppString(java.lang.String token) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); java.lang.String _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeString(token); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatUtf8CppString, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatUtf8CppString(token); } } _reply.readException(); _result = _reply.readString(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.lang.String RepeatNullableUtf8CppString(java.lang.String token) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); java.lang.String _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeString(token); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatNullableUtf8CppString, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatNullableUtf8CppString(token); } } _reply.readException(); _result = _reply.readString(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.lang.String[] ReverseUtf8CppString(java.lang.String[] input, java.lang.String[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); java.lang.String[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeStringArray(input); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseUtf8CppString, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseUtf8CppString(input, repeated); } } _reply.readException(); _result = _reply.createStringArray(); _reply.readStringArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.lang.String[] ReverseNullableUtf8CppString(java.lang.String[] input, java.lang.String[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); java.lang.String[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeStringArray(input); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseNullableUtf8CppString, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseNullableUtf8CppString(input, repeated); } } _reply.readException(); _result = _reply.createStringArray(); _reply.readStringArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.util.List ReverseUtf8CppStringList(java.util.List input, java.util.List repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); java.util.List _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeStringList(input); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseUtf8CppStringList, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseUtf8CppStringList(input, repeated); } } _reply.readException(); _result = _reply.createStringArrayList(); _reply.readStringList(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } /** comment before annotation */ @Override public android.aidl.tests.INamedCallback GetCallback(boolean return_null) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.INamedCallback _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeBoolean(return_null); boolean _status = mRemote.transact(Stub.TRANSACTION_GetCallback, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().GetCallback(return_null); } } _reply.readException(); _result = android.aidl.tests.INamedCallback.Stub.asInterface(_reply.readStrongBinder()); } finally { _reply.recycle(); _data.recycle(); } return _result; } // Since this paracelable has clearly defined default values, it would be // inefficient to use an IPC to fill it out in practice. @Override public void FillOutStructuredParcelable(android.aidl.tests.StructuredParcelable parcel) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(parcel, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_FillOutStructuredParcelable, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { getDefaultImpl().FillOutStructuredParcelable(parcel); return; } } _reply.readException(); if ((0!=_reply.readInt())) { parcel.readFromParcel(_reply); } } finally { _reply.recycle(); _data.recycle(); } } @Override public void RepeatExtendableParcelable(android.aidl.tests.extension.ExtendableParcelable ep, android.aidl.tests.extension.ExtendableParcelable ep2) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(ep, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatExtendableParcelable, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { getDefaultImpl().RepeatExtendableParcelable(ep, ep2); return; } } _reply.readException(); if ((0!=_reply.readInt())) { ep2.readFromParcel(_reply); } } finally { _reply.recycle(); _data.recycle(); } } @Override public android.aidl.tests.RecursiveList ReverseList(android.aidl.tests.RecursiveList list) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.RecursiveList _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(list, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseList, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseList(list); } } _reply.readException(); _result = _reply.readTypedObject(android.aidl.tests.RecursiveList.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.os.IBinder[] ReverseIBinderArray(android.os.IBinder[] input, android.os.IBinder[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); android.os.IBinder[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeBinderArray(input); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseIBinderArray, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseIBinderArray(input, repeated); } } _reply.readException(); _result = _reply.createBinderArray(); _reply.readBinderArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.os.IBinder[] ReverseNullableIBinderArray(android.os.IBinder[] input, android.os.IBinder[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); android.os.IBinder[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeBinderArray(input); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseNullableIBinderArray, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseNullableIBinderArray(input, repeated); } } _reply.readException(); _result = _reply.createBinderArray(); _reply.readBinderArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.tests.SimpleParcelable RepeatSimpleParcelable(android.aidl.tests.SimpleParcelable input, android.aidl.tests.SimpleParcelable repeat) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.SimpleParcelable _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatSimpleParcelable, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatSimpleParcelable(input, repeat); } } _reply.readException(); _result = _reply.readTypedObject(android.aidl.tests.SimpleParcelable.CREATOR); if ((0!=_reply.readInt())) { repeat.readFromParcel(_reply); } } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.tests.SimpleParcelable[] ReverseSimpleParcelables(android.aidl.tests.SimpleParcelable[] input, android.aidl.tests.SimpleParcelable[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.SimpleParcelable[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedArray(input, 0); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseSimpleParcelables, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseSimpleParcelables(input, repeated); } } _reply.readException(); _result = _reply.createTypedArray(android.aidl.tests.SimpleParcelable.CREATOR); _reply.readTypedArray(repeated, android.aidl.tests.SimpleParcelable.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.tests.IOldName GetOldNameInterface() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.IOldName _result; try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_GetOldNameInterface, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().GetOldNameInterface(); } } _reply.readException(); _result = android.aidl.tests.IOldName.Stub.asInterface(_reply.readStrongBinder()); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.tests.INewName GetNewNameInterface() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.INewName _result; try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_GetNewNameInterface, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().GetNewNameInterface(); } } _reply.readException(); _result = android.aidl.tests.INewName.Stub.asInterface(_reply.readStrongBinder()); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int[] GetUnionTags(android.aidl.tests.Union[] input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); int[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedArray(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_GetUnionTags, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().GetUnionTags(input); } } _reply.readException(); _result = _reply.createIntArray(); } finally { _reply.recycle(); _data.recycle(); } return _result; } // Retrieve the ICppJavaTests if the server supports it @Override public android.os.IBinder GetCppJavaTests() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); android.os.IBinder _result; try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_GetCppJavaTests, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().GetCppJavaTests(); } } _reply.readException(); _result = _reply.readStrongBinder(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public byte getBackendType() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); byte _result; try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getBackendType, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().getBackendType(); } } _reply.readException(); _result = _reply.readByte(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.tests.ICircular GetCircular(android.aidl.tests.CircularParcelable cp) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.ICircular _result; try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_GetCircular, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().GetCircular(cp); } } _reply.readException(); _result = android.aidl.tests.ICircular.Stub.asInterface(_reply.readStrongBinder()); if ((0!=_reply.readInt())) { cp.readFromParcel(_reply); } } finally { _reply.recycle(); _data.recycle(); } return _result; } public static android.aidl.tests.ITestService sDefaultImpl; } static final int TRANSACTION_UnimplementedMethod = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); static final int TRANSACTION_Deprecated = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1); static final int TRANSACTION_TestOneway = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2); static final int TRANSACTION_RepeatBoolean = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3); static final int TRANSACTION_RepeatByte = (android.os.IBinder.FIRST_CALL_TRANSACTION + 4); static final int TRANSACTION_RepeatChar = (android.os.IBinder.FIRST_CALL_TRANSACTION + 5); static final int TRANSACTION_RepeatInt = (android.os.IBinder.FIRST_CALL_TRANSACTION + 6); static final int TRANSACTION_RepeatLong = (android.os.IBinder.FIRST_CALL_TRANSACTION + 7); static final int TRANSACTION_RepeatFloat = (android.os.IBinder.FIRST_CALL_TRANSACTION + 8); static final int TRANSACTION_RepeatDouble = (android.os.IBinder.FIRST_CALL_TRANSACTION + 9); static final int TRANSACTION_RepeatString = (android.os.IBinder.FIRST_CALL_TRANSACTION + 10); static final int TRANSACTION_RepeatByteEnum = (android.os.IBinder.FIRST_CALL_TRANSACTION + 11); static final int TRANSACTION_RepeatIntEnum = (android.os.IBinder.FIRST_CALL_TRANSACTION + 12); static final int TRANSACTION_RepeatLongEnum = (android.os.IBinder.FIRST_CALL_TRANSACTION + 13); static final int TRANSACTION_ReverseBoolean = (android.os.IBinder.FIRST_CALL_TRANSACTION + 14); static final int TRANSACTION_ReverseByte = (android.os.IBinder.FIRST_CALL_TRANSACTION + 15); static final int TRANSACTION_ReverseChar = (android.os.IBinder.FIRST_CALL_TRANSACTION + 16); static final int TRANSACTION_ReverseInt = (android.os.IBinder.FIRST_CALL_TRANSACTION + 17); static final int TRANSACTION_ReverseLong = (android.os.IBinder.FIRST_CALL_TRANSACTION + 18); static final int TRANSACTION_ReverseFloat = (android.os.IBinder.FIRST_CALL_TRANSACTION + 19); static final int TRANSACTION_ReverseDouble = (android.os.IBinder.FIRST_CALL_TRANSACTION + 20); static final int TRANSACTION_ReverseString = (android.os.IBinder.FIRST_CALL_TRANSACTION + 21); static final int TRANSACTION_ReverseByteEnum = (android.os.IBinder.FIRST_CALL_TRANSACTION + 22); static final int TRANSACTION_ReverseIntEnum = (android.os.IBinder.FIRST_CALL_TRANSACTION + 23); static final int TRANSACTION_ReverseLongEnum = (android.os.IBinder.FIRST_CALL_TRANSACTION + 24); static final int TRANSACTION_GetOtherTestService = (android.os.IBinder.FIRST_CALL_TRANSACTION + 25); static final int TRANSACTION_SetOtherTestService = (android.os.IBinder.FIRST_CALL_TRANSACTION + 26); static final int TRANSACTION_VerifyName = (android.os.IBinder.FIRST_CALL_TRANSACTION + 27); static final int TRANSACTION_GetInterfaceArray = (android.os.IBinder.FIRST_CALL_TRANSACTION + 28); static final int TRANSACTION_VerifyNamesWithInterfaceArray = (android.os.IBinder.FIRST_CALL_TRANSACTION + 29); static final int TRANSACTION_GetNullableInterfaceArray = (android.os.IBinder.FIRST_CALL_TRANSACTION + 30); static final int TRANSACTION_VerifyNamesWithNullableInterfaceArray = (android.os.IBinder.FIRST_CALL_TRANSACTION + 31); static final int TRANSACTION_GetInterfaceList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 32); static final int TRANSACTION_VerifyNamesWithInterfaceList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 33); static final int TRANSACTION_ReverseStringList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 34); static final int TRANSACTION_RepeatParcelFileDescriptor = (android.os.IBinder.FIRST_CALL_TRANSACTION + 35); static final int TRANSACTION_ReverseParcelFileDescriptorArray = (android.os.IBinder.FIRST_CALL_TRANSACTION + 36); static final int TRANSACTION_ThrowServiceException = (android.os.IBinder.FIRST_CALL_TRANSACTION + 37); static final int TRANSACTION_RepeatNullableIntArray = (android.os.IBinder.FIRST_CALL_TRANSACTION + 38); static final int TRANSACTION_RepeatNullableByteEnumArray = (android.os.IBinder.FIRST_CALL_TRANSACTION + 39); static final int TRANSACTION_RepeatNullableIntEnumArray = (android.os.IBinder.FIRST_CALL_TRANSACTION + 40); static final int TRANSACTION_RepeatNullableLongEnumArray = (android.os.IBinder.FIRST_CALL_TRANSACTION + 41); static final int TRANSACTION_RepeatNullableString = (android.os.IBinder.FIRST_CALL_TRANSACTION + 42); static final int TRANSACTION_RepeatNullableStringList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 43); static final int TRANSACTION_RepeatNullableParcelable = (android.os.IBinder.FIRST_CALL_TRANSACTION + 44); static final int TRANSACTION_RepeatNullableParcelableArray = (android.os.IBinder.FIRST_CALL_TRANSACTION + 45); static final int TRANSACTION_RepeatNullableParcelableList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 46); static final int TRANSACTION_TakesAnIBinder = (android.os.IBinder.FIRST_CALL_TRANSACTION + 47); static final int TRANSACTION_TakesANullableIBinder = (android.os.IBinder.FIRST_CALL_TRANSACTION + 48); static final int TRANSACTION_TakesAnIBinderList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 49); static final int TRANSACTION_TakesANullableIBinderList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 50); static final int TRANSACTION_RepeatUtf8CppString = (android.os.IBinder.FIRST_CALL_TRANSACTION + 51); static final int TRANSACTION_RepeatNullableUtf8CppString = (android.os.IBinder.FIRST_CALL_TRANSACTION + 52); static final int TRANSACTION_ReverseUtf8CppString = (android.os.IBinder.FIRST_CALL_TRANSACTION + 53); static final int TRANSACTION_ReverseNullableUtf8CppString = (android.os.IBinder.FIRST_CALL_TRANSACTION + 54); static final int TRANSACTION_ReverseUtf8CppStringList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 55); static final int TRANSACTION_GetCallback = (android.os.IBinder.FIRST_CALL_TRANSACTION + 56); static final int TRANSACTION_FillOutStructuredParcelable = (android.os.IBinder.FIRST_CALL_TRANSACTION + 57); static final int TRANSACTION_RepeatExtendableParcelable = (android.os.IBinder.FIRST_CALL_TRANSACTION + 58); static final int TRANSACTION_ReverseList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 59); static final int TRANSACTION_ReverseIBinderArray = (android.os.IBinder.FIRST_CALL_TRANSACTION + 60); static final int TRANSACTION_ReverseNullableIBinderArray = (android.os.IBinder.FIRST_CALL_TRANSACTION + 61); static final int TRANSACTION_RepeatSimpleParcelable = (android.os.IBinder.FIRST_CALL_TRANSACTION + 62); static final int TRANSACTION_ReverseSimpleParcelables = (android.os.IBinder.FIRST_CALL_TRANSACTION + 63); static final int TRANSACTION_GetOldNameInterface = (android.os.IBinder.FIRST_CALL_TRANSACTION + 64); static final int TRANSACTION_GetNewNameInterface = (android.os.IBinder.FIRST_CALL_TRANSACTION + 65); static final int TRANSACTION_GetUnionTags = (android.os.IBinder.FIRST_CALL_TRANSACTION + 66); static final int TRANSACTION_GetCppJavaTests = (android.os.IBinder.FIRST_CALL_TRANSACTION + 67); static final int TRANSACTION_getBackendType = (android.os.IBinder.FIRST_CALL_TRANSACTION + 68); static final int TRANSACTION_GetCircular = (android.os.IBinder.FIRST_CALL_TRANSACTION + 69); /** @hide */ public int getMaxTransactionId() { return 69; } public static boolean setDefaultImpl(android.aidl.tests.ITestService impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. if (Stub.Proxy.sDefaultImpl != null) { throw new IllegalStateException("setDefaultImpl() called twice"); } if (impl != null) { Stub.Proxy.sDefaultImpl = impl; return true; } return false; } public static android.aidl.tests.ITestService getDefaultImpl() { return Stub.Proxy.sDefaultImpl; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.ITestService"; // Test that constants are accessible /** extra doc comment */ // extra line comment /* extra regular comment */ /** const comment */ public static final int CONSTANT = 42; public static final int CONSTANT2 = -42; public static final int CONSTANT3 = 42; public static final int CONSTANT4 = 4; public static final int CONSTANT5 = -4; public static final int CONSTANT6 = 0; public static final int CONSTANT7 = 0; public static final int CONSTANT8 = 0; public static final int CONSTANT9 = 86; public static final int CONSTANT10 = 165; public static final int CONSTANT11 = 250; public static final int CONSTANT12 = -1; public static final byte BYTE_CONSTANT = 17; public static final long LONG_CONSTANT = 1099511627776L; public static final String STRING_CONSTANT = "foo"; public static final String STRING_CONSTANT2 = "bar"; public static final float FLOAT_CONSTANT = 1.000000f; public static final float FLOAT_CONSTANT2 = -1.000000f; public static final float FLOAT_CONSTANT3 = 1.000000f; public static final float FLOAT_CONSTANT4 = 2.200000f; public static final float FLOAT_CONSTANT5 = -2.200000f; public static final float FLOAT_CONSTANT6 = -0.000000f; public static final float FLOAT_CONSTANT7 = 0.000000f; public static final double DOUBLE_CONSTANT = 1.000000; public static final double DOUBLE_CONSTANT2 = -1.000000; public static final double DOUBLE_CONSTANT3 = 1.000000; public static final double DOUBLE_CONSTANT4 = 2.200000; public static final double DOUBLE_CONSTANT5 = -2.200000; public static final double DOUBLE_CONSTANT6 = -0.000000; public static final double DOUBLE_CONSTANT7 = 0.000000; public static final double DOUBLE_CONSTANT8 = 1.100000; public static final double DOUBLE_CONSTANT9 = -1.100000; public static final String STRING_CONSTANT_UTF8 = "baz"; // All these constant expressions should be equal to 1 public static final int A1 = 1; public static final int A2 = 1; public static final int A3 = 1; public static final int A4 = 1; public static final int A5 = 1; public static final int A6 = 1; public static final int A7 = 1; public static final int A8 = 1; public static final int A9 = 1; public static final int A10 = 1; public static final int A11 = 1; public static final int A12 = 1; public static final int A13 = 1; public static final int A14 = 1; public static final int A15 = 1; public static final int A16 = 1; public static final int A17 = 1; public static final int A18 = 1; public static final int A19 = 1; public static final int A20 = 1; public static final int A21 = 1; public static final int A22 = 1; public static final int A23 = 1; public static final int A24 = 1; public static final int A25 = 1; public static final int A26 = 1; public static final int A27 = 1; public static final int A28 = 1; public static final int A29 = 1; public static final int A30 = 1; public static final int A31 = 1; public static final int A32 = 1; public static final int A33 = 1; public static final int A34 = 1; public static final int A35 = 1; public static final int A36 = 1; public static final int A37 = 1; public static final int A38 = 1; public static final int A39 = 1; public static final int A40 = 1; public static final int A41 = 1; public static final int A42 = 1; public static final int A43 = 1; public static final int A44 = 1; // && higher than || public static final int A45 = 1; public static final int A46 = 1; public static final int A47 = 1; public static final int A48 = 1; public static final int A49 = 1; public static final int A50 = 1; public static final int A51 = 1; public static final int A52 = 1; public static final int A53 = 1; // & higher than ^ public static final int A54 = 1; public static final int A55 = 1; public static final int A56 = 1; public static final int A57 = 1; // This is to emulate a method that is added after the service is implemented. // So the client cannot assume that a call to this method will be successful // or not. However, inside the test environment, we can't build client and // the server with different version of this AIDL file. So, we let the server // actually implement this and intercept the dispatch to the method // inside onTransact(). // WARNING: Must be first method. // This requires hard coding the transaction number. As long as this method is // the first in this interface, it can keep the // "::android::IBinder::FIRST_CALL_TRANSACTION + 0" value and allow // methods to be added and removed. public int UnimplementedMethod(int arg) throws android.os.RemoteException; /** * @deprecated to make sure we have something in system/tools/aidl which does a compile check * of deprecated and make sure this is reflected in goldens */ @Deprecated public void Deprecated() throws android.os.RemoteException; public void TestOneway() throws android.os.RemoteException; // Test that primitives work as parameters and return types. public boolean RepeatBoolean(boolean token) throws android.os.RemoteException; public byte RepeatByte(byte token) throws android.os.RemoteException; public char RepeatChar(char token) throws android.os.RemoteException; public int RepeatInt(int token) throws android.os.RemoteException; public long RepeatLong(long token) throws android.os.RemoteException; public float RepeatFloat(float token) throws android.os.RemoteException; public double RepeatDouble(double token) throws android.os.RemoteException; public java.lang.String RepeatString(java.lang.String token) throws android.os.RemoteException; public byte RepeatByteEnum(byte token) throws android.os.RemoteException; public int RepeatIntEnum(int token) throws android.os.RemoteException; public long RepeatLongEnum(long token) throws android.os.RemoteException; // Test that arrays work as parameters and return types. public boolean[] ReverseBoolean(boolean[] input, boolean[] repeated) throws android.os.RemoteException; public byte[] ReverseByte(byte[] input, byte[] repeated) throws android.os.RemoteException; public char[] ReverseChar(char[] input, char[] repeated) throws android.os.RemoteException; public int[] ReverseInt(int[] input, int[] repeated) throws android.os.RemoteException; public long[] ReverseLong(long[] input, long[] repeated) throws android.os.RemoteException; public float[] ReverseFloat(float[] input, float[] repeated) throws android.os.RemoteException; public double[] ReverseDouble(double[] input, double[] repeated) throws android.os.RemoteException; public java.lang.String[] ReverseString(java.lang.String[] input, java.lang.String[] repeated) throws android.os.RemoteException; public byte[] ReverseByteEnum(byte[] input, byte[] repeated) throws android.os.RemoteException; public int[] ReverseIntEnum(int[] input, int[] repeated) throws android.os.RemoteException; public long[] ReverseLongEnum(long[] input, long[] repeated) throws android.os.RemoteException; // Test that clients can send and receive Binders. public android.aidl.tests.INamedCallback GetOtherTestService(java.lang.String name) throws android.os.RemoteException; // returns true if the same service is already registered with the same name public boolean SetOtherTestService(java.lang.String name, android.aidl.tests.INamedCallback service) throws android.os.RemoteException; public boolean VerifyName(android.aidl.tests.INamedCallback service, java.lang.String name) throws android.os.RemoteException; public android.aidl.tests.INamedCallback[] GetInterfaceArray(java.lang.String[] names) throws android.os.RemoteException; public boolean VerifyNamesWithInterfaceArray(android.aidl.tests.INamedCallback[] services, java.lang.String[] names) throws android.os.RemoteException; public android.aidl.tests.INamedCallback[] GetNullableInterfaceArray(java.lang.String[] names) throws android.os.RemoteException; public boolean VerifyNamesWithNullableInterfaceArray(android.aidl.tests.INamedCallback[] services, java.lang.String[] names) throws android.os.RemoteException; public java.util.List GetInterfaceList(java.lang.String[] names) throws android.os.RemoteException; public boolean VerifyNamesWithInterfaceList(java.util.List services, java.lang.String[] names) throws android.os.RemoteException; // Test that List types work correctly. public java.util.List ReverseStringList(java.util.List input, java.util.List repeated) throws android.os.RemoteException; public android.os.ParcelFileDescriptor RepeatParcelFileDescriptor(android.os.ParcelFileDescriptor read) throws android.os.RemoteException; public android.os.ParcelFileDescriptor[] ReverseParcelFileDescriptorArray(android.os.ParcelFileDescriptor[] input, android.os.ParcelFileDescriptor[] repeated) throws android.os.RemoteException; // Test that service specific exceptions work correctly. public void ThrowServiceException(int code) throws android.os.RemoteException; // Test nullability public int[] RepeatNullableIntArray(int[] input) throws android.os.RemoteException; public byte[] RepeatNullableByteEnumArray(byte[] input) throws android.os.RemoteException; public int[] RepeatNullableIntEnumArray(int[] input) throws android.os.RemoteException; public long[] RepeatNullableLongEnumArray(long[] input) throws android.os.RemoteException; public java.lang.String RepeatNullableString(java.lang.String input) throws android.os.RemoteException; public java.util.List RepeatNullableStringList(java.util.List input) throws android.os.RemoteException; public android.aidl.tests.ITestService.Empty RepeatNullableParcelable(android.aidl.tests.ITestService.Empty input) throws android.os.RemoteException; public android.aidl.tests.ITestService.Empty[] RepeatNullableParcelableArray(android.aidl.tests.ITestService.Empty[] input) throws android.os.RemoteException; public java.util.List RepeatNullableParcelableList(java.util.List input) throws android.os.RemoteException; public void TakesAnIBinder(android.os.IBinder input) throws android.os.RemoteException; public void TakesANullableIBinder(android.os.IBinder input) throws android.os.RemoteException; public void TakesAnIBinderList(java.util.List input) throws android.os.RemoteException; public void TakesANullableIBinderList(java.util.List input) throws android.os.RemoteException; // Test utf8 decoding from utf16 wire format public java.lang.String RepeatUtf8CppString(java.lang.String token) throws android.os.RemoteException; public java.lang.String RepeatNullableUtf8CppString(java.lang.String token) throws android.os.RemoteException; public java.lang.String[] ReverseUtf8CppString(java.lang.String[] input, java.lang.String[] repeated) throws android.os.RemoteException; public java.lang.String[] ReverseNullableUtf8CppString(java.lang.String[] input, java.lang.String[] repeated) throws android.os.RemoteException; public java.util.List ReverseUtf8CppStringList(java.util.List input, java.util.List repeated) throws android.os.RemoteException; /** comment before annotation */ public android.aidl.tests.INamedCallback GetCallback(boolean return_null) throws android.os.RemoteException; // Since this paracelable has clearly defined default values, it would be // inefficient to use an IPC to fill it out in practice. public void FillOutStructuredParcelable(android.aidl.tests.StructuredParcelable parcel) throws android.os.RemoteException; public void RepeatExtendableParcelable(android.aidl.tests.extension.ExtendableParcelable ep, android.aidl.tests.extension.ExtendableParcelable ep2) throws android.os.RemoteException; public android.aidl.tests.RecursiveList ReverseList(android.aidl.tests.RecursiveList list) throws android.os.RemoteException; public android.os.IBinder[] ReverseIBinderArray(android.os.IBinder[] input, android.os.IBinder[] repeated) throws android.os.RemoteException; public android.os.IBinder[] ReverseNullableIBinderArray(android.os.IBinder[] input, android.os.IBinder[] repeated) throws android.os.RemoteException; public android.aidl.tests.SimpleParcelable RepeatSimpleParcelable(android.aidl.tests.SimpleParcelable input, android.aidl.tests.SimpleParcelable repeat) throws android.os.RemoteException; public android.aidl.tests.SimpleParcelable[] ReverseSimpleParcelables(android.aidl.tests.SimpleParcelable[] input, android.aidl.tests.SimpleParcelable[] repeated) throws android.os.RemoteException; public android.aidl.tests.IOldName GetOldNameInterface() throws android.os.RemoteException; public android.aidl.tests.INewName GetNewNameInterface() throws android.os.RemoteException; public int[] GetUnionTags(android.aidl.tests.Union[] input) throws android.os.RemoteException; // Retrieve the ICppJavaTests if the server supports it public android.os.IBinder GetCppJavaTests() throws android.os.RemoteException; public byte getBackendType() throws android.os.RemoteException; public android.aidl.tests.ICircular GetCircular(android.aidl.tests.CircularParcelable cp) throws android.os.RemoteException; // Small empty parcelable for nullability check public static class Empty implements android.os.Parcelable { public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public Empty createFromParcel(android.os.Parcel _aidl_source) { Empty _aidl_out = new Empty(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public Empty[] newArray(int _aidl_size) { return new Empty[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public boolean equals(Object other) { if (this == other) return true; if (other == null) return false; if (!(other instanceof Empty)) return false; Empty that = (Empty)other; return true; } @Override public int hashCode() { return java.util.Arrays.deepHashCode(java.util.Arrays.asList().toArray()); } @Override public int describeContents() { int _mask = 0; return _mask; } } public static class CompilerChecks implements android.os.Parcelable { // IBinder public android.os.IBinder binder; public android.os.IBinder nullable_binder; public android.os.IBinder[] binder_array; public android.os.IBinder[] nullable_binder_array; public java.util.List binder_list; public java.util.List nullable_binder_list; // ParcelFileDescriptor public android.os.ParcelFileDescriptor pfd; public android.os.ParcelFileDescriptor nullable_pfd; public android.os.ParcelFileDescriptor[] pfd_array; public android.os.ParcelFileDescriptor[] nullable_pfd_array; public java.util.List pfd_list; public java.util.List nullable_pfd_list; // parcelable public android.aidl.tests.ITestService.Empty parcel; public android.aidl.tests.ITestService.Empty nullable_parcel; public android.aidl.tests.ITestService.Empty[] parcel_array; public android.aidl.tests.ITestService.Empty[] nullable_parcel_array; public java.util.List parcel_list; public java.util.List nullable_parcel_list; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public CompilerChecks createFromParcel(android.os.Parcel _aidl_source) { CompilerChecks _aidl_out = new CompilerChecks(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public CompilerChecks[] newArray(int _aidl_size) { return new CompilerChecks[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeStrongBinder(binder); _aidl_parcel.writeStrongBinder(nullable_binder); _aidl_parcel.writeBinderArray(binder_array); _aidl_parcel.writeBinderArray(nullable_binder_array); _aidl_parcel.writeBinderList(binder_list); _aidl_parcel.writeBinderList(nullable_binder_list); _aidl_parcel.writeTypedObject(pfd, _aidl_flag); _aidl_parcel.writeTypedObject(nullable_pfd, _aidl_flag); _aidl_parcel.writeTypedArray(pfd_array, _aidl_flag); _aidl_parcel.writeTypedArray(nullable_pfd_array, _aidl_flag); _aidl_parcel.writeTypedList(pfd_list, _aidl_flag); _aidl_parcel.writeTypedList(nullable_pfd_list, _aidl_flag); _aidl_parcel.writeTypedObject(parcel, _aidl_flag); _aidl_parcel.writeTypedObject(nullable_parcel, _aidl_flag); _aidl_parcel.writeTypedArray(parcel_array, _aidl_flag); _aidl_parcel.writeTypedArray(nullable_parcel_array, _aidl_flag); _aidl_parcel.writeTypedList(parcel_list, _aidl_flag); _aidl_parcel.writeTypedList(nullable_parcel_list, _aidl_flag); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; binder = _aidl_parcel.readStrongBinder(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; nullable_binder = _aidl_parcel.readStrongBinder(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; binder_array = _aidl_parcel.createBinderArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; nullable_binder_array = _aidl_parcel.createBinderArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; binder_list = _aidl_parcel.createBinderArrayList(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; nullable_binder_list = _aidl_parcel.createBinderArrayList(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; pfd = _aidl_parcel.readTypedObject(android.os.ParcelFileDescriptor.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; nullable_pfd = _aidl_parcel.readTypedObject(android.os.ParcelFileDescriptor.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; pfd_array = _aidl_parcel.createTypedArray(android.os.ParcelFileDescriptor.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; nullable_pfd_array = _aidl_parcel.createTypedArray(android.os.ParcelFileDescriptor.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; pfd_list = _aidl_parcel.createTypedArrayList(android.os.ParcelFileDescriptor.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; nullable_pfd_list = _aidl_parcel.createTypedArrayList(android.os.ParcelFileDescriptor.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; parcel = _aidl_parcel.readTypedObject(android.aidl.tests.ITestService.Empty.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; nullable_parcel = _aidl_parcel.readTypedObject(android.aidl.tests.ITestService.Empty.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; parcel_array = _aidl_parcel.createTypedArray(android.aidl.tests.ITestService.Empty.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; nullable_parcel_array = _aidl_parcel.createTypedArray(android.aidl.tests.ITestService.Empty.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; parcel_list = _aidl_parcel.createTypedArrayList(android.aidl.tests.ITestService.Empty.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; nullable_parcel_list = _aidl_parcel.createTypedArrayList(android.aidl.tests.ITestService.Empty.CREATOR); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; _mask |= describeContents(pfd); _mask |= describeContents(nullable_pfd); _mask |= describeContents(pfd_array); _mask |= describeContents(nullable_pfd_array); _mask |= describeContents(pfd_list); _mask |= describeContents(nullable_pfd_list); _mask |= describeContents(parcel); _mask |= describeContents(nullable_parcel); _mask |= describeContents(parcel_array); _mask |= describeContents(nullable_parcel_array); _mask |= describeContents(parcel_list); _mask |= describeContents(nullable_parcel_list); return _mask; } private int describeContents(Object _v) { if (_v == null) return 0; if (_v instanceof Object[]) { int _mask = 0; for (Object o : (Object[]) _v) { _mask |= describeContents(o); } return _mask; } if (_v instanceof java.util.Collection) { int _mask = 0; for (Object o : (java.util.Collection) _v) { _mask |= describeContents(o); } return _mask; } if (_v instanceof android.os.Parcelable) { return ((android.os.Parcelable) _v).describeContents(); } return 0; } // interface without I- public interface Foo extends android.os.IInterface { /** Default implementation for Foo. */ public static class Default implements android.aidl.tests.ITestService.CompilerChecks.Foo { @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.ITestService.CompilerChecks.Foo { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.ITestService.CompilerChecks.Foo interface, * generating a proxy if needed. */ public static android.aidl.tests.ITestService.CompilerChecks.Foo asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.ITestService.CompilerChecks.Foo))) { return ((android.aidl.tests.ITestService.CompilerChecks.Foo)iin); } return new android.aidl.tests.ITestService.CompilerChecks.Foo.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { default: { return super.onTransact(code, data, reply, flags); } } } private static class Proxy implements android.aidl.tests.ITestService.CompilerChecks.Foo { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } } /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.ITestService.CompilerChecks.Foo"; } public static class HasDeprecated implements android.os.Parcelable { /** @deprecated field */ @Deprecated public int deprecated = 0; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public HasDeprecated createFromParcel(android.os.Parcel _aidl_source) { HasDeprecated _aidl_out = new HasDeprecated(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public HasDeprecated[] newArray(int _aidl_size) { return new HasDeprecated[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(deprecated); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; deprecated = _aidl_parcel.readInt(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } } public static final class UsingHasDeprecated implements android.os.Parcelable { // tags for union fields public final static int n = 0; // int n; public final static int m = 1; // android.aidl.tests.ITestService.CompilerChecks.HasDeprecated m; private int _tag; private Object _value; public UsingHasDeprecated() { int _value = 0; this._tag = n; this._value = _value; } private UsingHasDeprecated(android.os.Parcel _aidl_parcel) { readFromParcel(_aidl_parcel); } private UsingHasDeprecated(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public int getTag() { return _tag; } // int n; public static UsingHasDeprecated n(int _value) { return new UsingHasDeprecated(n, _value); } public int getN() { _assertTag(n); return (int) _value; } public void setN(int _value) { _set(n, _value); } // android.aidl.tests.ITestService.CompilerChecks.HasDeprecated m; public static UsingHasDeprecated m(android.aidl.tests.ITestService.CompilerChecks.HasDeprecated _value) { return new UsingHasDeprecated(m, _value); } public android.aidl.tests.ITestService.CompilerChecks.HasDeprecated getM() { _assertTag(m); return (android.aidl.tests.ITestService.CompilerChecks.HasDeprecated) _value; } public void setM(android.aidl.tests.ITestService.CompilerChecks.HasDeprecated _value) { _set(m, _value); } public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public UsingHasDeprecated createFromParcel(android.os.Parcel _aidl_source) { return new UsingHasDeprecated(_aidl_source); } @Override public UsingHasDeprecated[] newArray(int _aidl_size) { return new UsingHasDeprecated[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { _aidl_parcel.writeInt(_tag); switch (_tag) { case n: _aidl_parcel.writeInt(getN()); break; case m: _aidl_parcel.writeTypedObject(getM(), _aidl_flag); break; } } public void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_tag; _aidl_tag = _aidl_parcel.readInt(); switch (_aidl_tag) { case n: { int _aidl_value; _aidl_value = _aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } case m: { android.aidl.tests.ITestService.CompilerChecks.HasDeprecated _aidl_value; _aidl_value = _aidl_parcel.readTypedObject(android.aidl.tests.ITestService.CompilerChecks.HasDeprecated.CREATOR); _set(_aidl_tag, _aidl_value); return; } } throw new IllegalArgumentException("union: unknown tag: " + _aidl_tag); } @Override public int describeContents() { int _mask = 0; switch (getTag()) { case m: _mask |= describeContents(getM()); break; } return _mask; } private int describeContents(Object _v) { if (_v == null) return 0; if (_v instanceof android.os.Parcelable) { return ((android.os.Parcelable) _v).describeContents(); } return 0; } private void _assertTag(int tag) { if (getTag() != tag) { throw new IllegalStateException("bad access: " + _tagString(tag) + ", " + _tagString(getTag()) + " is available."); } } private String _tagString(int _tag) { switch (_tag) { case n: return "n"; case m: return "m"; } throw new IllegalStateException("unknown field: " + _tag); } private void _set(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public static @interface Tag { public static final int n = 0; public static final int m = 1; } } public interface NoPrefixInterface extends android.os.IInterface { /** Default implementation for NoPrefixInterface. */ public static class Default implements android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface { @Override public void foo() throws android.os.RemoteException { } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface interface, * generating a proxy if needed. */ public static android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface))) { return ((android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface)iin); } return new android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_foo: { return "foo"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_foo: { this.foo(); reply.writeNoException(); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public void foo() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_foo, _data, _reply, 0); _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } } static final int TRANSACTION_foo = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface"; public void foo() throws android.os.RemoteException; public static class Nested implements android.os.Parcelable { public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public Nested createFromParcel(android.os.Parcel _aidl_source) { Nested _aidl_out = new Nested(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public Nested[] newArray(int _aidl_size) { return new Nested[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } } public interface NestedNoPrefixInterface extends android.os.IInterface { /** Default implementation for NestedNoPrefixInterface. */ public static class Default implements android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.NestedNoPrefixInterface { @Override public void foo() throws android.os.RemoteException { } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.NestedNoPrefixInterface { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.NestedNoPrefixInterface interface, * generating a proxy if needed. */ public static android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.NestedNoPrefixInterface asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.NestedNoPrefixInterface))) { return ((android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.NestedNoPrefixInterface)iin); } return new android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.NestedNoPrefixInterface.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_foo: { return "foo"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_foo: { this.foo(); reply.writeNoException(); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.NestedNoPrefixInterface { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public void foo() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_foo, _data, _reply, 0); _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } } static final int TRANSACTION_foo = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.NestedNoPrefixInterface"; public void foo() throws android.os.RemoteException; } } } } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_ITestServ0100644 0000000 0000000 00000000034 15172120304 033166 xustar000000000 0000000 28 mtime=1776853188.4460000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/ITestService.java.d0100644 0000000 0000000 00000002227 15172120304 031600 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/ITestService.java : \ system/tools/aidl/tests/android/aidl/tests/ITestService.aidl \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ICircular.aidl \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl \ system/tools/aidl/tests/android/aidl/tests/SimpleParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_IntEnum.j0100644 0000000 0000000 00000000034 15172120304 033105 xustar000000000 0000000 28 mtime=1776853188.4460000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/IntEnum.java0100644 0000000 0000000 00000003501 15172120304 030360 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/IntEnum.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl */ package android.aidl.tests; public @interface IntEnum { public static final int FOO = 1000; public static final int BAR = 2000; public static final int BAZ = 2001; /** @deprecated do not use this */ @Deprecated public static final int QUX = 2002; interface $ { static String toString(int _aidl_v) { if (_aidl_v == FOO) return "FOO"; if (_aidl_v == BAR) return "BAR"; if (_aidl_v == BAZ) return "BAZ"; if (_aidl_v == QUX) return "QUX"; return Integer.toString(_aidl_v); } static String arrayToString(Object _aidl_v) { if (_aidl_v == null) return "null"; Class _aidl_cls = _aidl_v.getClass(); if (!_aidl_cls.isArray()) throw new IllegalArgumentException("not an array: " + _aidl_v); Class comp = _aidl_cls.getComponentType(); java.util.StringJoiner _aidl_sj = new java.util.StringJoiner(", ", "[", "]"); if (comp.isArray()) { for (int _aidl_i = 0; _aidl_i < java.lang.reflect.Array.getLength(_aidl_v); _aidl_i++) { _aidl_sj.add(arrayToString(java.lang.reflect.Array.get(_aidl_v, _aidl_i))); } } else { if (_aidl_cls != int[].class) throw new IllegalArgumentException("wrong type: " + _aidl_cls); for (int e : (int[]) _aidl_v) { _aidl_sj.add(toString(e)); } } return _aidl_sj.toString(); } } } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_IntEnum.j0100644 0000000 0000000 00000000034 15172120304 033105 xustar000000000 0000000 28 mtime=1776853188.4460000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/IntEnum.java.d0100644 0000000 0000000 00000000255 15172120304 030605 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/IntEnum.java : \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_ListOfInt0100644 0000000 0000000 00000000034 15172120304 033151 xustar000000000 0000000 28 mtime=1776853188.4460000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/ListOfInterfaces.java0100644 0000000 0000000 00000065133 15172120304 032216 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/ListOfInterfaces.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ListOfInterfaces.aidl */ package android.aidl.tests; public class ListOfInterfaces implements android.os.Parcelable { public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public ListOfInterfaces createFromParcel(android.os.Parcel _aidl_source) { ListOfInterfaces _aidl_out = new ListOfInterfaces(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public ListOfInterfaces[] newArray(int _aidl_size) { return new ListOfInterfaces[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } public interface IEmptyInterface extends android.os.IInterface { /** Default implementation for IEmptyInterface. */ public static class Default implements android.aidl.tests.ListOfInterfaces.IEmptyInterface { @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.ListOfInterfaces.IEmptyInterface { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.ListOfInterfaces.IEmptyInterface interface, * generating a proxy if needed. */ public static android.aidl.tests.ListOfInterfaces.IEmptyInterface asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.ListOfInterfaces.IEmptyInterface))) { return ((android.aidl.tests.ListOfInterfaces.IEmptyInterface)iin); } return new android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { default: { return super.onTransact(code, data, reply, flags); } } } private static class Proxy implements android.aidl.tests.ListOfInterfaces.IEmptyInterface { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } } /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.ListOfInterfaces.IEmptyInterface"; } public interface IMyInterface extends android.os.IInterface { /** Default implementation for IMyInterface. */ public static class Default implements android.aidl.tests.ListOfInterfaces.IMyInterface { @Override public java.util.List methodWithInterfaces(android.aidl.tests.ListOfInterfaces.IEmptyInterface iface, android.aidl.tests.ListOfInterfaces.IEmptyInterface nullable_iface, java.util.List iface_list_in, java.util.List iface_list_out, java.util.List iface_list_inout, java.util.List nullable_iface_list_in, java.util.List nullable_iface_list_out, java.util.List nullable_iface_list_inout) throws android.os.RemoteException { return null; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.ListOfInterfaces.IMyInterface { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.ListOfInterfaces.IMyInterface interface, * generating a proxy if needed. */ public static android.aidl.tests.ListOfInterfaces.IMyInterface asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.ListOfInterfaces.IMyInterface))) { return ((android.aidl.tests.ListOfInterfaces.IMyInterface)iin); } return new android.aidl.tests.ListOfInterfaces.IMyInterface.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_methodWithInterfaces: { return "methodWithInterfaces"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_methodWithInterfaces: { android.aidl.tests.ListOfInterfaces.IEmptyInterface _arg0; _arg0 = android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub.asInterface(data.readStrongBinder()); android.aidl.tests.ListOfInterfaces.IEmptyInterface _arg1; _arg1 = android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub.asInterface(data.readStrongBinder()); java.util.List _arg2; _arg2 = data.createInterfaceArrayList(android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub::asInterface); java.util.List _arg3; _arg3 = new java.util.ArrayList(); java.util.List _arg4; _arg4 = data.createInterfaceArrayList(android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub::asInterface); java.util.List _arg5; _arg5 = data.createInterfaceArrayList(android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub::asInterface); java.util.List _arg6; _arg6 = new java.util.ArrayList(); java.util.List _arg7; _arg7 = data.createInterfaceArrayList(android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub::asInterface); data.enforceNoDataAvail(); java.util.List _result = this.methodWithInterfaces(_arg0, _arg1, _arg2, _arg3, _arg4, _arg5, _arg6, _arg7); reply.writeNoException(); reply.writeInterfaceList(_result); reply.writeInterfaceList(_arg3); reply.writeInterfaceList(_arg4); reply.writeInterfaceList(_arg6); reply.writeInterfaceList(_arg7); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.ListOfInterfaces.IMyInterface { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public java.util.List methodWithInterfaces(android.aidl.tests.ListOfInterfaces.IEmptyInterface iface, android.aidl.tests.ListOfInterfaces.IEmptyInterface nullable_iface, java.util.List iface_list_in, java.util.List iface_list_out, java.util.List iface_list_inout, java.util.List nullable_iface_list_in, java.util.List nullable_iface_list_out, java.util.List nullable_iface_list_inout) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.util.List _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeStrongInterface(iface); _data.writeStrongInterface(nullable_iface); _data.writeInterfaceList(iface_list_in); _data.writeInterfaceList(iface_list_inout); _data.writeInterfaceList(nullable_iface_list_in); _data.writeInterfaceList(nullable_iface_list_inout); boolean _status = mRemote.transact(Stub.TRANSACTION_methodWithInterfaces, _data, _reply, 0); _reply.readException(); _result = _reply.createInterfaceArrayList(android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub::asInterface); _reply.readInterfaceList(iface_list_out, android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub::asInterface); _reply.readInterfaceList(iface_list_inout, android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub::asInterface); _reply.readInterfaceList(nullable_iface_list_out, android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub::asInterface); _reply.readInterfaceList(nullable_iface_list_inout, android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub::asInterface); } finally { _reply.recycle(); _data.recycle(); } return _result; } } static final int TRANSACTION_methodWithInterfaces = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.ListOfInterfaces.IMyInterface"; public java.util.List methodWithInterfaces(android.aidl.tests.ListOfInterfaces.IEmptyInterface iface, android.aidl.tests.ListOfInterfaces.IEmptyInterface nullable_iface, java.util.List iface_list_in, java.util.List iface_list_out, java.util.List iface_list_inout, java.util.List nullable_iface_list_in, java.util.List nullable_iface_list_out, java.util.List nullable_iface_list_inout) throws android.os.RemoteException; } public static class MyParcelable implements android.os.Parcelable { public android.aidl.tests.ListOfInterfaces.IEmptyInterface iface; public android.aidl.tests.ListOfInterfaces.IEmptyInterface nullable_iface; public java.util.List iface_list; public java.util.List nullable_iface_list; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public MyParcelable createFromParcel(android.os.Parcel _aidl_source) { MyParcelable _aidl_out = new MyParcelable(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public MyParcelable[] newArray(int _aidl_size) { return new MyParcelable[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeStrongInterface(iface); _aidl_parcel.writeStrongInterface(nullable_iface); _aidl_parcel.writeInterfaceList(iface_list); _aidl_parcel.writeInterfaceList(nullable_iface_list); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; iface = android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub.asInterface(_aidl_parcel.readStrongBinder()); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; nullable_iface = android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub.asInterface(_aidl_parcel.readStrongBinder()); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; iface_list = _aidl_parcel.createInterfaceArrayList(android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub::asInterface); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; nullable_iface_list = _aidl_parcel.createInterfaceArrayList(android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub::asInterface); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public String toString() { java.util.StringJoiner _aidl_sj = new java.util.StringJoiner(", ", "{", "}"); _aidl_sj.add("iface: " + (java.util.Objects.toString(iface))); _aidl_sj.add("nullable_iface: " + (java.util.Objects.toString(nullable_iface))); _aidl_sj.add("iface_list: " + (java.util.Objects.toString(iface_list))); _aidl_sj.add("nullable_iface_list: " + (java.util.Objects.toString(nullable_iface_list))); return "MyParcelable" + _aidl_sj.toString() ; } @Override public boolean equals(Object other) { if (this == other) return true; if (other == null) return false; if (!(other instanceof MyParcelable)) return false; MyParcelable that = (MyParcelable)other; if (!java.util.Objects.deepEquals(iface, that.iface)) return false; if (!java.util.Objects.deepEquals(nullable_iface, that.nullable_iface)) return false; if (!java.util.Objects.deepEquals(iface_list, that.iface_list)) return false; if (!java.util.Objects.deepEquals(nullable_iface_list, that.nullable_iface_list)) return false; return true; } @Override public int hashCode() { return java.util.Arrays.deepHashCode(java.util.Arrays.asList(iface, nullable_iface, iface_list, nullable_iface_list).toArray()); } @Override public int describeContents() { int _mask = 0; return _mask; } } public static final class MyUnion implements android.os.Parcelable { // tags for union fields public final static int iface = 0; // android.aidl.tests.ListOfInterfaces.IEmptyInterface iface; public final static int nullable_iface = 1; // android.aidl.tests.ListOfInterfaces.IEmptyInterface nullable_iface; public final static int iface_list = 2; // List iface_list; public final static int nullable_iface_list = 3; // List nullable_iface_list; private int _tag; private Object _value; public MyUnion() { android.aidl.tests.ListOfInterfaces.IEmptyInterface _value = null; this._tag = iface; this._value = _value; } private MyUnion(android.os.Parcel _aidl_parcel) { readFromParcel(_aidl_parcel); } private MyUnion(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public int getTag() { return _tag; } // android.aidl.tests.ListOfInterfaces.IEmptyInterface iface; public static MyUnion iface(android.aidl.tests.ListOfInterfaces.IEmptyInterface _value) { return new MyUnion(iface, _value); } public android.aidl.tests.ListOfInterfaces.IEmptyInterface getIface() { _assertTag(iface); return (android.aidl.tests.ListOfInterfaces.IEmptyInterface) _value; } public void setIface(android.aidl.tests.ListOfInterfaces.IEmptyInterface _value) { _set(iface, _value); } // android.aidl.tests.ListOfInterfaces.IEmptyInterface nullable_iface; public static MyUnion nullable_iface(android.aidl.tests.ListOfInterfaces.IEmptyInterface _value) { return new MyUnion(nullable_iface, _value); } public android.aidl.tests.ListOfInterfaces.IEmptyInterface getNullable_iface() { _assertTag(nullable_iface); return (android.aidl.tests.ListOfInterfaces.IEmptyInterface) _value; } public void setNullable_iface(android.aidl.tests.ListOfInterfaces.IEmptyInterface _value) { _set(nullable_iface, _value); } // List iface_list; public static MyUnion iface_list(java.util.List _value) { return new MyUnion(iface_list, _value); } @SuppressWarnings("unchecked") public java.util.List getIface_list() { _assertTag(iface_list); return (java.util.List) _value; } public void setIface_list(java.util.List _value) { _set(iface_list, _value); } // List nullable_iface_list; public static MyUnion nullable_iface_list(java.util.List _value) { return new MyUnion(nullable_iface_list, _value); } @SuppressWarnings("unchecked") public java.util.List getNullable_iface_list() { _assertTag(nullable_iface_list); return (java.util.List) _value; } public void setNullable_iface_list(java.util.List _value) { _set(nullable_iface_list, _value); } public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public MyUnion createFromParcel(android.os.Parcel _aidl_source) { return new MyUnion(_aidl_source); } @Override public MyUnion[] newArray(int _aidl_size) { return new MyUnion[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { _aidl_parcel.writeInt(_tag); switch (_tag) { case iface: _aidl_parcel.writeStrongInterface(getIface()); break; case nullable_iface: _aidl_parcel.writeStrongInterface(getNullable_iface()); break; case iface_list: _aidl_parcel.writeInterfaceList(getIface_list()); break; case nullable_iface_list: _aidl_parcel.writeInterfaceList(getNullable_iface_list()); break; } } public void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_tag; _aidl_tag = _aidl_parcel.readInt(); switch (_aidl_tag) { case iface: { android.aidl.tests.ListOfInterfaces.IEmptyInterface _aidl_value; _aidl_value = android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub.asInterface(_aidl_parcel.readStrongBinder()); _set(_aidl_tag, _aidl_value); return; } case nullable_iface: { android.aidl.tests.ListOfInterfaces.IEmptyInterface _aidl_value; _aidl_value = android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub.asInterface(_aidl_parcel.readStrongBinder()); _set(_aidl_tag, _aidl_value); return; } case iface_list: { java.util.List _aidl_value; _aidl_value = _aidl_parcel.createInterfaceArrayList(android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub::asInterface); _set(_aidl_tag, _aidl_value); return; } case nullable_iface_list: { java.util.List _aidl_value; _aidl_value = _aidl_parcel.createInterfaceArrayList(android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub::asInterface); _set(_aidl_tag, _aidl_value); return; } } throw new IllegalArgumentException("union: unknown tag: " + _aidl_tag); } @Override public int describeContents() { int _mask = 0; switch (getTag()) { } return _mask; } @Override public String toString() { switch (_tag) { case iface: return "MyUnion.iface(" + (java.util.Objects.toString(getIface())) + ")"; case nullable_iface: return "MyUnion.nullable_iface(" + (java.util.Objects.toString(getNullable_iface())) + ")"; case iface_list: return "MyUnion.iface_list(" + (java.util.Objects.toString(getIface_list())) + ")"; case nullable_iface_list: return "MyUnion.nullable_iface_list(" + (java.util.Objects.toString(getNullable_iface_list())) + ")"; } throw new IllegalStateException("unknown field: " + _tag); } @Override public boolean equals(Object other) { if (this == other) return true; if (other == null) return false; if (!(other instanceof MyUnion)) return false; MyUnion that = (MyUnion)other; if (_tag != that._tag) return false; if (!java.util.Objects.deepEquals(_value, that._value)) return false; return true; } @Override public int hashCode() { return java.util.Arrays.deepHashCode(java.util.Arrays.asList(_tag, _value).toArray()); } private void _assertTag(int tag) { if (getTag() != tag) { throw new IllegalStateException("bad access: " + _tagString(tag) + ", " + _tagString(getTag()) + " is available."); } } private String _tagString(int _tag) { switch (_tag) { case iface: return "iface"; case nullable_iface: return "nullable_iface"; case iface_list: return "iface_list"; case nullable_iface_list: return "nullable_iface_list"; } throw new IllegalStateException("unknown field: " + _tag); } private void _set(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public static @interface Tag { public static final int iface = 0; public static final int nullable_iface = 1; public static final int iface_list = 2; public static final int nullable_iface_list = 3; } } } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_ListOfInt0100644 0000000 0000000 00000000034 15172120304 033151 xustar000000000 0000000 28 mtime=1776853188.4470000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/ListOfInterfaces.java.d0100644 0000000 0000000 00000000277 15172120304 032436 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/ListOfInterfaces.java : \ system/tools/aidl/tests/android/aidl/tests/ListOfInterfaces.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_LongEnum.0100644 0000000 0000000 00000000034 15172120304 033100 xustar000000000 0000000 28 mtime=1776853188.4470000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/LongEnum.java0100644 0000000 0000000 00000001261 15172120304 030526 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/LongEnum.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl */ package android.aidl.tests; public @interface LongEnum { public static final long FOO = 100000000000L; public static final long BAR = 200000000000L; public static final long BAZ = 200000000001L; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_LongEnum.0100644 0000000 0000000 00000000034 15172120304 033100 xustar000000000 0000000 28 mtime=1776853188.4470000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/LongEnum.java.d0100644 0000000 0000000 00000000257 15172120304 030754 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/LongEnum.java : \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_OtherParc0100644 0000000 0000000 00000000220 15172120304 033162 xustar000000000 0000000 116 path=tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/OtherParcelableForToString.java 28 mtime=1776853188.4470000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/OtherParcelableForToStrin0100644 0000000 0000000 00000005227 15172120304 033116 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/OtherParcelableForToString.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl */ package android.aidl.tests; public class OtherParcelableForToString implements android.os.Parcelable { public java.lang.String field; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public OtherParcelableForToString createFromParcel(android.os.Parcel _aidl_source) { OtherParcelableForToString _aidl_out = new OtherParcelableForToString(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public OtherParcelableForToString[] newArray(int _aidl_size) { return new OtherParcelableForToString[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeString(field); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; field = _aidl_parcel.readString(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public String toString() { java.util.StringJoiner _aidl_sj = new java.util.StringJoiner(", ", "{", "}"); _aidl_sj.add("field: " + (java.util.Objects.toString(field))); return "OtherParcelableForToString" + _aidl_sj.toString() ; } @Override public int describeContents() { int _mask = 0; return _mask; } } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_OtherParc0100644 0000000 0000000 00000000222 15172120304 033164 xustar000000000 0000000 118 path=tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/OtherParcelableForToString.java.d 28 mtime=1776853188.4470000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/OtherParcelableForToStrin0100644 0000000 0000000 00000000323 15172120304 033106 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/OtherParcelableForToString.java : \ system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_Parcelabl0100644 0000000 0000000 00000000213 15172120304 033162 xustar000000000 0000000 111 path=tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/ParcelableForToString.java 28 mtime=1776853188.4470000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/ParcelableForToString.jav0100644 0000000 0000000 00000023563 15172120304 033045 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/ParcelableForToString.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ParcelableForToString.aidl */ package android.aidl.tests; public class ParcelableForToString implements android.os.Parcelable { public int intValue = 0; public int[] intArray; public long longValue = 0L; public long[] longArray; public double doubleValue = 0.000000; public double[] doubleArray; public float floatValue = 0.000000f; public float[] floatArray; public byte byteValue = 0; public byte[] byteArray; public boolean booleanValue = false; public boolean[] booleanArray; public java.lang.String stringValue; public java.lang.String[] stringArray; public java.util.List stringList; public android.aidl.tests.OtherParcelableForToString parcelableValue; public android.aidl.tests.OtherParcelableForToString[] parcelableArray; public int enumValue = android.aidl.tests.IntEnum.FOO; public int[] enumArray; public java.lang.String[] nullArray; public java.util.List nullList; public android.aidl.tests.GenericStructuredParcelable parcelableGeneric; public android.aidl.tests.Union unionValue; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public ParcelableForToString createFromParcel(android.os.Parcel _aidl_source) { ParcelableForToString _aidl_out = new ParcelableForToString(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public ParcelableForToString[] newArray(int _aidl_size) { return new ParcelableForToString[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(intValue); _aidl_parcel.writeIntArray(intArray); _aidl_parcel.writeLong(longValue); _aidl_parcel.writeLongArray(longArray); _aidl_parcel.writeDouble(doubleValue); _aidl_parcel.writeDoubleArray(doubleArray); _aidl_parcel.writeFloat(floatValue); _aidl_parcel.writeFloatArray(floatArray); _aidl_parcel.writeByte(byteValue); _aidl_parcel.writeByteArray(byteArray); _aidl_parcel.writeBoolean(booleanValue); _aidl_parcel.writeBooleanArray(booleanArray); _aidl_parcel.writeString(stringValue); _aidl_parcel.writeStringArray(stringArray); _aidl_parcel.writeStringList(stringList); _aidl_parcel.writeTypedObject(parcelableValue, _aidl_flag); _aidl_parcel.writeTypedArray(parcelableArray, _aidl_flag); _aidl_parcel.writeInt(enumValue); _aidl_parcel.writeIntArray(enumArray); _aidl_parcel.writeStringArray(nullArray); _aidl_parcel.writeStringList(nullList); _aidl_parcel.writeTypedObject(parcelableGeneric, _aidl_flag); _aidl_parcel.writeTypedObject(unionValue, _aidl_flag); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; intValue = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; intArray = _aidl_parcel.createIntArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; longValue = _aidl_parcel.readLong(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; longArray = _aidl_parcel.createLongArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; doubleValue = _aidl_parcel.readDouble(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; doubleArray = _aidl_parcel.createDoubleArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; floatValue = _aidl_parcel.readFloat(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; floatArray = _aidl_parcel.createFloatArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; byteValue = _aidl_parcel.readByte(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; byteArray = _aidl_parcel.createByteArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; booleanValue = _aidl_parcel.readBoolean(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; booleanArray = _aidl_parcel.createBooleanArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; stringValue = _aidl_parcel.readString(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; stringArray = _aidl_parcel.createStringArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; stringList = _aidl_parcel.createStringArrayList(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; parcelableValue = _aidl_parcel.readTypedObject(android.aidl.tests.OtherParcelableForToString.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; parcelableArray = _aidl_parcel.createTypedArray(android.aidl.tests.OtherParcelableForToString.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; enumValue = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; enumArray = _aidl_parcel.createIntArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; nullArray = _aidl_parcel.createStringArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; nullList = _aidl_parcel.createStringArrayList(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; parcelableGeneric = _aidl_parcel.readTypedObject(android.aidl.tests.GenericStructuredParcelable.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; unionValue = _aidl_parcel.readTypedObject(android.aidl.tests.Union.CREATOR); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public String toString() { java.util.StringJoiner _aidl_sj = new java.util.StringJoiner(", ", "{", "}"); _aidl_sj.add("intValue: " + (intValue)); _aidl_sj.add("intArray: " + (java.util.Arrays.toString(intArray))); _aidl_sj.add("longValue: " + (longValue)); _aidl_sj.add("longArray: " + (java.util.Arrays.toString(longArray))); _aidl_sj.add("doubleValue: " + (doubleValue)); _aidl_sj.add("doubleArray: " + (java.util.Arrays.toString(doubleArray))); _aidl_sj.add("floatValue: " + (floatValue)); _aidl_sj.add("floatArray: " + (java.util.Arrays.toString(floatArray))); _aidl_sj.add("byteValue: " + (byteValue)); _aidl_sj.add("byteArray: " + (java.util.Arrays.toString(byteArray))); _aidl_sj.add("booleanValue: " + (booleanValue)); _aidl_sj.add("booleanArray: " + (java.util.Arrays.toString(booleanArray))); _aidl_sj.add("stringValue: " + (java.util.Objects.toString(stringValue))); _aidl_sj.add("stringArray: " + (java.util.Arrays.toString(stringArray))); _aidl_sj.add("stringList: " + (java.util.Objects.toString(stringList))); _aidl_sj.add("parcelableValue: " + (java.util.Objects.toString(parcelableValue))); _aidl_sj.add("parcelableArray: " + (java.util.Arrays.toString(parcelableArray))); _aidl_sj.add("enumValue: " + (android.aidl.tests.IntEnum.$.toString(enumValue))); _aidl_sj.add("enumArray: " + (android.aidl.tests.IntEnum.$.arrayToString(enumArray))); _aidl_sj.add("nullArray: " + (java.util.Arrays.toString(nullArray))); _aidl_sj.add("nullList: " + (java.util.Objects.toString(nullList))); _aidl_sj.add("parcelableGeneric: " + (java.util.Objects.toString(parcelableGeneric))); _aidl_sj.add("unionValue: " + (java.util.Objects.toString(unionValue))); return "ParcelableForToString" + _aidl_sj.toString() ; } @Override public int describeContents() { int _mask = 0; _mask |= describeContents(parcelableValue); _mask |= describeContents(parcelableArray); _mask |= describeContents(parcelableGeneric); _mask |= describeContents(unionValue); return _mask; } private int describeContents(Object _v) { if (_v == null) return 0; if (_v instanceof Object[]) { int _mask = 0; for (Object o : (Object[]) _v) { _mask |= describeContents(o); } return _mask; } if (_v instanceof android.os.Parcelable) { return ((android.os.Parcelable) _v).describeContents(); } return 0; } } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_Parcelabl0100644 0000000 0000000 00000000215 15172120304 033164 xustar000000000 0000000 113 path=tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/ParcelableForToString.java.d 28 mtime=1776853188.4480000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/ParcelableForToString.jav0100644 0000000 0000000 00000001354 15172120304 033037 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/ParcelableForToString.java : \ system/tools/aidl/tests/android/aidl/tests/ParcelableForToString.aidl \ system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_Recursive0100644 0000000 0000000 00000000034 15172120304 033245 xustar000000000 0000000 28 mtime=1776853188.4480000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/RecursiveList.java0100644 0000000 0000000 00000005413 15172120304 031610 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/RecursiveList.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl */ package android.aidl.tests; public class RecursiveList implements android.os.Parcelable { public int value = 0; public android.aidl.tests.RecursiveList next; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public RecursiveList createFromParcel(android.os.Parcel _aidl_source) { RecursiveList _aidl_out = new RecursiveList(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public RecursiveList[] newArray(int _aidl_size) { return new RecursiveList[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(value); _aidl_parcel.writeTypedObject(next, _aidl_flag); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; value = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; next = _aidl_parcel.readTypedObject(android.aidl.tests.RecursiveList.CREATOR); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; _mask |= describeContents(next); return _mask; } private int describeContents(Object _v) { if (_v == null) return 0; if (_v instanceof android.os.Parcelable) { return ((android.os.Parcelable) _v).describeContents(); } return 0; } } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_Recursive0100644 0000000 0000000 00000000034 15172120304 033245 xustar000000000 0000000 28 mtime=1776853188.4480000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/RecursiveList.java.d0100644 0000000 0000000 00000000271 15172120304 032027 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/RecursiveList.java : \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_Structure0100644 0000000 0000000 00000000212 15172120304 033274 xustar000000000 0000000 110 path=tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/StructuredParcelable.java 28 mtime=1776853188.4480000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/StructuredParcelable.java0100644 0000000 0000000 00000066365 15172120304 033141 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/StructuredParcelable.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl */ package android.aidl.tests; public class StructuredParcelable implements android.os.Parcelable { public int[] shouldContainThreeFs; public int f = 0; public java.lang.String shouldBeJerry; public byte shouldBeByteBar; public int shouldBeIntBar; public long shouldBeLongBar; public byte[] shouldContainTwoByteFoos; public int[] shouldContainTwoIntFoos; public long[] shouldContainTwoLongFoos; public java.lang.String stringDefaultsToFoo = "foo"; public byte byteDefaultsToFour = 4; public int intDefaultsToFive = 5; public long longDefaultsToNegativeSeven = -7L; public boolean booleanDefaultsToTrue = true; public char charDefaultsToC = 'C'; public float floatDefaultsToPi = 3.140000f; public double doubleWithDefault = -314000000000000000.000000; public int[] arrayDefaultsTo123 = {1, 2, 3}; public int[] arrayDefaultsToEmpty = {}; public boolean boolDefault = false; public byte byteDefault = 0; public int intDefault = 0; public long longDefault = 0L; public float floatDefault = 0.000000f; public double doubleDefault = 0.000000; // parse checks only public double checkDoubleFromFloat = 3.140000; public java.lang.String[] checkStringArray1 = {"a", "b"}; public java.lang.String[] checkStringArray2 = {"a", "b"}; // Add test to verify corner cases public int int32_min = -2147483648; public int int32_max = 2147483647; public long int64_max = 9223372036854775807L; public int hexInt32_neg_1 = -1; public android.os.IBinder ibinder; public android.aidl.tests.StructuredParcelable.Empty empty; // Constant expressions that evaluate to 1 public byte[] int8_1 = {1, 1, 1, 1, 1}; public int[] int32_1 = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}; public long[] int64_1 = {1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L}; public int hexInt32_pos_1 = 1; public int hexInt64_pos_1 = 1; public int const_exprs_1; public int const_exprs_2; public int const_exprs_3; public int const_exprs_4; public int const_exprs_5; public int const_exprs_6; public int const_exprs_7; public int const_exprs_8; public int const_exprs_9; public int const_exprs_10; // String expressions public java.lang.String addString1 = "hello world!"; public java.lang.String addString2 = "The quick brown fox jumps over the lazy dog."; public int shouldSetBit0AndBit2 = 0; public android.aidl.tests.Union u; public android.aidl.tests.Union shouldBeConstS1; public int defaultWithFoo = android.aidl.tests.IntEnum.FOO; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public StructuredParcelable createFromParcel(android.os.Parcel _aidl_source) { StructuredParcelable _aidl_out = new StructuredParcelable(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public StructuredParcelable[] newArray(int _aidl_size) { return new StructuredParcelable[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeIntArray(shouldContainThreeFs); _aidl_parcel.writeInt(f); _aidl_parcel.writeString(shouldBeJerry); _aidl_parcel.writeByte(shouldBeByteBar); _aidl_parcel.writeInt(shouldBeIntBar); _aidl_parcel.writeLong(shouldBeLongBar); _aidl_parcel.writeByteArray(shouldContainTwoByteFoos); _aidl_parcel.writeIntArray(shouldContainTwoIntFoos); _aidl_parcel.writeLongArray(shouldContainTwoLongFoos); _aidl_parcel.writeString(stringDefaultsToFoo); _aidl_parcel.writeByte(byteDefaultsToFour); _aidl_parcel.writeInt(intDefaultsToFive); _aidl_parcel.writeLong(longDefaultsToNegativeSeven); _aidl_parcel.writeBoolean(booleanDefaultsToTrue); _aidl_parcel.writeInt(((int)charDefaultsToC)); _aidl_parcel.writeFloat(floatDefaultsToPi); _aidl_parcel.writeDouble(doubleWithDefault); _aidl_parcel.writeIntArray(arrayDefaultsTo123); _aidl_parcel.writeIntArray(arrayDefaultsToEmpty); _aidl_parcel.writeBoolean(boolDefault); _aidl_parcel.writeByte(byteDefault); _aidl_parcel.writeInt(intDefault); _aidl_parcel.writeLong(longDefault); _aidl_parcel.writeFloat(floatDefault); _aidl_parcel.writeDouble(doubleDefault); _aidl_parcel.writeDouble(checkDoubleFromFloat); _aidl_parcel.writeStringArray(checkStringArray1); _aidl_parcel.writeStringArray(checkStringArray2); _aidl_parcel.writeInt(int32_min); _aidl_parcel.writeInt(int32_max); _aidl_parcel.writeLong(int64_max); _aidl_parcel.writeInt(hexInt32_neg_1); _aidl_parcel.writeStrongBinder(ibinder); _aidl_parcel.writeTypedObject(empty, _aidl_flag); _aidl_parcel.writeByteArray(int8_1); _aidl_parcel.writeIntArray(int32_1); _aidl_parcel.writeLongArray(int64_1); _aidl_parcel.writeInt(hexInt32_pos_1); _aidl_parcel.writeInt(hexInt64_pos_1); _aidl_parcel.writeInt(const_exprs_1); _aidl_parcel.writeInt(const_exprs_2); _aidl_parcel.writeInt(const_exprs_3); _aidl_parcel.writeInt(const_exprs_4); _aidl_parcel.writeInt(const_exprs_5); _aidl_parcel.writeInt(const_exprs_6); _aidl_parcel.writeInt(const_exprs_7); _aidl_parcel.writeInt(const_exprs_8); _aidl_parcel.writeInt(const_exprs_9); _aidl_parcel.writeInt(const_exprs_10); _aidl_parcel.writeString(addString1); _aidl_parcel.writeString(addString2); _aidl_parcel.writeInt(shouldSetBit0AndBit2); _aidl_parcel.writeTypedObject(u, _aidl_flag); _aidl_parcel.writeTypedObject(shouldBeConstS1, _aidl_flag); _aidl_parcel.writeInt(defaultWithFoo); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; shouldContainThreeFs = _aidl_parcel.createIntArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; f = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; shouldBeJerry = _aidl_parcel.readString(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; shouldBeByteBar = _aidl_parcel.readByte(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; shouldBeIntBar = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; shouldBeLongBar = _aidl_parcel.readLong(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; shouldContainTwoByteFoos = _aidl_parcel.createByteArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; shouldContainTwoIntFoos = _aidl_parcel.createIntArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; shouldContainTwoLongFoos = _aidl_parcel.createLongArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; stringDefaultsToFoo = _aidl_parcel.readString(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; byteDefaultsToFour = _aidl_parcel.readByte(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; intDefaultsToFive = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; longDefaultsToNegativeSeven = _aidl_parcel.readLong(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; booleanDefaultsToTrue = _aidl_parcel.readBoolean(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; charDefaultsToC = (char)_aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; floatDefaultsToPi = _aidl_parcel.readFloat(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; doubleWithDefault = _aidl_parcel.readDouble(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; arrayDefaultsTo123 = _aidl_parcel.createIntArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; arrayDefaultsToEmpty = _aidl_parcel.createIntArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; boolDefault = _aidl_parcel.readBoolean(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; byteDefault = _aidl_parcel.readByte(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; intDefault = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; longDefault = _aidl_parcel.readLong(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; floatDefault = _aidl_parcel.readFloat(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; doubleDefault = _aidl_parcel.readDouble(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; checkDoubleFromFloat = _aidl_parcel.readDouble(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; checkStringArray1 = _aidl_parcel.createStringArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; checkStringArray2 = _aidl_parcel.createStringArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; int32_min = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; int32_max = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; int64_max = _aidl_parcel.readLong(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; hexInt32_neg_1 = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; ibinder = _aidl_parcel.readStrongBinder(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; empty = _aidl_parcel.readTypedObject(android.aidl.tests.StructuredParcelable.Empty.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; int8_1 = _aidl_parcel.createByteArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; int32_1 = _aidl_parcel.createIntArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; int64_1 = _aidl_parcel.createLongArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; hexInt32_pos_1 = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; hexInt64_pos_1 = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; const_exprs_1 = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; const_exprs_2 = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; const_exprs_3 = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; const_exprs_4 = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; const_exprs_5 = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; const_exprs_6 = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; const_exprs_7 = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; const_exprs_8 = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; const_exprs_9 = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; const_exprs_10 = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; addString1 = _aidl_parcel.readString(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; addString2 = _aidl_parcel.readString(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; shouldSetBit0AndBit2 = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; u = _aidl_parcel.readTypedObject(android.aidl.tests.Union.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; shouldBeConstS1 = _aidl_parcel.readTypedObject(android.aidl.tests.Union.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; defaultWithFoo = _aidl_parcel.readInt(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } public static final int BIT0 = 1; public static final int BIT1 = 2; public static final int BIT2 = 4; @Override public String toString() { java.util.StringJoiner _aidl_sj = new java.util.StringJoiner(", ", "{", "}"); _aidl_sj.add("shouldContainThreeFs: " + (java.util.Arrays.toString(shouldContainThreeFs))); _aidl_sj.add("f: " + (f)); _aidl_sj.add("shouldBeJerry: " + (java.util.Objects.toString(shouldBeJerry))); _aidl_sj.add("shouldBeByteBar: " + (shouldBeByteBar)); _aidl_sj.add("shouldBeIntBar: " + (android.aidl.tests.IntEnum.$.toString(shouldBeIntBar))); _aidl_sj.add("shouldBeLongBar: " + (shouldBeLongBar)); _aidl_sj.add("shouldContainTwoByteFoos: " + (java.util.Arrays.toString(shouldContainTwoByteFoos))); _aidl_sj.add("shouldContainTwoIntFoos: " + (android.aidl.tests.IntEnum.$.arrayToString(shouldContainTwoIntFoos))); _aidl_sj.add("shouldContainTwoLongFoos: " + (java.util.Arrays.toString(shouldContainTwoLongFoos))); _aidl_sj.add("stringDefaultsToFoo: " + (java.util.Objects.toString(stringDefaultsToFoo))); _aidl_sj.add("byteDefaultsToFour: " + (byteDefaultsToFour)); _aidl_sj.add("intDefaultsToFive: " + (intDefaultsToFive)); _aidl_sj.add("longDefaultsToNegativeSeven: " + (longDefaultsToNegativeSeven)); _aidl_sj.add("booleanDefaultsToTrue: " + (booleanDefaultsToTrue)); _aidl_sj.add("charDefaultsToC: " + (charDefaultsToC)); _aidl_sj.add("floatDefaultsToPi: " + (floatDefaultsToPi)); _aidl_sj.add("doubleWithDefault: " + (doubleWithDefault)); _aidl_sj.add("arrayDefaultsTo123: " + (java.util.Arrays.toString(arrayDefaultsTo123))); _aidl_sj.add("arrayDefaultsToEmpty: " + (java.util.Arrays.toString(arrayDefaultsToEmpty))); _aidl_sj.add("boolDefault: " + (boolDefault)); _aidl_sj.add("byteDefault: " + (byteDefault)); _aidl_sj.add("intDefault: " + (intDefault)); _aidl_sj.add("longDefault: " + (longDefault)); _aidl_sj.add("floatDefault: " + (floatDefault)); _aidl_sj.add("doubleDefault: " + (doubleDefault)); _aidl_sj.add("checkDoubleFromFloat: " + (checkDoubleFromFloat)); _aidl_sj.add("checkStringArray1: " + (java.util.Arrays.toString(checkStringArray1))); _aidl_sj.add("checkStringArray2: " + (java.util.Arrays.toString(checkStringArray2))); _aidl_sj.add("int32_min: " + (int32_min)); _aidl_sj.add("int32_max: " + (int32_max)); _aidl_sj.add("int64_max: " + (int64_max)); _aidl_sj.add("hexInt32_neg_1: " + (hexInt32_neg_1)); _aidl_sj.add("ibinder: " + (java.util.Objects.toString(ibinder))); _aidl_sj.add("empty: " + (java.util.Objects.toString(empty))); _aidl_sj.add("int8_1: " + (java.util.Arrays.toString(int8_1))); _aidl_sj.add("int32_1: " + (java.util.Arrays.toString(int32_1))); _aidl_sj.add("int64_1: " + (java.util.Arrays.toString(int64_1))); _aidl_sj.add("hexInt32_pos_1: " + (hexInt32_pos_1)); _aidl_sj.add("hexInt64_pos_1: " + (hexInt64_pos_1)); _aidl_sj.add("const_exprs_1: " + (const_exprs_1)); _aidl_sj.add("const_exprs_2: " + (const_exprs_2)); _aidl_sj.add("const_exprs_3: " + (const_exprs_3)); _aidl_sj.add("const_exprs_4: " + (const_exprs_4)); _aidl_sj.add("const_exprs_5: " + (const_exprs_5)); _aidl_sj.add("const_exprs_6: " + (const_exprs_6)); _aidl_sj.add("const_exprs_7: " + (const_exprs_7)); _aidl_sj.add("const_exprs_8: " + (const_exprs_8)); _aidl_sj.add("const_exprs_9: " + (const_exprs_9)); _aidl_sj.add("const_exprs_10: " + (const_exprs_10)); _aidl_sj.add("addString1: " + (java.util.Objects.toString(addString1))); _aidl_sj.add("addString2: " + (java.util.Objects.toString(addString2))); _aidl_sj.add("shouldSetBit0AndBit2: " + (shouldSetBit0AndBit2)); _aidl_sj.add("u: " + (java.util.Objects.toString(u))); _aidl_sj.add("shouldBeConstS1: " + (java.util.Objects.toString(shouldBeConstS1))); _aidl_sj.add("defaultWithFoo: " + (android.aidl.tests.IntEnum.$.toString(defaultWithFoo))); return "StructuredParcelable" + _aidl_sj.toString() ; } @Override public boolean equals(Object other) { if (this == other) return true; if (other == null) return false; if (!(other instanceof StructuredParcelable)) return false; StructuredParcelable that = (StructuredParcelable)other; if (!java.util.Objects.deepEquals(shouldContainThreeFs, that.shouldContainThreeFs)) return false; if (!java.util.Objects.deepEquals(f, that.f)) return false; if (!java.util.Objects.deepEquals(shouldBeJerry, that.shouldBeJerry)) return false; if (!java.util.Objects.deepEquals(shouldBeByteBar, that.shouldBeByteBar)) return false; if (!java.util.Objects.deepEquals(shouldBeIntBar, that.shouldBeIntBar)) return false; if (!java.util.Objects.deepEquals(shouldBeLongBar, that.shouldBeLongBar)) return false; if (!java.util.Objects.deepEquals(shouldContainTwoByteFoos, that.shouldContainTwoByteFoos)) return false; if (!java.util.Objects.deepEquals(shouldContainTwoIntFoos, that.shouldContainTwoIntFoos)) return false; if (!java.util.Objects.deepEquals(shouldContainTwoLongFoos, that.shouldContainTwoLongFoos)) return false; if (!java.util.Objects.deepEquals(stringDefaultsToFoo, that.stringDefaultsToFoo)) return false; if (!java.util.Objects.deepEquals(byteDefaultsToFour, that.byteDefaultsToFour)) return false; if (!java.util.Objects.deepEquals(intDefaultsToFive, that.intDefaultsToFive)) return false; if (!java.util.Objects.deepEquals(longDefaultsToNegativeSeven, that.longDefaultsToNegativeSeven)) return false; if (!java.util.Objects.deepEquals(booleanDefaultsToTrue, that.booleanDefaultsToTrue)) return false; if (!java.util.Objects.deepEquals(charDefaultsToC, that.charDefaultsToC)) return false; if (!java.util.Objects.deepEquals(floatDefaultsToPi, that.floatDefaultsToPi)) return false; if (!java.util.Objects.deepEquals(doubleWithDefault, that.doubleWithDefault)) return false; if (!java.util.Objects.deepEquals(arrayDefaultsTo123, that.arrayDefaultsTo123)) return false; if (!java.util.Objects.deepEquals(arrayDefaultsToEmpty, that.arrayDefaultsToEmpty)) return false; if (!java.util.Objects.deepEquals(boolDefault, that.boolDefault)) return false; if (!java.util.Objects.deepEquals(byteDefault, that.byteDefault)) return false; if (!java.util.Objects.deepEquals(intDefault, that.intDefault)) return false; if (!java.util.Objects.deepEquals(longDefault, that.longDefault)) return false; if (!java.util.Objects.deepEquals(floatDefault, that.floatDefault)) return false; if (!java.util.Objects.deepEquals(doubleDefault, that.doubleDefault)) return false; if (!java.util.Objects.deepEquals(checkDoubleFromFloat, that.checkDoubleFromFloat)) return false; if (!java.util.Objects.deepEquals(checkStringArray1, that.checkStringArray1)) return false; if (!java.util.Objects.deepEquals(checkStringArray2, that.checkStringArray2)) return false; if (!java.util.Objects.deepEquals(int32_min, that.int32_min)) return false; if (!java.util.Objects.deepEquals(int32_max, that.int32_max)) return false; if (!java.util.Objects.deepEquals(int64_max, that.int64_max)) return false; if (!java.util.Objects.deepEquals(hexInt32_neg_1, that.hexInt32_neg_1)) return false; if (!java.util.Objects.deepEquals(ibinder, that.ibinder)) return false; if (!java.util.Objects.deepEquals(empty, that.empty)) return false; if (!java.util.Objects.deepEquals(int8_1, that.int8_1)) return false; if (!java.util.Objects.deepEquals(int32_1, that.int32_1)) return false; if (!java.util.Objects.deepEquals(int64_1, that.int64_1)) return false; if (!java.util.Objects.deepEquals(hexInt32_pos_1, that.hexInt32_pos_1)) return false; if (!java.util.Objects.deepEquals(hexInt64_pos_1, that.hexInt64_pos_1)) return false; if (!java.util.Objects.deepEquals(const_exprs_1, that.const_exprs_1)) return false; if (!java.util.Objects.deepEquals(const_exprs_2, that.const_exprs_2)) return false; if (!java.util.Objects.deepEquals(const_exprs_3, that.const_exprs_3)) return false; if (!java.util.Objects.deepEquals(const_exprs_4, that.const_exprs_4)) return false; if (!java.util.Objects.deepEquals(const_exprs_5, that.const_exprs_5)) return false; if (!java.util.Objects.deepEquals(const_exprs_6, that.const_exprs_6)) return false; if (!java.util.Objects.deepEquals(const_exprs_7, that.const_exprs_7)) return false; if (!java.util.Objects.deepEquals(const_exprs_8, that.const_exprs_8)) return false; if (!java.util.Objects.deepEquals(const_exprs_9, that.const_exprs_9)) return false; if (!java.util.Objects.deepEquals(const_exprs_10, that.const_exprs_10)) return false; if (!java.util.Objects.deepEquals(addString1, that.addString1)) return false; if (!java.util.Objects.deepEquals(addString2, that.addString2)) return false; if (!java.util.Objects.deepEquals(shouldSetBit0AndBit2, that.shouldSetBit0AndBit2)) return false; if (!java.util.Objects.deepEquals(u, that.u)) return false; if (!java.util.Objects.deepEquals(shouldBeConstS1, that.shouldBeConstS1)) return false; if (!java.util.Objects.deepEquals(defaultWithFoo, that.defaultWithFoo)) return false; return true; } @Override public int hashCode() { return java.util.Arrays.deepHashCode(java.util.Arrays.asList(shouldContainThreeFs, f, shouldBeJerry, shouldBeByteBar, shouldBeIntBar, shouldBeLongBar, shouldContainTwoByteFoos, shouldContainTwoIntFoos, shouldContainTwoLongFoos, stringDefaultsToFoo, byteDefaultsToFour, intDefaultsToFive, longDefaultsToNegativeSeven, booleanDefaultsToTrue, charDefaultsToC, floatDefaultsToPi, doubleWithDefault, arrayDefaultsTo123, arrayDefaultsToEmpty, boolDefault, byteDefault, intDefault, longDefault, floatDefault, doubleDefault, checkDoubleFromFloat, checkStringArray1, checkStringArray2, int32_min, int32_max, int64_max, hexInt32_neg_1, ibinder, empty, int8_1, int32_1, int64_1, hexInt32_pos_1, hexInt64_pos_1, const_exprs_1, const_exprs_2, const_exprs_3, const_exprs_4, const_exprs_5, const_exprs_6, const_exprs_7, const_exprs_8, const_exprs_9, const_exprs_10, addString1, addString2, shouldSetBit0AndBit2, u, shouldBeConstS1, defaultWithFoo).toArray()); } @Override public int describeContents() { int _mask = 0; _mask |= describeContents(empty); _mask |= describeContents(u); _mask |= describeContents(shouldBeConstS1); return _mask; } private int describeContents(Object _v) { if (_v == null) return 0; if (_v instanceof android.os.Parcelable) { return ((android.os.Parcelable) _v).describeContents(); } return 0; } // Make sure we can send an empty parcelable public static class Empty implements android.os.Parcelable { public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public Empty createFromParcel(android.os.Parcel _aidl_source) { Empty _aidl_out = new Empty(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public Empty[] newArray(int _aidl_size) { return new Empty[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public String toString() { java.util.StringJoiner _aidl_sj = new java.util.StringJoiner(", ", "{", "}"); return "Empty" + _aidl_sj.toString() ; } @Override public boolean equals(Object other) { if (this == other) return true; if (other == null) return false; if (!(other instanceof Empty)) return false; Empty that = (Empty)other; return true; } @Override public int hashCode() { return java.util.Arrays.deepHashCode(java.util.Arrays.asList().toArray()); } @Override public int describeContents() { int _mask = 0; return _mask; } } } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_Structure0100644 0000000 0000000 00000000214 15172120304 033276 xustar000000000 0000000 112 path=tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/StructuredParcelable.java.d 28 mtime=1776853188.4490000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/StructuredParcelable.java0100644 0000000 0000000 00000001002 15172120304 033112 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/StructuredParcelable.java : \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_Union.jav0100644 0000000 0000000 00000000034 15172120304 033145 xustar000000000 0000000 28 mtime=1776853188.4490000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/Union.java0100644 0000000 0000000 00000016771 15172120304 030106 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/Union.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/Union.aidl */ package android.aidl.tests; public final class Union implements android.os.Parcelable { // tags for union fields public final static int ns = 0; // int[] ns; public final static int n = 1; // int n; public final static int m = 2; // int m; public final static int s = 3; // String s; public final static int ibinder = 4; // IBinder ibinder; public final static int ss = 5; // List ss; public final static int be = 6; // android.aidl.tests.ByteEnum be; private int _tag; private Object _value; public Union() { int[] _value = {}; this._tag = ns; this._value = _value; } private Union(android.os.Parcel _aidl_parcel) { readFromParcel(_aidl_parcel); } private Union(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public int getTag() { return _tag; } // int[] ns; public static Union ns(int[] _value) { return new Union(ns, _value); } public int[] getNs() { _assertTag(ns); return (int[]) _value; } public void setNs(int[] _value) { _set(ns, _value); } // int n; public static Union n(int _value) { return new Union(n, _value); } public int getN() { _assertTag(n); return (int) _value; } public void setN(int _value) { _set(n, _value); } // int m; public static Union m(int _value) { return new Union(m, _value); } public int getM() { _assertTag(m); return (int) _value; } public void setM(int _value) { _set(m, _value); } // String s; public static Union s(java.lang.String _value) { return new Union(s, _value); } public java.lang.String getS() { _assertTag(s); return (java.lang.String) _value; } public void setS(java.lang.String _value) { _set(s, _value); } // IBinder ibinder; public static Union ibinder(android.os.IBinder _value) { return new Union(ibinder, _value); } public android.os.IBinder getIbinder() { _assertTag(ibinder); return (android.os.IBinder) _value; } public void setIbinder(android.os.IBinder _value) { _set(ibinder, _value); } // List ss; public static Union ss(java.util.List _value) { return new Union(ss, _value); } @SuppressWarnings("unchecked") public java.util.List getSs() { _assertTag(ss); return (java.util.List) _value; } public void setSs(java.util.List _value) { _set(ss, _value); } // android.aidl.tests.ByteEnum be; public static Union be(byte _value) { return new Union(be, _value); } public byte getBe() { _assertTag(be); return (byte) _value; } public void setBe(byte _value) { _set(be, _value); } public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public Union createFromParcel(android.os.Parcel _aidl_source) { return new Union(_aidl_source); } @Override public Union[] newArray(int _aidl_size) { return new Union[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { _aidl_parcel.writeInt(_tag); switch (_tag) { case ns: _aidl_parcel.writeIntArray(getNs()); break; case n: _aidl_parcel.writeInt(getN()); break; case m: _aidl_parcel.writeInt(getM()); break; case s: _aidl_parcel.writeString(getS()); break; case ibinder: _aidl_parcel.writeStrongBinder(getIbinder()); break; case ss: _aidl_parcel.writeStringList(getSs()); break; case be: _aidl_parcel.writeByte(getBe()); break; } } public void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_tag; _aidl_tag = _aidl_parcel.readInt(); switch (_aidl_tag) { case ns: { int[] _aidl_value; _aidl_value = _aidl_parcel.createIntArray(); _set(_aidl_tag, _aidl_value); return; } case n: { int _aidl_value; _aidl_value = _aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } case m: { int _aidl_value; _aidl_value = _aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } case s: { java.lang.String _aidl_value; _aidl_value = _aidl_parcel.readString(); _set(_aidl_tag, _aidl_value); return; } case ibinder: { android.os.IBinder _aidl_value; _aidl_value = _aidl_parcel.readStrongBinder(); _set(_aidl_tag, _aidl_value); return; } case ss: { java.util.List _aidl_value; _aidl_value = _aidl_parcel.createStringArrayList(); _set(_aidl_tag, _aidl_value); return; } case be: { byte _aidl_value; _aidl_value = _aidl_parcel.readByte(); _set(_aidl_tag, _aidl_value); return; } } throw new IllegalArgumentException("union: unknown tag: " + _aidl_tag); } public static final String S1 = "a string constant in union"; @Override public int describeContents() { int _mask = 0; switch (getTag()) { } return _mask; } @Override public String toString() { switch (_tag) { case ns: return "Union.ns(" + (java.util.Arrays.toString(getNs())) + ")"; case n: return "Union.n(" + (getN()) + ")"; case m: return "Union.m(" + (getM()) + ")"; case s: return "Union.s(" + (java.util.Objects.toString(getS())) + ")"; case ibinder: return "Union.ibinder(" + (java.util.Objects.toString(getIbinder())) + ")"; case ss: return "Union.ss(" + (java.util.Objects.toString(getSs())) + ")"; case be: return "Union.be(" + (getBe()) + ")"; } throw new IllegalStateException("unknown field: " + _tag); } @Override public boolean equals(Object other) { if (this == other) return true; if (other == null) return false; if (!(other instanceof Union)) return false; Union that = (Union)other; if (_tag != that._tag) return false; if (!java.util.Objects.deepEquals(_value, that._value)) return false; return true; } @Override public int hashCode() { return java.util.Arrays.deepHashCode(java.util.Arrays.asList(_tag, _value).toArray()); } private void _assertTag(int tag) { if (getTag() != tag) { throw new IllegalStateException("bad access: " + _tagString(tag) + ", " + _tagString(getTag()) + " is available."); } } private String _tagString(int _tag) { switch (_tag) { case ns: return "ns"; case n: return "n"; case m: return "m"; case s: return "s"; case ibinder: return "ibinder"; case ss: return "ss"; case be: return "be"; } throw new IllegalStateException("unknown field: " + _tag); } private void _set(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public static @interface Tag { public static final int ns = 0; public static final int n = 1; public static final int m = 2; public static final int s = 3; public static final int ibinder = 4; public static final int ss = 5; public static final int be = 6; } } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_Union.jav0100644 0000000 0000000 00000000034 15172120304 033145 xustar000000000 0000000 28 mtime=1776853188.4490000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/Union.java.d0100644 0000000 0000000 00000000346 15172120304 030317 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/Union.java : \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_UnionWith0100644 0000000 0000000 00000000034 15172120304 033222 xustar000000000 0000000 28 mtime=1776853188.4490000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/UnionWithFd.java0100644 0000000 0000000 00000007641 15172120304 031210 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/UnionWithFd.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/UnionWithFd.aidl */ package android.aidl.tests; public final class UnionWithFd implements android.os.Parcelable { // tags for union fields public final static int num = 0; // int num; public final static int pfd = 1; // ParcelFileDescriptor pfd; private int _tag; private Object _value; public UnionWithFd() { int _value = 0; this._tag = num; this._value = _value; } private UnionWithFd(android.os.Parcel _aidl_parcel) { readFromParcel(_aidl_parcel); } private UnionWithFd(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public int getTag() { return _tag; } // int num; public static UnionWithFd num(int _value) { return new UnionWithFd(num, _value); } public int getNum() { _assertTag(num); return (int) _value; } public void setNum(int _value) { _set(num, _value); } // ParcelFileDescriptor pfd; public static UnionWithFd pfd(android.os.ParcelFileDescriptor _value) { return new UnionWithFd(pfd, _value); } public android.os.ParcelFileDescriptor getPfd() { _assertTag(pfd); return (android.os.ParcelFileDescriptor) _value; } public void setPfd(android.os.ParcelFileDescriptor _value) { _set(pfd, _value); } public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public UnionWithFd createFromParcel(android.os.Parcel _aidl_source) { return new UnionWithFd(_aidl_source); } @Override public UnionWithFd[] newArray(int _aidl_size) { return new UnionWithFd[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { _aidl_parcel.writeInt(_tag); switch (_tag) { case num: _aidl_parcel.writeInt(getNum()); break; case pfd: _aidl_parcel.writeTypedObject(getPfd(), _aidl_flag); break; } } public void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_tag; _aidl_tag = _aidl_parcel.readInt(); switch (_aidl_tag) { case num: { int _aidl_value; _aidl_value = _aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } case pfd: { android.os.ParcelFileDescriptor _aidl_value; _aidl_value = _aidl_parcel.readTypedObject(android.os.ParcelFileDescriptor.CREATOR); _set(_aidl_tag, _aidl_value); return; } } throw new IllegalArgumentException("union: unknown tag: " + _aidl_tag); } @Override public int describeContents() { int _mask = 0; switch (getTag()) { case pfd: _mask |= describeContents(getPfd()); break; } return _mask; } private int describeContents(Object _v) { if (_v == null) return 0; if (_v instanceof android.os.Parcelable) { return ((android.os.Parcelable) _v).describeContents(); } return 0; } private void _assertTag(int tag) { if (getTag() != tag) { throw new IllegalStateException("bad access: " + _tagString(tag) + ", " + _tagString(getTag()) + " is available."); } } private String _tagString(int _tag) { switch (_tag) { case num: return "num"; case pfd: return "pfd"; } throw new IllegalStateException("unknown field: " + _tag); } private void _set(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public static @interface Tag { public static final int num = 0; public static final int pfd = 1; } } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_UnionWith0100644 0000000 0000000 00000000034 15172120304 033222 xustar000000000 0000000 28 mtime=1776853188.4490000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/UnionWithFd.java.d0100644 0000000 0000000 00000000265 15172120304 031425 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/UnionWithFd.java : \ system/tools/aidl/tests/android/aidl/tests/UnionWithFd.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_extension0100644 0000000 0000000 00000000034 15172120304 033312 xustar000000000 0000000 28 mtime=1776853188.4520000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/extension/0040755 0000000 0000000 00000000000 15172120304 030156 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_extension0100644 0000000 0000000 00000000224 15172120304 033313 xustar000000000 0000000 120 path=tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/extension/ExtendableParcelable.java 28 mtime=1776853188.4520000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/extension/ExtendableParce0100644 0000000 0000000 00000007255 15172120304 033135 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/extension/ExtendableParcelable.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl */ package android.aidl.tests.extension; public class ExtendableParcelable implements android.os.Parcelable { public int a = 0; public java.lang.String b; public final android.os.ParcelableHolder ext = new android.os.ParcelableHolder(android.os.Parcelable.PARCELABLE_STABILITY_LOCAL); public long c = 0L; public final android.os.ParcelableHolder ext2 = new android.os.ParcelableHolder(android.os.Parcelable.PARCELABLE_STABILITY_LOCAL); public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public ExtendableParcelable createFromParcel(android.os.Parcel _aidl_source) { ExtendableParcelable _aidl_out = new ExtendableParcelable(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public ExtendableParcelable[] newArray(int _aidl_size) { return new ExtendableParcelable[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(a); _aidl_parcel.writeString(b); _aidl_parcel.writeTypedObject(ext, 0); _aidl_parcel.writeLong(c); _aidl_parcel.writeTypedObject(ext2, 0); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; a = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; b = _aidl_parcel.readString(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; if ((0!=_aidl_parcel.readInt())) { ext.readFromParcel(_aidl_parcel); } if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; c = _aidl_parcel.readLong(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; if ((0!=_aidl_parcel.readInt())) { ext2.readFromParcel(_aidl_parcel); } } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; _mask |= describeContents(ext); _mask |= describeContents(ext2); return _mask; } private int describeContents(Object _v) { if (_v == null) return 0; if (_v instanceof android.os.Parcelable) { return ((android.os.Parcelable) _v).describeContents(); } return 0; } } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_extension0100644 0000000 0000000 00000000226 15172120304 033315 xustar000000000 0000000 122 path=tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/extension/ExtendableParcelable.java.d 28 mtime=1776853188.4520000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/extension/ExtendableParce0100644 0000000 0000000 00000000333 15172120304 033123 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/extension/ExtendableParcelable.java : \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_extension0100644 0000000 0000000 00000000034 15172120304 033312 xustar000000000 0000000 28 mtime=1776853188.4520000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/extension/MyExt.java0100644 0000000 0000000 00000004602 15172120304 032066 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/extension/MyExt.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl */ package android.aidl.tests.extension; public class MyExt implements android.os.Parcelable { public int a = 0; public java.lang.String b; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public MyExt createFromParcel(android.os.Parcel _aidl_source) { MyExt _aidl_out = new MyExt(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public MyExt[] newArray(int _aidl_size) { return new MyExt[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(a); _aidl_parcel.writeString(b); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; a = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; b = _aidl_parcel.readString(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_extension0100644 0000000 0000000 00000000034 15172120304 033312 xustar000000000 0000000 28 mtime=1776853188.4520000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/extension/MyExt.java.d0100644 0000000 0000000 00000000275 15172120304 032312 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/extension/MyExt.java : \ system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_extension0100644 0000000 0000000 00000000034 15172120304 033312 xustar000000000 0000000 28 mtime=1776853188.4520000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/extension/MyExt2.java0100644 0000000 0000000 00000005614 15172120304 032154 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/extension/MyExt2.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt2.aidl */ package android.aidl.tests.extension; public class MyExt2 implements android.os.Parcelable { public int a = 0; public android.aidl.tests.extension.MyExt b; public java.lang.String c; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public MyExt2 createFromParcel(android.os.Parcel _aidl_source) { MyExt2 _aidl_out = new MyExt2(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public MyExt2[] newArray(int _aidl_size) { return new MyExt2[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(a); _aidl_parcel.writeTypedObject(b, _aidl_flag); _aidl_parcel.writeString(c); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; a = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; b = _aidl_parcel.readTypedObject(android.aidl.tests.extension.MyExt.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; c = _aidl_parcel.readString(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; _mask |= describeContents(b); return _mask; } private int describeContents(Object _v) { if (_v == null) return 0; if (_v instanceof android.os.Parcelable) { return ((android.os.Parcelable) _v).describeContents(); } return 0; } } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_extension0100644 0000000 0000000 00000000034 15172120304 033312 xustar000000000 0000000 28 mtime=1776853188.4520000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/extension/MyExt2.java.d0100644 0000000 0000000 00000000403 15172120304 032365 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/extension/MyExt2.java : \ system/tools/aidl/tests/android/aidl/tests/extension/MyExt2.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_extension0100644 0000000 0000000 00000000034 15172120304 033312 xustar000000000 0000000 28 mtime=1776853188.4520000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/extension/MyExtLike.java0100644 0000000 0000000 00000004652 15172120304 032700 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/extension/MyExtLike.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExtLike.aidl */ package android.aidl.tests.extension; public class MyExtLike implements android.os.Parcelable { public int a = 0; public java.lang.String b; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public MyExtLike createFromParcel(android.os.Parcel _aidl_source) { MyExtLike _aidl_out = new MyExtLike(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public MyExtLike[] newArray(int _aidl_size) { return new MyExtLike[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(a); _aidl_parcel.writeString(b); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; a = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; b = _aidl_parcel.readString(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_extension0100644 0000000 0000000 00000000213 15172120304 033311 xustar000000000 0000000 111 path=tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/extension/MyExtLike.java.d 28 mtime=1776853188.4530000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/extension/MyExtLike.java.0100644 0000000 0000000 00000000305 15172120304 032745 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/extension/MyExtLike.java : \ system/tools/aidl/tests/android/aidl/tests/extension/MyExtLike.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_nested_0100644 0000000 0000000 00000000034 15172120304 032717 xustar000000000 0000000 28 mtime=1776853188.4530000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/nested/0040755 0000000 0000000 00000000000 15172120304 027424 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_nested_De0100644 0000000 0000000 00000000034 15172120304 033170 xustar000000000 0000000 28 mtime=1776853188.4530000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/nested/DeeplyNested.java0100644 0000000 0000000 00000021656 15172120304 032663 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/nested/DeeplyNested.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/DeeplyNested.aidl */ package android.aidl.tests.nested; public class DeeplyNested implements android.os.Parcelable { public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public DeeplyNested createFromParcel(android.os.Parcel _aidl_source) { DeeplyNested _aidl_out = new DeeplyNested(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public DeeplyNested[] newArray(int _aidl_size) { return new DeeplyNested[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } public static class A implements android.os.Parcelable { // Can reference deeply nested type of a sibling type. public byte e = android.aidl.tests.nested.DeeplyNested.B.C.D.E.OK; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public A createFromParcel(android.os.Parcel _aidl_source) { A _aidl_out = new A(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public A[] newArray(int _aidl_size) { return new A[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeByte(e); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; e = _aidl_parcel.readByte(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } } public static class B implements android.os.Parcelable { public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public B createFromParcel(android.os.Parcel _aidl_source) { B _aidl_out = new B(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public B[] newArray(int _aidl_size) { return new B[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } public static class C implements android.os.Parcelable { public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public C createFromParcel(android.os.Parcel _aidl_source) { C _aidl_out = new C(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public C[] newArray(int _aidl_size) { return new C[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } public static class D implements android.os.Parcelable { public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public D createFromParcel(android.os.Parcel _aidl_source) { D _aidl_out = new D(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public D[] newArray(int _aidl_size) { return new D[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } public static @interface E { public static final byte OK = 0; } } } } } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_nested_De0100644 0000000 0000000 00000000213 15172120304 033167 xustar000000000 0000000 111 path=tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/nested/DeeplyNested.java.d 28 mtime=1776853188.4530000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/nested/DeeplyNested.java.0100644 0000000 0000000 00000000305 15172120304 032725 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/nested/DeeplyNested.java : \ system/tools/aidl/tests/android/aidl/tests/nested/DeeplyNested.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_nested_IN0100644 0000000 0000000 00000000213 15172120304 033145 xustar000000000 0000000 111 path=tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/nested/INestedService.java 28 mtime=1776853188.4530000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/nested/INestedService.jav0100644 0000000 0000000 00000031702 15172120304 033002 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/nested/INestedService.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/INestedService.aidl */ package android.aidl.tests.nested; public interface INestedService extends android.os.IInterface { /** Default implementation for INestedService. */ public static class Default implements android.aidl.tests.nested.INestedService { @Override public android.aidl.tests.nested.INestedService.Result flipStatus(android.aidl.tests.nested.ParcelableWithNested p) throws android.os.RemoteException { return null; } @Override public void flipStatusWithCallback(byte status, android.aidl.tests.nested.INestedService.ICallback cb) throws android.os.RemoteException { } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.nested.INestedService { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.nested.INestedService interface, * generating a proxy if needed. */ public static android.aidl.tests.nested.INestedService asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.nested.INestedService))) { return ((android.aidl.tests.nested.INestedService)iin); } return new android.aidl.tests.nested.INestedService.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_flipStatus: { return "flipStatus"; } case TRANSACTION_flipStatusWithCallback: { return "flipStatusWithCallback"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_flipStatus: { android.aidl.tests.nested.ParcelableWithNested _arg0; _arg0 = data.readTypedObject(android.aidl.tests.nested.ParcelableWithNested.CREATOR); data.enforceNoDataAvail(); android.aidl.tests.nested.INestedService.Result _result = this.flipStatus(_arg0); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_flipStatusWithCallback: { byte _arg0; _arg0 = data.readByte(); android.aidl.tests.nested.INestedService.ICallback _arg1; _arg1 = android.aidl.tests.nested.INestedService.ICallback.Stub.asInterface(data.readStrongBinder()); data.enforceNoDataAvail(); this.flipStatusWithCallback(_arg0, _arg1); reply.writeNoException(); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.nested.INestedService { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public android.aidl.tests.nested.INestedService.Result flipStatus(android.aidl.tests.nested.ParcelableWithNested p) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.nested.INestedService.Result _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(p, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_flipStatus, _data, _reply, 0); _reply.readException(); _result = _reply.readTypedObject(android.aidl.tests.nested.INestedService.Result.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public void flipStatusWithCallback(byte status, android.aidl.tests.nested.INestedService.ICallback cb) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeByte(status); _data.writeStrongInterface(cb); boolean _status = mRemote.transact(Stub.TRANSACTION_flipStatusWithCallback, _data, _reply, 0); _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } } static final int TRANSACTION_flipStatus = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); static final int TRANSACTION_flipStatusWithCallback = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1); /** @hide */ public int getMaxTransactionId() { return 1; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.nested.INestedService"; public android.aidl.tests.nested.INestedService.Result flipStatus(android.aidl.tests.nested.ParcelableWithNested p) throws android.os.RemoteException; public void flipStatusWithCallback(byte status, android.aidl.tests.nested.INestedService.ICallback cb) throws android.os.RemoteException; public static class Result implements android.os.Parcelable { public byte status = android.aidl.tests.nested.ParcelableWithNested.Status.OK; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public Result createFromParcel(android.os.Parcel _aidl_source) { Result _aidl_out = new Result(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public Result[] newArray(int _aidl_size) { return new Result[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeByte(status); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; status = _aidl_parcel.readByte(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } } public interface ICallback extends android.os.IInterface { /** Default implementation for ICallback. */ public static class Default implements android.aidl.tests.nested.INestedService.ICallback { @Override public void done(byte status) throws android.os.RemoteException { } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.nested.INestedService.ICallback { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.nested.INestedService.ICallback interface, * generating a proxy if needed. */ public static android.aidl.tests.nested.INestedService.ICallback asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.nested.INestedService.ICallback))) { return ((android.aidl.tests.nested.INestedService.ICallback)iin); } return new android.aidl.tests.nested.INestedService.ICallback.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_done: { return "done"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_done: { byte _arg0; _arg0 = data.readByte(); data.enforceNoDataAvail(); this.done(_arg0); reply.writeNoException(); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.nested.INestedService.ICallback { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public void done(byte status) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeByte(status); boolean _status = mRemote.transact(Stub.TRANSACTION_done, _data, _reply, 0); _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } } static final int TRANSACTION_done = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.nested.INestedService.ICallback"; public void done(byte status) throws android.os.RemoteException; } } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_nested_IN0100644 0000000 0000000 00000000215 15172120304 033147 xustar000000000 0000000 113 path=tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/nested/INestedService.java.d 28 mtime=1776853188.4530000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/nested/INestedService.jav0100644 0000000 0000000 00000000431 15172120304 032775 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/nested/INestedService.java : \ system/tools/aidl/tests/android/aidl/tests/nested/INestedService.aidl \ system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_nested_Pa0100644 0000000 0000000 00000000221 15172120304 033176 xustar000000000 0000000 117 path=tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/nested/ParcelableWithNested.java 28 mtime=1776853188.4530000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/nested/ParcelableWithNest0100644 0000000 0000000 00000005021 15172120304 033062 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/nested/ParcelableWithNested.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl */ package android.aidl.tests.nested; public class ParcelableWithNested implements android.os.Parcelable { public byte status = android.aidl.tests.nested.ParcelableWithNested.Status.OK; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public ParcelableWithNested createFromParcel(android.os.Parcel _aidl_source) { ParcelableWithNested _aidl_out = new ParcelableWithNested(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public ParcelableWithNested[] newArray(int _aidl_size) { return new ParcelableWithNested[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeByte(status); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; status = _aidl_parcel.readByte(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } public static @interface Status { public static final byte OK = 0; public static final byte NOT_OK = 1; } } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_nested_Pa0100644 0000000 0000000 00000000223 15172120304 033200 xustar000000000 0000000 119 path=tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/nested/ParcelableWithNested.java.d 28 mtime=1776853188.4530000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/nested/ParcelableWithNest0100644 0000000 0000000 00000000325 15172120304 033064 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/nested/ParcelableWithNested.java : \ system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_unions_0100644 0000000 0000000 00000000034 15172120304 032750 xustar000000000 0000000 28 mtime=1776853188.4530000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/unions/0040755 0000000 0000000 00000000000 15172120304 027455 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_unions_En0100644 0000000 0000000 00000000034 15172120304 033233 xustar000000000 0000000 28 mtime=1776853188.4530000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/unions/EnumUnion.java0100644 0000000 0000000 00000012550 15172120304 032235 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/unions/EnumUnion.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl */ package android.aidl.tests.unions; public final class EnumUnion implements android.os.Parcelable { // tags for union fields public final static int intEnum = 0; // android.aidl.tests.IntEnum intEnum; public final static int longEnum = 1; // android.aidl.tests.LongEnum longEnum; public final static int deprecatedField = 2; // int deprecatedField; private int _tag; private Object _value; public EnumUnion() { int _value = android.aidl.tests.IntEnum.FOO; this._tag = intEnum; this._value = _value; } private EnumUnion(android.os.Parcel _aidl_parcel) { readFromParcel(_aidl_parcel); } private EnumUnion(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public int getTag() { return _tag; } // android.aidl.tests.IntEnum intEnum; public static EnumUnion intEnum(int _value) { return new EnumUnion(intEnum, _value); } public int getIntEnum() { _assertTag(intEnum); return (int) _value; } public void setIntEnum(int _value) { _set(intEnum, _value); } // android.aidl.tests.LongEnum longEnum; public static EnumUnion longEnum(long _value) { return new EnumUnion(longEnum, _value); } public long getLongEnum() { _assertTag(longEnum); return (long) _value; } public void setLongEnum(long _value) { _set(longEnum, _value); } // int deprecatedField; /** @deprecated do not use this */ @Deprecated public static EnumUnion deprecatedField(int _value) { return new EnumUnion(deprecatedField, _value); } public int getDeprecatedField() { _assertTag(deprecatedField); return (int) _value; } public void setDeprecatedField(int _value) { _set(deprecatedField, _value); } public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public EnumUnion createFromParcel(android.os.Parcel _aidl_source) { return new EnumUnion(_aidl_source); } @Override public EnumUnion[] newArray(int _aidl_size) { return new EnumUnion[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { _aidl_parcel.writeInt(_tag); switch (_tag) { case intEnum: _aidl_parcel.writeInt(getIntEnum()); break; case longEnum: _aidl_parcel.writeLong(getLongEnum()); break; case deprecatedField: _aidl_parcel.writeInt(getDeprecatedField()); break; } } public void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_tag; _aidl_tag = _aidl_parcel.readInt(); switch (_aidl_tag) { case intEnum: { int _aidl_value; _aidl_value = _aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } case longEnum: { long _aidl_value; _aidl_value = _aidl_parcel.readLong(); _set(_aidl_tag, _aidl_value); return; } case deprecatedField: { int _aidl_value; _aidl_value = _aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } } throw new IllegalArgumentException("union: unknown tag: " + _aidl_tag); } @Override public int describeContents() { int _mask = 0; switch (getTag()) { } return _mask; } @Override public String toString() { switch (_tag) { case intEnum: return "EnumUnion.intEnum(" + (android.aidl.tests.IntEnum.$.toString(getIntEnum())) + ")"; case longEnum: return "EnumUnion.longEnum(" + (getLongEnum()) + ")"; case deprecatedField: return "EnumUnion.deprecatedField(" + (getDeprecatedField()) + ")"; } throw new IllegalStateException("unknown field: " + _tag); } @Override public boolean equals(Object other) { if (this == other) return true; if (other == null) return false; if (!(other instanceof EnumUnion)) return false; EnumUnion that = (EnumUnion)other; if (_tag != that._tag) return false; if (!java.util.Objects.deepEquals(_value, that._value)) return false; return true; } @Override public int hashCode() { return java.util.Arrays.deepHashCode(java.util.Arrays.asList(_tag, _value).toArray()); } private void _assertTag(int tag) { if (getTag() != tag) { throw new IllegalStateException("bad access: " + _tagString(tag) + ", " + _tagString(getTag()) + " is available."); } } private String _tagString(int _tag) { switch (_tag) { case intEnum: return "intEnum"; case longEnum: return "longEnum"; case deprecatedField: return "deprecatedField"; } throw new IllegalStateException("unknown field: " + _tag); } private void _set(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public static @interface Tag { public static final int intEnum = 0; public static final int longEnum = 1; /** @deprecated do not use this */ @Deprecated public static final int deprecatedField = 2; } } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_unions_En0100644 0000000 0000000 00000000034 15172120304 033233 xustar000000000 0000000 28 mtime=1776853188.4540000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/unions/EnumUnion.java.d0100644 0000000 0000000 00000000470 15172120304 032455 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/unions/EnumUnion.java : \ system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_unions_Un0100644 0000000 0000000 00000000034 15172120304 033253 xustar000000000 0000000 28 mtime=1776853188.4540000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/unions/UnionInUnion.java0100644 0000000 0000000 00000011614 15172120304 032710 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/unions/UnionInUnion.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/UnionInUnion.aidl */ package android.aidl.tests.unions; public final class UnionInUnion implements android.os.Parcelable { // tags for union fields public final static int first = 0; // android.aidl.tests.unions.EnumUnion first; public final static int second = 1; // int second; private int _tag; private Object _value; public UnionInUnion() { android.aidl.tests.unions.EnumUnion _value = null; this._tag = first; this._value = _value; } private UnionInUnion(android.os.Parcel _aidl_parcel) { readFromParcel(_aidl_parcel); } private UnionInUnion(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public int getTag() { return _tag; } // android.aidl.tests.unions.EnumUnion first; public static UnionInUnion first(android.aidl.tests.unions.EnumUnion _value) { return new UnionInUnion(first, _value); } public android.aidl.tests.unions.EnumUnion getFirst() { _assertTag(first); return (android.aidl.tests.unions.EnumUnion) _value; } public void setFirst(android.aidl.tests.unions.EnumUnion _value) { _set(first, _value); } // int second; public static UnionInUnion second(int _value) { return new UnionInUnion(second, _value); } public int getSecond() { _assertTag(second); return (int) _value; } public void setSecond(int _value) { _set(second, _value); } public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public UnionInUnion createFromParcel(android.os.Parcel _aidl_source) { return new UnionInUnion(_aidl_source); } @Override public UnionInUnion[] newArray(int _aidl_size) { return new UnionInUnion[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { _aidl_parcel.writeInt(_tag); switch (_tag) { case first: _aidl_parcel.writeTypedObject(getFirst(), _aidl_flag); break; case second: _aidl_parcel.writeInt(getSecond()); break; } } public void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_tag; _aidl_tag = _aidl_parcel.readInt(); switch (_aidl_tag) { case first: { android.aidl.tests.unions.EnumUnion _aidl_value; _aidl_value = _aidl_parcel.readTypedObject(android.aidl.tests.unions.EnumUnion.CREATOR); _set(_aidl_tag, _aidl_value); return; } case second: { int _aidl_value; _aidl_value = _aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } } throw new IllegalArgumentException("union: unknown tag: " + _aidl_tag); } @Override public int describeContents() { int _mask = 0; switch (getTag()) { case first: _mask |= describeContents(getFirst()); break; } return _mask; } private int describeContents(Object _v) { if (_v == null) return 0; if (_v instanceof android.os.Parcelable) { return ((android.os.Parcelable) _v).describeContents(); } return 0; } @Override public String toString() { switch (_tag) { case first: return "UnionInUnion.first(" + (java.util.Objects.toString(getFirst())) + ")"; case second: return "UnionInUnion.second(" + (getSecond()) + ")"; } throw new IllegalStateException("unknown field: " + _tag); } @Override public boolean equals(Object other) { if (this == other) return true; if (other == null) return false; if (!(other instanceof UnionInUnion)) return false; UnionInUnion that = (UnionInUnion)other; if (_tag != that._tag) return false; if (!java.util.Objects.deepEquals(_value, that._value)) return false; return true; } @Override public int hashCode() { return java.util.Arrays.deepHashCode(java.util.Arrays.asList(_tag, _value).toArray()); } private void _assertTag(int tag) { if (getTag() != tag) { throw new IllegalStateException("bad access: " + _tagString(tag) + ", " + _tagString(getTag()) + " is available."); } } private String _tagString(int _tag) { switch (_tag) { case first: return "first"; case second: return "second"; } throw new IllegalStateException("unknown field: " + _tag); } private void _set(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public static @interface Tag { public static final int first = 0; public static final int second = 1; } } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_android_aidl_tests_unions_Un0100644 0000000 0000000 00000000213 15172120304 033252 xustar000000000 0000000 111 path=tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/unions/UnionInUnion.java.d 28 mtime=1776853188.4540000 tests/golden_output/aidl-test-interface-java-source/gen/android/aidl/tests/unions/UnionInUnion.java.0100644 0000000 0000000 00000000603 15172120304 032762 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/unions/UnionInUnion.java : \ system/tools/aidl/tests/android/aidl/tests/unions/UnionInUnion.aidl \ system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-java-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 027366 xustar000000000 0000000 28 mtime=1776853188.4540000 tests/golden_output/aidl-test-interface-java-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 024360 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_0100644 0000000 0000000 00000000034 15172120304 024444 xustar000000000 0000000 28 mtime=1776853188.4540000 tests/golden_output/aidl-test-interface-ndk-source/0040755 0000000 0000000 00000000000 15172120304 021531 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_0100644 0000000 0000000 00000000034 15172120304 025275 xustar000000000 0000000 28 mtime=1776853188.4540000 tests/golden_output/aidl-test-interface-ndk-source/gen/0040755 0000000 0000000 00000000000 15172120304 022302 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 026775 xustar000000000 0000000 28 mtime=1776853188.4540000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 023722 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 027766 xustar000000000 0000000 28 mtime=1776853188.4540000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 024633 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_0100644 0000000 0000000 00000000034 15172120304 031210 xustar000000000 0000000 28 mtime=1776853188.4540000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/0040755 0000000 0000000 00000000000 15172120304 025775 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_ArrayOfInt0100644 0000000 0000000 00000000034 15172120304 033147 xustar000000000 0000000 28 mtime=1776853188.4560000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/ArrayOfInterfaces.cpp0100644 0000000 0000000 00000064050 15172120304 032052 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ArrayOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ArrayOfInterfaces.aidl */ #include "aidl/android/aidl/tests/ArrayOfInterfaces.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { const char* ArrayOfInterfaces::descriptor = "android.aidl.tests.ArrayOfInterfaces"; binder_status_t ArrayOfInterfaces::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t ArrayOfInterfaces::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { static binder_status_t _aidl_android_aidl_tests_ArrayOfInterfaces_IEmptyInterface_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; (void)_aidl_binder; (void)_aidl_code; return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_tests_ArrayOfInterfaces_IEmptyInterface_clazz = ::ndk::ICInterface::defineClass(ArrayOfInterfaces::IEmptyInterface::descriptor, _aidl_android_aidl_tests_ArrayOfInterfaces_IEmptyInterface_onTransact); ArrayOfInterfaces::BpEmptyInterface::BpEmptyInterface(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} ArrayOfInterfaces::BpEmptyInterface::~BpEmptyInterface() {} // Source for BnEmptyInterface ArrayOfInterfaces::BnEmptyInterface::BnEmptyInterface() {} ArrayOfInterfaces::BnEmptyInterface::~BnEmptyInterface() {} ::ndk::SpAIBinder ArrayOfInterfaces::BnEmptyInterface::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_tests_ArrayOfInterfaces_IEmptyInterface_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for IEmptyInterface const char* ArrayOfInterfaces::IEmptyInterface::descriptor = "android.aidl.tests.ArrayOfInterfaces.IEmptyInterface"; ArrayOfInterfaces::IEmptyInterface::IEmptyInterface() {} ArrayOfInterfaces::IEmptyInterface::~IEmptyInterface() {} std::shared_ptr ArrayOfInterfaces::IEmptyInterface::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_tests_ArrayOfInterfaces_IEmptyInterface_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t ArrayOfInterfaces::IEmptyInterface::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t ArrayOfInterfaces::IEmptyInterface::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = IEmptyInterface::fromBinder(binder); return STATUS_OK; } bool ArrayOfInterfaces::IEmptyInterface::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!IEmptyInterface::default_impl); if (impl) { IEmptyInterface::default_impl = impl; return true; } return false; } const std::shared_ptr& ArrayOfInterfaces::IEmptyInterface::getDefaultImpl() { return IEmptyInterface::default_impl; } std::shared_ptr ArrayOfInterfaces::IEmptyInterface::default_impl = nullptr; ::ndk::SpAIBinder ArrayOfInterfaces::IEmptyInterfaceDefault::asBinder() { return ::ndk::SpAIBinder(); } bool ArrayOfInterfaces::IEmptyInterfaceDefault::isRemote() { return false; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { static binder_status_t _aidl_android_aidl_tests_ArrayOfInterfaces_IMyInterface_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*methodWithInterfaces*/): { std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface> in_iface; std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface> in_nullable_iface; std::vector> in_iface_array_in; std::vector> out_iface_array_out; std::vector> in_iface_array_inout; std::optional>> in_nullable_iface_array_in; std::optional>> out_nullable_iface_array_out; std::optional>> in_nullable_iface_array_inout; std::optional>> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_iface); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_nullable_iface); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_iface_array_in); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_iface_array_out); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_iface_array_inout); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_nullable_iface_array_in); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_nullable_iface_array_out); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_nullable_iface_array_inout); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->methodWithInterfaces(in_iface, in_nullable_iface, in_iface_array_in, &out_iface_array_out, &in_iface_array_inout, in_nullable_iface_array_in, &out_nullable_iface_array_out, &in_nullable_iface_array_inout, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_iface_array_out); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, in_iface_array_inout); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, out_nullable_iface_array_out); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, in_nullable_iface_array_inout); if (_aidl_ret_status != STATUS_OK) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_tests_ArrayOfInterfaces_IMyInterface_clazz = ::ndk::ICInterface::defineClass(ArrayOfInterfaces::IMyInterface::descriptor, _aidl_android_aidl_tests_ArrayOfInterfaces_IMyInterface_onTransact); ArrayOfInterfaces::BpMyInterface::BpMyInterface(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} ArrayOfInterfaces::BpMyInterface::~BpMyInterface() {} ::ndk::ScopedAStatus ArrayOfInterfaces::BpMyInterface::methodWithInterfaces(const std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& in_iface, const std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& in_nullable_iface, const std::vector>& in_iface_array_in, std::vector>* out_iface_array_out, std::vector>* in_iface_array_inout, const std::optional>>& in_nullable_iface_array_in, std::optional>>* out_nullable_iface_array_out, std::optional>>* in_nullable_iface_array_inout, std::optional>>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_iface); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_nullable_iface); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_iface_array_in); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_iface_array_out); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), *in_iface_array_inout); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_nullable_iface_array_in); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_nullable_iface_array_out); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), *in_nullable_iface_array_inout); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*methodWithInterfaces*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IMyInterface::getDefaultImpl()) { _aidl_status = IMyInterface::getDefaultImpl()->methodWithInterfaces(in_iface, in_nullable_iface, in_iface_array_in, out_iface_array_out, in_iface_array_inout, in_nullable_iface_array_in, out_nullable_iface_array_out, in_nullable_iface_array_inout, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_iface_array_out); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), in_iface_array_inout); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), out_nullable_iface_array_out); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), in_nullable_iface_array_inout); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } // Source for BnMyInterface ArrayOfInterfaces::BnMyInterface::BnMyInterface() {} ArrayOfInterfaces::BnMyInterface::~BnMyInterface() {} ::ndk::SpAIBinder ArrayOfInterfaces::BnMyInterface::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_tests_ArrayOfInterfaces_IMyInterface_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for IMyInterface const char* ArrayOfInterfaces::IMyInterface::descriptor = "android.aidl.tests.ArrayOfInterfaces.IMyInterface"; ArrayOfInterfaces::IMyInterface::IMyInterface() {} ArrayOfInterfaces::IMyInterface::~IMyInterface() {} std::shared_ptr ArrayOfInterfaces::IMyInterface::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_tests_ArrayOfInterfaces_IMyInterface_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t ArrayOfInterfaces::IMyInterface::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t ArrayOfInterfaces::IMyInterface::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = IMyInterface::fromBinder(binder); return STATUS_OK; } bool ArrayOfInterfaces::IMyInterface::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!IMyInterface::default_impl); if (impl) { IMyInterface::default_impl = impl; return true; } return false; } const std::shared_ptr& ArrayOfInterfaces::IMyInterface::getDefaultImpl() { return IMyInterface::default_impl; } std::shared_ptr ArrayOfInterfaces::IMyInterface::default_impl = nullptr; ::ndk::ScopedAStatus ArrayOfInterfaces::IMyInterfaceDefault::methodWithInterfaces(const std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& /*in_iface*/, const std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& /*in_nullable_iface*/, const std::vector>& /*in_iface_array_in*/, std::vector>* /*out_iface_array_out*/, std::vector>* /*in_iface_array_inout*/, const std::optional>>& /*in_nullable_iface_array_in*/, std::optional>>* /*out_nullable_iface_array_out*/, std::optional>>* /*in_nullable_iface_array_inout*/, std::optional>>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::SpAIBinder ArrayOfInterfaces::IMyInterfaceDefault::asBinder() { return ::ndk::SpAIBinder(); } bool ArrayOfInterfaces::IMyInterfaceDefault::isRemote() { return false; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { const char* ArrayOfInterfaces::MyParcelable::descriptor = "android.aidl.tests.ArrayOfInterfaces.MyParcelable"; binder_status_t ArrayOfInterfaces::MyParcelable::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &iface); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &nullable_iface); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &iface_array); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &nullable_iface_array); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t ArrayOfInterfaces::MyParcelable::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, iface); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, nullable_iface); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, iface_array); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, nullable_iface_array); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { const char* ArrayOfInterfaces::MyUnion::descriptor = "android.aidl.tests.ArrayOfInterfaces.MyUnion"; binder_status_t ArrayOfInterfaces::MyUnion::readFromParcel(const AParcel* _parcel) { binder_status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_tag)) != STATUS_OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case iface: { std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface> _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case nullable_iface: { std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface> _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readNullableData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case iface_array: { std::vector> _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v>>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case nullable_iface_array: { std::optional>> _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readNullableData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v>>>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } } return STATUS_BAD_VALUE; } binder_status_t ArrayOfInterfaces::MyUnion::writeToParcel(AParcel* _parcel) const { binder_status_t _aidl_ret_status = ::ndk::AParcel_writeData(_parcel, static_cast(getTag())); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; switch (getTag()) { case iface: return ::ndk::AParcel_writeData(_parcel, get()); case nullable_iface: return ::ndk::AParcel_writeNullableData(_parcel, get()); case iface_array: return ::ndk::AParcel_writeData(_parcel, get()); case nullable_iface_array: return ::ndk::AParcel_writeNullableData(_parcel, get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_ArrayOfInt0100644 0000000 0000000 00000000034 15172120304 033147 xustar000000000 0000000 28 mtime=1776853188.4560000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/ArrayOfInterfaces.cpp.d0100644 0000000 0000000 00000000277 15172120304 032275 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/ArrayOfInterfaces.cpp : \ system/tools/aidl/tests/android/aidl/tests/ArrayOfInterfaces.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_BackendTyp0100644 0000000 0000000 00000000034 15172120304 033155 xustar000000000 0000000 28 mtime=1776853188.4560000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/BackendType.cpp0100644 0000000 0000000 00000001236 15172120304 030671 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/BackendType.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/BackendType.aidl */ // This file is intentionally left blank as placeholder for enum declaration. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_BackendTyp0100644 0000000 0000000 00000000034 15172120304 033155 xustar000000000 0000000 28 mtime=1776853188.4560000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/BackendType.cpp.d0100644 0000000 0000000 00000000263 15172120304 031112 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/BackendType.cpp : \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_ByteEnum.c0100644 0000000 0000000 00000000034 15172120304 033102 xustar000000000 0000000 28 mtime=1776853188.4560000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/ByteEnum.cpp0100644 0000000 0000000 00000001230 15172120304 030222 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ByteEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl */ // This file is intentionally left blank as placeholder for enum declaration. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_ByteEnum.c0100644 0000000 0000000 00000000034 15172120304 033102 xustar000000000 0000000 28 mtime=1776853188.4560000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/ByteEnum.cpp.d0100644 0000000 0000000 00000000255 15172120304 030452 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/ByteEnum.cpp : \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_CircularPa0100644 0000000 0000000 00000000034 15172120304 033156 xustar000000000 0000000 28 mtime=1776853188.4560000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/CircularParcelable.cpp0100644 0000000 0000000 00000006477 15172120304 032233 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/CircularParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl */ #include "aidl/android/aidl/tests/CircularParcelable.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace aidl { namespace android { namespace aidl { namespace tests { const char* CircularParcelable::descriptor = "android.aidl.tests.CircularParcelable"; binder_status_t CircularParcelable::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &testService); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t CircularParcelable::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, testService); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_CircularPa0100644 0000000 0000000 00000000034 15172120304 033156 xustar000000000 0000000 28 mtime=1776853188.4560000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/CircularParcelable.cpp.d0100644 0000000 0000000 00000002233 15172120304 032437 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/CircularParcelable.cpp : \ system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ITestService.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl \ system/tools/aidl/tests/android/aidl/tests/SimpleParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl \ system/tools/aidl/tests/android/aidl/tests/ICircular.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_ConstantEx0100644 0000000 0000000 00000000212 15172120304 033215 xustar000000000 0000000 110 path=tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/ConstantExpressionEnum.cpp 28 mtime=1776853188.4560000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/ConstantExpressionEnum.cpp0100644 0000000 0000000 00000001264 15172120304 033177 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ConstantExpressionEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl */ // This file is intentionally left blank as placeholder for enum declaration. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_ConstantEx0100644 0000000 0000000 00000000214 15172120304 033217 xustar000000000 0000000 112 path=tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/ConstantExpressionEnum.cpp.d 28 mtime=1776853188.4560000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/ConstantExpressionEnum.cpp0100644 0000000 0000000 00000000311 15172120304 033167 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/ConstantExpressionEnum.cpp : \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_Deprecated0100644 0000000 0000000 00000000034 15172120304 033171 xustar000000000 0000000 28 mtime=1776853188.4560000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/DeprecatedEnum.cpp0100644 0000000 0000000 00000001244 15172120304 031364 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/DeprecatedEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedEnum.aidl */ // This file is intentionally left blank as placeholder for enum declaration. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_Deprecated0100644 0000000 0000000 00000000034 15172120304 033171 xustar000000000 0000000 28 mtime=1776853188.4570000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/DeprecatedEnum.cpp.d0100644 0000000 0000000 00000000271 15172120304 031605 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/DeprecatedEnum.cpp : \ system/tools/aidl/tests/android/aidl/tests/DeprecatedEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_Deprecated0100644 0000000 0000000 00000000034 15172120304 033171 xustar000000000 0000000 28 mtime=1776853188.4570000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/DeprecatedParcelable.cpp0100644 0000000 0000000 00000004177 15172120304 032522 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/DeprecatedParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedParcelable.aidl */ #include "aidl/android/aidl/tests/DeprecatedParcelable.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { const char* DeprecatedParcelable::descriptor = "android.aidl.tests.DeprecatedParcelable"; binder_status_t DeprecatedParcelable::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t DeprecatedParcelable::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_Deprecated0100644 0000000 0000000 00000000212 15172120304 033167 xustar000000000 0000000 110 path=tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/DeprecatedParcelable.cpp.d 28 mtime=1776853188.4570000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/DeprecatedParcelable.cpp.d0100644 0000000 0000000 00000000305 15172120304 032731 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/DeprecatedParcelable.cpp : \ system/tools/aidl/tests/android/aidl/tests/DeprecatedParcelable.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_FixedSize.0100644 0000000 0000000 00000000034 15172120304 033101 xustar000000000 0000000 28 mtime=1776853188.4570000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/FixedSize.cpp0100644 0000000 0000000 00000030611 15172120304 030371 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/FixedSize.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/FixedSize.aidl */ #include "aidl/android/aidl/tests/FixedSize.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { const char* FixedSize::descriptor = "android.aidl.tests.FixedSize"; binder_status_t FixedSize::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t FixedSize::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { const char* FixedSize::FixedParcelable::descriptor = "android.aidl.tests.FixedSize.FixedParcelable"; binder_status_t FixedSize::FixedParcelable::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &booleanValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &byteValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &charValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &intValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &longValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &floatValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &doubleValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &enumValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &parcelableValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t FixedSize::FixedParcelable::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, booleanValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, byteValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, charValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, intValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, longValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, floatValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, doubleValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, enumValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, parcelableValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { const char* FixedSize::FixedUnion::descriptor = "android.aidl.tests.FixedSize.FixedUnion"; binder_status_t FixedSize::FixedUnion::readFromParcel(const AParcel* _parcel) { binder_status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_tag)) != STATUS_OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case booleanValue: { bool _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case byteValue: { int8_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case charValue: { char16_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case intValue: { int32_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case longValue: { int64_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case floatValue: { float _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case doubleValue: { double _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case enumValue: { ::aidl::android::aidl::tests::LongEnum _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::aidl::android::aidl::tests::LongEnum>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } } return STATUS_BAD_VALUE; } binder_status_t FixedSize::FixedUnion::writeToParcel(AParcel* _parcel) const { binder_status_t _aidl_ret_status = ::ndk::AParcel_writeData(_parcel, static_cast(getTag())); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; switch (getTag()) { case booleanValue: return ::ndk::AParcel_writeData(_parcel, get()); case byteValue: return ::ndk::AParcel_writeData(_parcel, get()); case charValue: return ::ndk::AParcel_writeData(_parcel, get()); case intValue: return ::ndk::AParcel_writeData(_parcel, get()); case longValue: return ::ndk::AParcel_writeData(_parcel, get()); case floatValue: return ::ndk::AParcel_writeData(_parcel, get()); case doubleValue: return ::ndk::AParcel_writeData(_parcel, get()); case enumValue: return ::ndk::AParcel_writeData(_parcel, get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_FixedSize.0100644 0000000 0000000 00000000034 15172120304 033101 xustar000000000 0000000 28 mtime=1776853188.4570000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/FixedSize.cpp.d0100644 0000000 0000000 00000000354 15172120304 030614 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/FixedSize.cpp : \ system/tools/aidl/tests/android/aidl/tests/FixedSize.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_GenericStr0100644 0000000 0000000 00000000217 15172120304 033201 xustar000000000 0000000 115 path=tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/GenericStructuredParcelable.cpp 28 mtime=1776853188.4570000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/GenericStructuredParcelabl0100644 0000000 0000000 00000001160 15172120304 033162 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/GenericStructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl */ ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_GenericStr0100644 0000000 0000000 00000000221 15172120304 033174 xustar000000000 0000000 117 path=tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/GenericStructuredParcelable.cpp.d 28 mtime=1776853188.4570000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/GenericStructuredParcelabl0100644 0000000 0000000 00000000323 15172120304 033162 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/GenericStructuredParcelable.cpp : \ system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_ICircular.0100644 0000000 0000000 00000000034 15172120304 033064 xustar000000000 0000000 28 mtime=1776853188.4570000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/ICircular.cpp0100644 0000000 0000000 00000015513 15172120304 030360 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ICircular.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ICircular.aidl */ #include "aidl/android/aidl/tests/ICircular.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace aidl { namespace android { namespace aidl { namespace tests { static binder_status_t _aidl_android_aidl_tests_ICircular_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*GetTestService*/): { std::shared_ptr<::aidl::android::aidl::tests::ITestService> _aidl_return; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->GetTestService(&_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_tests_ICircular_clazz = ::ndk::ICInterface::defineClass(ICircular::descriptor, _aidl_android_aidl_tests_ICircular_onTransact); BpCircular::BpCircular(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} BpCircular::~BpCircular() {} ::ndk::ScopedAStatus BpCircular::GetTestService(std::shared_ptr<::aidl::android::aidl::tests::ITestService>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*GetTestService*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ICircular::getDefaultImpl()) { _aidl_status = ICircular::getDefaultImpl()->GetTestService(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } // Source for BnCircular BnCircular::BnCircular() {} BnCircular::~BnCircular() {} ::ndk::SpAIBinder BnCircular::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_tests_ICircular_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for ICircular const char* ICircular::descriptor = "android.aidl.tests.ICircular"; ICircular::ICircular() {} ICircular::~ICircular() {} std::shared_ptr ICircular::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_tests_ICircular_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t ICircular::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t ICircular::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = ICircular::fromBinder(binder); return STATUS_OK; } bool ICircular::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!ICircular::default_impl); if (impl) { ICircular::default_impl = impl; return true; } return false; } const std::shared_ptr& ICircular::getDefaultImpl() { return ICircular::default_impl; } std::shared_ptr ICircular::default_impl = nullptr; ::ndk::ScopedAStatus ICircularDefault::GetTestService(std::shared_ptr<::aidl::android::aidl::tests::ITestService>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::SpAIBinder ICircularDefault::asBinder() { return ::ndk::SpAIBinder(); } bool ICircularDefault::isRemote() { return false; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_ICircular.0100644 0000000 0000000 00000000034 15172120304 033064 xustar000000000 0000000 28 mtime=1776853188.4570000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/ICircular.cpp.d0100644 0000000 0000000 00000002222 15172120304 030573 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/ICircular.cpp : \ system/tools/aidl/tests/android/aidl/tests/ICircular.aidl \ system/tools/aidl/tests/android/aidl/tests/ITestService.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl \ system/tools/aidl/tests/android/aidl/tests/SimpleParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl \ system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_IDeprecate0100644 0000000 0000000 00000000034 15172120304 033136 xustar000000000 0000000 28 mtime=1776853188.4580000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/IDeprecated.cpp0100644 0000000 0000000 00000010224 15172120304 030646 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/IDeprecated.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IDeprecated.aidl */ #include "aidl/android/aidl/tests/IDeprecated.h" #include #include #include namespace aidl { namespace android { namespace aidl { namespace tests { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated" static binder_status_t _aidl_android_aidl_tests_IDeprecated_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; (void)_aidl_binder; (void)_aidl_code; return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_tests_IDeprecated_clazz = ::ndk::ICInterface::defineClass(IDeprecated::descriptor, _aidl_android_aidl_tests_IDeprecated_onTransact); #pragma clang diagnostic pop BpDeprecated::BpDeprecated(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} BpDeprecated::~BpDeprecated() {} // Source for BnDeprecated BnDeprecated::BnDeprecated() {} BnDeprecated::~BnDeprecated() {} ::ndk::SpAIBinder BnDeprecated::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_tests_IDeprecated_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for IDeprecated const char* IDeprecated::descriptor = "android.aidl.tests.IDeprecated"; IDeprecated::IDeprecated() {} IDeprecated::~IDeprecated() {} std::shared_ptr IDeprecated::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_tests_IDeprecated_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t IDeprecated::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t IDeprecated::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = IDeprecated::fromBinder(binder); return STATUS_OK; } bool IDeprecated::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!IDeprecated::default_impl); if (impl) { IDeprecated::default_impl = impl; return true; } return false; } const std::shared_ptr& IDeprecated::getDefaultImpl() { return IDeprecated::default_impl; } std::shared_ptr IDeprecated::default_impl = nullptr; ::ndk::SpAIBinder IDeprecatedDefault::asBinder() { return ::ndk::SpAIBinder(); } bool IDeprecatedDefault::isRemote() { return false; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_IDeprecate0100644 0000000 0000000 00000000034 15172120304 033136 xustar000000000 0000000 28 mtime=1776853188.4580000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/IDeprecated.cpp.d0100644 0000000 0000000 00000000263 15172120304 031072 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/IDeprecated.cpp : \ system/tools/aidl/tests/android/aidl/tests/IDeprecated.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_INamedCall0100644 0000000 0000000 00000000034 15172120304 033062 xustar000000000 0000000 28 mtime=1776853188.4580000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/INamedCallback.cpp0100644 0000000 0000000 00000014506 15172120304 031256 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/INamedCallback.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl */ #include "aidl/android/aidl/tests/INamedCallback.h" #include #include #include namespace aidl { namespace android { namespace aidl { namespace tests { static binder_status_t _aidl_android_aidl_tests_INamedCallback_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*GetName*/): { std::string _aidl_return; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->GetName(&_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_tests_INamedCallback_clazz = ::ndk::ICInterface::defineClass(INamedCallback::descriptor, _aidl_android_aidl_tests_INamedCallback_onTransact); BpNamedCallback::BpNamedCallback(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} BpNamedCallback::~BpNamedCallback() {} ::ndk::ScopedAStatus BpNamedCallback::GetName(std::string* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*GetName*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && INamedCallback::getDefaultImpl()) { _aidl_status = INamedCallback::getDefaultImpl()->GetName(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } // Source for BnNamedCallback BnNamedCallback::BnNamedCallback() {} BnNamedCallback::~BnNamedCallback() {} ::ndk::SpAIBinder BnNamedCallback::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_tests_INamedCallback_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for INamedCallback const char* INamedCallback::descriptor = "android.aidl.tests.INamedCallback"; INamedCallback::INamedCallback() {} INamedCallback::~INamedCallback() {} std::shared_ptr INamedCallback::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_tests_INamedCallback_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t INamedCallback::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t INamedCallback::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = INamedCallback::fromBinder(binder); return STATUS_OK; } bool INamedCallback::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!INamedCallback::default_impl); if (impl) { INamedCallback::default_impl = impl; return true; } return false; } const std::shared_ptr& INamedCallback::getDefaultImpl() { return INamedCallback::default_impl; } std::shared_ptr INamedCallback::default_impl = nullptr; ::ndk::ScopedAStatus INamedCallbackDefault::GetName(std::string* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::SpAIBinder INamedCallbackDefault::asBinder() { return ::ndk::SpAIBinder(); } bool INamedCallbackDefault::isRemote() { return false; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_INamedCall0100644 0000000 0000000 00000000034 15172120304 033062 xustar000000000 0000000 28 mtime=1776853188.4580000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/INamedCallback.cpp.d0100644 0000000 0000000 00000000271 15172120304 031472 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/INamedCallback.cpp : \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_INewName.c0100644 0000000 0000000 00000000034 15172120304 033015 xustar000000000 0000000 28 mtime=1776853188.4580000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/INewName.cpp0100644 0000000 0000000 00000014002 15172120304 030136 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/INewName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INewName.aidl */ #include "aidl/android/aidl/tests/INewName.h" #include #include #include namespace aidl { namespace android { namespace aidl { namespace tests { static binder_status_t _aidl_android_aidl_tests_INewName_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*RealName*/): { std::string _aidl_return; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RealName(&_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_tests_INewName_clazz = ::ndk::ICInterface::defineClass(INewName::descriptor, _aidl_android_aidl_tests_INewName_onTransact); BpNewName::BpNewName(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} BpNewName::~BpNewName() {} ::ndk::ScopedAStatus BpNewName::RealName(std::string* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*RealName*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && INewName::getDefaultImpl()) { _aidl_status = INewName::getDefaultImpl()->RealName(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } // Source for BnNewName BnNewName::BnNewName() {} BnNewName::~BnNewName() {} ::ndk::SpAIBinder BnNewName::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_tests_INewName_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for INewName const char* INewName::descriptor = "android.aidl.tests.IOldName"; INewName::INewName() {} INewName::~INewName() {} std::shared_ptr INewName::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_tests_INewName_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t INewName::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t INewName::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = INewName::fromBinder(binder); return STATUS_OK; } bool INewName::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!INewName::default_impl); if (impl) { INewName::default_impl = impl; return true; } return false; } const std::shared_ptr& INewName::getDefaultImpl() { return INewName::default_impl; } std::shared_ptr INewName::default_impl = nullptr; ::ndk::ScopedAStatus INewNameDefault::RealName(std::string* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::SpAIBinder INewNameDefault::asBinder() { return ::ndk::SpAIBinder(); } bool INewNameDefault::isRemote() { return false; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_INewName.c0100644 0000000 0000000 00000000034 15172120304 033015 xustar000000000 0000000 28 mtime=1776853188.4580000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/INewName.cpp.d0100644 0000000 0000000 00000000255 15172120304 030365 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/INewName.cpp : \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_IOldName.c0100644 0000000 0000000 00000000034 15172120304 033002 xustar000000000 0000000 28 mtime=1776853188.4580000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/IOldName.cpp0100644 0000000 0000000 00000014002 15172120304 030123 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/IOldName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IOldName.aidl */ #include "aidl/android/aidl/tests/IOldName.h" #include #include #include namespace aidl { namespace android { namespace aidl { namespace tests { static binder_status_t _aidl_android_aidl_tests_IOldName_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*RealName*/): { std::string _aidl_return; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RealName(&_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_tests_IOldName_clazz = ::ndk::ICInterface::defineClass(IOldName::descriptor, _aidl_android_aidl_tests_IOldName_onTransact); BpOldName::BpOldName(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} BpOldName::~BpOldName() {} ::ndk::ScopedAStatus BpOldName::RealName(std::string* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*RealName*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IOldName::getDefaultImpl()) { _aidl_status = IOldName::getDefaultImpl()->RealName(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } // Source for BnOldName BnOldName::BnOldName() {} BnOldName::~BnOldName() {} ::ndk::SpAIBinder BnOldName::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_tests_IOldName_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for IOldName const char* IOldName::descriptor = "android.aidl.tests.IOldName"; IOldName::IOldName() {} IOldName::~IOldName() {} std::shared_ptr IOldName::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_tests_IOldName_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t IOldName::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t IOldName::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = IOldName::fromBinder(binder); return STATUS_OK; } bool IOldName::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!IOldName::default_impl); if (impl) { IOldName::default_impl = impl; return true; } return false; } const std::shared_ptr& IOldName::getDefaultImpl() { return IOldName::default_impl; } std::shared_ptr IOldName::default_impl = nullptr; ::ndk::ScopedAStatus IOldNameDefault::RealName(std::string* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::SpAIBinder IOldNameDefault::asBinder() { return ::ndk::SpAIBinder(); } bool IOldNameDefault::isRemote() { return false; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_IOldName.c0100644 0000000 0000000 00000000034 15172120304 033002 xustar000000000 0000000 28 mtime=1776853188.4590000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/IOldName.cpp.d0100644 0000000 0000000 00000000255 15172120304 030352 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/IOldName.cpp : \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_ITestServi0100644 0000000 0000000 00000000034 15172120304 033172 xustar000000000 0000000 28 mtime=1776853188.4590000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/ITestService.cpp0100644 0000000 0000000 00000721650 15172120304 031062 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ITestService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ITestService.aidl */ #include "aidl/android/aidl/tests/ITestService.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace aidl { namespace android { namespace aidl { namespace tests { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated" static binder_status_t _aidl_android_aidl_tests_ITestService_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*UnimplementedMethod*/): { int32_t in_arg; int32_t _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_arg); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->UnimplementedMethod(in_arg, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 1 /*Deprecated*/): { ::ndk::ScopedAStatus _aidl_status = _aidl_impl->Deprecated(); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } case (FIRST_CALL_TRANSACTION + 2 /*TestOneway*/): { ::ndk::ScopedAStatus _aidl_status = _aidl_impl->TestOneway(); _aidl_ret_status = STATUS_OK; break; } case (FIRST_CALL_TRANSACTION + 3 /*RepeatBoolean*/): { bool in_token; bool _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_token); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatBoolean(in_token, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 4 /*RepeatByte*/): { int8_t in_token; int8_t _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_token); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatByte(in_token, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 5 /*RepeatChar*/): { char16_t in_token; char16_t _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_token); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatChar(in_token, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 6 /*RepeatInt*/): { int32_t in_token; int32_t _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_token); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatInt(in_token, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 7 /*RepeatLong*/): { int64_t in_token; int64_t _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_token); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatLong(in_token, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 8 /*RepeatFloat*/): { float in_token; float _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_token); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatFloat(in_token, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 9 /*RepeatDouble*/): { double in_token; double _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_token); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatDouble(in_token, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 10 /*RepeatString*/): { std::string in_token; std::string _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_token); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatString(in_token, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 11 /*RepeatByteEnum*/): { ::aidl::android::aidl::tests::ByteEnum in_token; ::aidl::android::aidl::tests::ByteEnum _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_token); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatByteEnum(in_token, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 12 /*RepeatIntEnum*/): { ::aidl::android::aidl::tests::IntEnum in_token; ::aidl::android::aidl::tests::IntEnum _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_token); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatIntEnum(in_token, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 13 /*RepeatLongEnum*/): { ::aidl::android::aidl::tests::LongEnum in_token; ::aidl::android::aidl::tests::LongEnum _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_token); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatLongEnum(in_token, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 14 /*ReverseBoolean*/): { std::vector in_input; std::vector out_repeated; std::vector _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_repeated); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseBoolean(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 15 /*ReverseByte*/): { std::vector in_input; std::vector out_repeated; std::vector _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_repeated); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseByte(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 16 /*ReverseChar*/): { std::vector in_input; std::vector out_repeated; std::vector _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_repeated); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseChar(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 17 /*ReverseInt*/): { std::vector in_input; std::vector out_repeated; std::vector _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_repeated); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseInt(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 18 /*ReverseLong*/): { std::vector in_input; std::vector out_repeated; std::vector _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_repeated); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseLong(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 19 /*ReverseFloat*/): { std::vector in_input; std::vector out_repeated; std::vector _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_repeated); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseFloat(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 20 /*ReverseDouble*/): { std::vector in_input; std::vector out_repeated; std::vector _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_repeated); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseDouble(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 21 /*ReverseString*/): { std::vector in_input; std::vector out_repeated; std::vector _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_repeated); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseString(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 22 /*ReverseByteEnum*/): { std::vector<::aidl::android::aidl::tests::ByteEnum> in_input; std::vector<::aidl::android::aidl::tests::ByteEnum> out_repeated; std::vector<::aidl::android::aidl::tests::ByteEnum> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_repeated); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseByteEnum(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 23 /*ReverseIntEnum*/): { std::vector<::aidl::android::aidl::tests::IntEnum> in_input; std::vector<::aidl::android::aidl::tests::IntEnum> out_repeated; std::vector<::aidl::android::aidl::tests::IntEnum> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_repeated); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseIntEnum(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 24 /*ReverseLongEnum*/): { std::vector<::aidl::android::aidl::tests::LongEnum> in_input; std::vector<::aidl::android::aidl::tests::LongEnum> out_repeated; std::vector<::aidl::android::aidl::tests::LongEnum> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_repeated); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseLongEnum(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 25 /*GetOtherTestService*/): { std::string in_name; std::shared_ptr<::aidl::android::aidl::tests::INamedCallback> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_name); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->GetOtherTestService(in_name, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 26 /*SetOtherTestService*/): { std::string in_name; std::shared_ptr<::aidl::android::aidl::tests::INamedCallback> in_service; bool _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_name); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_service); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->SetOtherTestService(in_name, in_service, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 27 /*VerifyName*/): { std::shared_ptr<::aidl::android::aidl::tests::INamedCallback> in_service; std::string in_name; bool _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_service); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_name); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->VerifyName(in_service, in_name, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 28 /*GetInterfaceArray*/): { std::vector in_names; std::vector> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_names); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->GetInterfaceArray(in_names, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 29 /*VerifyNamesWithInterfaceArray*/): { std::vector> in_services; std::vector in_names; bool _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_services); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_names); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->VerifyNamesWithInterfaceArray(in_services, in_names, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 30 /*GetNullableInterfaceArray*/): { std::optional>> in_names; std::optional>> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_names); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->GetNullableInterfaceArray(in_names, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 31 /*VerifyNamesWithNullableInterfaceArray*/): { std::optional>> in_services; std::optional>> in_names; bool _aidl_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_services); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_names); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->VerifyNamesWithNullableInterfaceArray(in_services, in_names, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 32 /*GetInterfaceList*/): { std::optional>> in_names; std::optional>> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_names); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->GetInterfaceList(in_names, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 33 /*VerifyNamesWithInterfaceList*/): { std::optional>> in_services; std::optional>> in_names; bool _aidl_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_services); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_names); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->VerifyNamesWithInterfaceList(in_services, in_names, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 34 /*ReverseStringList*/): { std::vector in_input; std::vector out_repeated; std::vector _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseStringList(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 35 /*RepeatParcelFileDescriptor*/): { ::ndk::ScopedFileDescriptor in_read; ::ndk::ScopedFileDescriptor _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_read); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatParcelFileDescriptor(in_read, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 36 /*ReverseParcelFileDescriptorArray*/): { std::vector<::ndk::ScopedFileDescriptor> in_input; std::vector<::ndk::ScopedFileDescriptor> out_repeated; std::vector<::ndk::ScopedFileDescriptor> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_repeated); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseParcelFileDescriptorArray(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 37 /*ThrowServiceException*/): { int32_t in_code; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_code); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ThrowServiceException(in_code); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } case (FIRST_CALL_TRANSACTION + 38 /*RepeatNullableIntArray*/): { std::optional> in_input; std::optional> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatNullableIntArray(in_input, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 39 /*RepeatNullableByteEnumArray*/): { std::optional> in_input; std::optional> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatNullableByteEnumArray(in_input, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 40 /*RepeatNullableIntEnumArray*/): { std::optional> in_input; std::optional> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatNullableIntEnumArray(in_input, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 41 /*RepeatNullableLongEnumArray*/): { std::optional> in_input; std::optional> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatNullableLongEnumArray(in_input, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 42 /*RepeatNullableString*/): { std::optional in_input; std::optional _aidl_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatNullableString(in_input, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 43 /*RepeatNullableStringList*/): { std::optional>> in_input; std::optional>> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatNullableStringList(in_input, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 44 /*RepeatNullableParcelable*/): { std::optional<::aidl::android::aidl::tests::ITestService::Empty> in_input; std::optional<::aidl::android::aidl::tests::ITestService::Empty> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatNullableParcelable(in_input, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 45 /*RepeatNullableParcelableArray*/): { std::optional>> in_input; std::optional>> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatNullableParcelableArray(in_input, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 46 /*RepeatNullableParcelableList*/): { std::optional>> in_input; std::optional>> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatNullableParcelableList(in_input, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 47 /*TakesAnIBinder*/): { ::ndk::SpAIBinder in_input; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->TakesAnIBinder(in_input); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } case (FIRST_CALL_TRANSACTION + 48 /*TakesANullableIBinder*/): { ::ndk::SpAIBinder in_input; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->TakesANullableIBinder(in_input); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } case (FIRST_CALL_TRANSACTION + 49 /*TakesAnIBinderList*/): { std::vector<::ndk::SpAIBinder> in_input; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->TakesAnIBinderList(in_input); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } case (FIRST_CALL_TRANSACTION + 50 /*TakesANullableIBinderList*/): { std::optional> in_input; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->TakesANullableIBinderList(in_input); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } case (FIRST_CALL_TRANSACTION + 51 /*RepeatUtf8CppString*/): { std::string in_token; std::string _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_token); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatUtf8CppString(in_token, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 52 /*RepeatNullableUtf8CppString*/): { std::optional in_token; std::optional _aidl_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_token); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatNullableUtf8CppString(in_token, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 53 /*ReverseUtf8CppString*/): { std::vector in_input; std::vector out_repeated; std::vector _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_repeated); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseUtf8CppString(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 54 /*ReverseNullableUtf8CppString*/): { std::optional>> in_input; std::optional>> out_repeated; std::optional>> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_repeated); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseNullableUtf8CppString(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 55 /*ReverseUtf8CppStringList*/): { std::optional>> in_input; std::optional>> out_repeated; std::optional>> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseUtf8CppStringList(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 56 /*GetCallback*/): { bool in_return_null; std::shared_ptr<::aidl::android::aidl::tests::INamedCallback> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_return_null); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->GetCallback(in_return_null, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 57 /*FillOutStructuredParcelable*/): { ::aidl::android::aidl::tests::StructuredParcelable in_parcel; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_parcel); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->FillOutStructuredParcelable(&in_parcel); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, in_parcel); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 58 /*RepeatExtendableParcelable*/): { ::aidl::android::aidl::tests::extension::ExtendableParcelable in_ep; ::aidl::android::aidl::tests::extension::ExtendableParcelable out_ep2; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_ep); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatExtendableParcelable(in_ep, &out_ep2); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_ep2); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 59 /*ReverseList*/): { ::aidl::android::aidl::tests::RecursiveList in_list; ::aidl::android::aidl::tests::RecursiveList _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_list); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseList(in_list, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 60 /*ReverseIBinderArray*/): { std::vector<::ndk::SpAIBinder> in_input; std::vector<::ndk::SpAIBinder> out_repeated; std::vector<::ndk::SpAIBinder> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_repeated); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseIBinderArray(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 61 /*ReverseNullableIBinderArray*/): { std::optional> in_input; std::optional> out_repeated; std::optional> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_repeated); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseNullableIBinderArray(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 62 /*RepeatSimpleParcelable*/): { ::aidl::android::aidl::tests::SimpleParcelable in_input; ::aidl::android::aidl::tests::SimpleParcelable out_repeat; ::aidl::android::aidl::tests::SimpleParcelable _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatSimpleParcelable(in_input, &out_repeat, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeat); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 63 /*ReverseSimpleParcelables*/): { std::vector<::aidl::android::aidl::tests::SimpleParcelable> in_input; std::vector<::aidl::android::aidl::tests::SimpleParcelable> out_repeated; std::vector<::aidl::android::aidl::tests::SimpleParcelable> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_repeated); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseSimpleParcelables(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 64 /*GetOldNameInterface*/): { std::shared_ptr<::aidl::android::aidl::tests::IOldName> _aidl_return; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->GetOldNameInterface(&_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 65 /*GetNewNameInterface*/): { std::shared_ptr<::aidl::android::aidl::tests::INewName> _aidl_return; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->GetNewNameInterface(&_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 66 /*GetUnionTags*/): { std::vector<::aidl::android::aidl::tests::Union> in_input; std::vector<::aidl::android::aidl::tests::Union::Tag> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->GetUnionTags(in_input, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 67 /*GetCppJavaTests*/): { ::ndk::SpAIBinder _aidl_return; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->GetCppJavaTests(&_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 68 /*getBackendType*/): { ::aidl::android::aidl::tests::BackendType _aidl_return; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->getBackendType(&_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 69 /*GetCircular*/): { ::aidl::android::aidl::tests::CircularParcelable out_cp; std::shared_ptr<::aidl::android::aidl::tests::ICircular> _aidl_return; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->GetCircular(&out_cp, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_cp); if (_aidl_ret_status != STATUS_OK) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_tests_ITestService_clazz = ::ndk::ICInterface::defineClass(ITestService::descriptor, _aidl_android_aidl_tests_ITestService_onTransact); #pragma clang diagnostic pop BpTestService::BpTestService(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} BpTestService::~BpTestService() {} ::ndk::ScopedAStatus BpTestService::UnimplementedMethod(int32_t in_arg, int32_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_arg); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*UnimplementedMethod*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->UnimplementedMethod(in_arg, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::Deprecated() { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 1 /*Deprecated*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->Deprecated(); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::TestOneway() { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 2 /*TestOneway*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_ONEWAY | FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->TestOneway(); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatBoolean(bool in_token, bool* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_token); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 3 /*RepeatBoolean*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatBoolean(in_token, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatByte(int8_t in_token, int8_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_token); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 4 /*RepeatByte*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatByte(in_token, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatChar(char16_t in_token, char16_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_token); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 5 /*RepeatChar*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatChar(in_token, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatInt(int32_t in_token, int32_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_token); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 6 /*RepeatInt*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatInt(in_token, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatLong(int64_t in_token, int64_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_token); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 7 /*RepeatLong*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatLong(in_token, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatFloat(float in_token, float* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_token); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 8 /*RepeatFloat*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatFloat(in_token, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatDouble(double in_token, double* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_token); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 9 /*RepeatDouble*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatDouble(in_token, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatString(const std::string& in_token, std::string* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_token); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 10 /*RepeatString*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatString(in_token, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatByteEnum(::aidl::android::aidl::tests::ByteEnum in_token, ::aidl::android::aidl::tests::ByteEnum* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_token); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 11 /*RepeatByteEnum*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatByteEnum(in_token, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatIntEnum(::aidl::android::aidl::tests::IntEnum in_token, ::aidl::android::aidl::tests::IntEnum* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_token); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 12 /*RepeatIntEnum*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatIntEnum(in_token, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatLongEnum(::aidl::android::aidl::tests::LongEnum in_token, ::aidl::android::aidl::tests::LongEnum* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_token); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 13 /*RepeatLongEnum*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatLongEnum(in_token, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseBoolean(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 14 /*ReverseBoolean*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseBoolean(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseByte(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 15 /*ReverseByte*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseByte(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseChar(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 16 /*ReverseChar*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseChar(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseInt(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 17 /*ReverseInt*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseInt(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseLong(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 18 /*ReverseLong*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseLong(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseFloat(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 19 /*ReverseFloat*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseFloat(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseDouble(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 20 /*ReverseDouble*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseDouble(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseString(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 21 /*ReverseString*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseString(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseByteEnum(const std::vector<::aidl::android::aidl::tests::ByteEnum>& in_input, std::vector<::aidl::android::aidl::tests::ByteEnum>* out_repeated, std::vector<::aidl::android::aidl::tests::ByteEnum>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 22 /*ReverseByteEnum*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseByteEnum(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseIntEnum(const std::vector<::aidl::android::aidl::tests::IntEnum>& in_input, std::vector<::aidl::android::aidl::tests::IntEnum>* out_repeated, std::vector<::aidl::android::aidl::tests::IntEnum>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 23 /*ReverseIntEnum*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseIntEnum(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseLongEnum(const std::vector<::aidl::android::aidl::tests::LongEnum>& in_input, std::vector<::aidl::android::aidl::tests::LongEnum>* out_repeated, std::vector<::aidl::android::aidl::tests::LongEnum>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 24 /*ReverseLongEnum*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseLongEnum(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::GetOtherTestService(const std::string& in_name, std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_name); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 25 /*GetOtherTestService*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->GetOtherTestService(in_name, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::SetOtherTestService(const std::string& in_name, const std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>& in_service, bool* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_name); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_service); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 26 /*SetOtherTestService*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->SetOtherTestService(in_name, in_service, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::VerifyName(const std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>& in_service, const std::string& in_name, bool* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_service); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_name); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 27 /*VerifyName*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->VerifyName(in_service, in_name, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::GetInterfaceArray(const std::vector& in_names, std::vector>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_names); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 28 /*GetInterfaceArray*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->GetInterfaceArray(in_names, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::VerifyNamesWithInterfaceArray(const std::vector>& in_services, const std::vector& in_names, bool* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_services); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_names); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 29 /*VerifyNamesWithInterfaceArray*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->VerifyNamesWithInterfaceArray(in_services, in_names, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::GetNullableInterfaceArray(const std::optional>>& in_names, std::optional>>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_names); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 30 /*GetNullableInterfaceArray*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->GetNullableInterfaceArray(in_names, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::VerifyNamesWithNullableInterfaceArray(const std::optional>>& in_services, const std::optional>>& in_names, bool* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_services); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_names); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 31 /*VerifyNamesWithNullableInterfaceArray*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->VerifyNamesWithNullableInterfaceArray(in_services, in_names, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::GetInterfaceList(const std::optional>>& in_names, std::optional>>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_names); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 32 /*GetInterfaceList*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->GetInterfaceList(in_names, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::VerifyNamesWithInterfaceList(const std::optional>>& in_services, const std::optional>>& in_names, bool* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_services); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_names); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 33 /*VerifyNamesWithInterfaceList*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->VerifyNamesWithInterfaceList(in_services, in_names, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseStringList(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 34 /*ReverseStringList*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseStringList(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatParcelFileDescriptor(const ::ndk::ScopedFileDescriptor& in_read, ::ndk::ScopedFileDescriptor* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_read); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 35 /*RepeatParcelFileDescriptor*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatParcelFileDescriptor(in_read, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseParcelFileDescriptorArray(const std::vector<::ndk::ScopedFileDescriptor>& in_input, std::vector<::ndk::ScopedFileDescriptor>* out_repeated, std::vector<::ndk::ScopedFileDescriptor>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 36 /*ReverseParcelFileDescriptorArray*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseParcelFileDescriptorArray(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ThrowServiceException(int32_t in_code) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_code); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 37 /*ThrowServiceException*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ThrowServiceException(in_code); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatNullableIntArray(const std::optional>& in_input, std::optional>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 38 /*RepeatNullableIntArray*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatNullableIntArray(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatNullableByteEnumArray(const std::optional>& in_input, std::optional>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 39 /*RepeatNullableByteEnumArray*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatNullableByteEnumArray(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatNullableIntEnumArray(const std::optional>& in_input, std::optional>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 40 /*RepeatNullableIntEnumArray*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatNullableIntEnumArray(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatNullableLongEnumArray(const std::optional>& in_input, std::optional>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 41 /*RepeatNullableLongEnumArray*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatNullableLongEnumArray(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatNullableString(const std::optional& in_input, std::optional* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 42 /*RepeatNullableString*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatNullableString(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatNullableStringList(const std::optional>>& in_input, std::optional>>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 43 /*RepeatNullableStringList*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatNullableStringList(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatNullableParcelable(const std::optional<::aidl::android::aidl::tests::ITestService::Empty>& in_input, std::optional<::aidl::android::aidl::tests::ITestService::Empty>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 44 /*RepeatNullableParcelable*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatNullableParcelable(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatNullableParcelableArray(const std::optional>>& in_input, std::optional>>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 45 /*RepeatNullableParcelableArray*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatNullableParcelableArray(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatNullableParcelableList(const std::optional>>& in_input, std::optional>>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 46 /*RepeatNullableParcelableList*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatNullableParcelableList(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::TakesAnIBinder(const ::ndk::SpAIBinder& in_input) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 47 /*TakesAnIBinder*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->TakesAnIBinder(in_input); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::TakesANullableIBinder(const ::ndk::SpAIBinder& in_input) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 48 /*TakesANullableIBinder*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->TakesANullableIBinder(in_input); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::TakesAnIBinderList(const std::vector<::ndk::SpAIBinder>& in_input) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 49 /*TakesAnIBinderList*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->TakesAnIBinderList(in_input); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::TakesANullableIBinderList(const std::optional>& in_input) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 50 /*TakesANullableIBinderList*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->TakesANullableIBinderList(in_input); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatUtf8CppString(const std::string& in_token, std::string* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_token); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 51 /*RepeatUtf8CppString*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatUtf8CppString(in_token, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatNullableUtf8CppString(const std::optional& in_token, std::optional* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_token); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 52 /*RepeatNullableUtf8CppString*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatNullableUtf8CppString(in_token, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseUtf8CppString(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 53 /*ReverseUtf8CppString*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseUtf8CppString(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseNullableUtf8CppString(const std::optional>>& in_input, std::optional>>* out_repeated, std::optional>>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 54 /*ReverseNullableUtf8CppString*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseNullableUtf8CppString(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseUtf8CppStringList(const std::optional>>& in_input, std::optional>>* out_repeated, std::optional>>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 55 /*ReverseUtf8CppStringList*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseUtf8CppStringList(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::GetCallback(bool in_return_null, std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_return_null); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 56 /*GetCallback*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->GetCallback(in_return_null, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::FillOutStructuredParcelable(::aidl::android::aidl::tests::StructuredParcelable* in_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), *in_parcel); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 57 /*FillOutStructuredParcelable*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->FillOutStructuredParcelable(in_parcel); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), in_parcel); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatExtendableParcelable(const ::aidl::android::aidl::tests::extension::ExtendableParcelable& in_ep, ::aidl::android::aidl::tests::extension::ExtendableParcelable* out_ep2) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_ep); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 58 /*RepeatExtendableParcelable*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatExtendableParcelable(in_ep, out_ep2); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_ep2); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseList(const ::aidl::android::aidl::tests::RecursiveList& in_list, ::aidl::android::aidl::tests::RecursiveList* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_list); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 59 /*ReverseList*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseList(in_list, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseIBinderArray(const std::vector<::ndk::SpAIBinder>& in_input, std::vector<::ndk::SpAIBinder>* out_repeated, std::vector<::ndk::SpAIBinder>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 60 /*ReverseIBinderArray*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseIBinderArray(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseNullableIBinderArray(const std::optional>& in_input, std::optional>* out_repeated, std::optional>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 61 /*ReverseNullableIBinderArray*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseNullableIBinderArray(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatSimpleParcelable(const ::aidl::android::aidl::tests::SimpleParcelable& in_input, ::aidl::android::aidl::tests::SimpleParcelable* out_repeat, ::aidl::android::aidl::tests::SimpleParcelable* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 62 /*RepeatSimpleParcelable*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatSimpleParcelable(in_input, out_repeat, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeat); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseSimpleParcelables(const std::vector<::aidl::android::aidl::tests::SimpleParcelable>& in_input, std::vector<::aidl::android::aidl::tests::SimpleParcelable>* out_repeated, std::vector<::aidl::android::aidl::tests::SimpleParcelable>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 63 /*ReverseSimpleParcelables*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseSimpleParcelables(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::GetOldNameInterface(std::shared_ptr<::aidl::android::aidl::tests::IOldName>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 64 /*GetOldNameInterface*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->GetOldNameInterface(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::GetNewNameInterface(std::shared_ptr<::aidl::android::aidl::tests::INewName>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 65 /*GetNewNameInterface*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->GetNewNameInterface(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::GetUnionTags(const std::vector<::aidl::android::aidl::tests::Union>& in_input, std::vector<::aidl::android::aidl::tests::Union::Tag>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 66 /*GetUnionTags*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->GetUnionTags(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::GetCppJavaTests(::ndk::SpAIBinder* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 67 /*GetCppJavaTests*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->GetCppJavaTests(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::getBackendType(::aidl::android::aidl::tests::BackendType* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 68 /*getBackendType*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->getBackendType(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::GetCircular(::aidl::android::aidl::tests::CircularParcelable* out_cp, std::shared_ptr<::aidl::android::aidl::tests::ICircular>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 69 /*GetCircular*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->GetCircular(out_cp, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_cp); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } // Source for BnTestService BnTestService::BnTestService() {} BnTestService::~BnTestService() {} ::ndk::SpAIBinder BnTestService::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_tests_ITestService_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for ITestService const char* ITestService::descriptor = "android.aidl.tests.ITestService"; ITestService::ITestService() {} ITestService::~ITestService() {} const char* ITestService::STRING_CONSTANT = "foo"; const char* ITestService::STRING_CONSTANT2 = "bar"; const char* ITestService::STRING_CONSTANT_UTF8 = "baz"; std::shared_ptr ITestService::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_tests_ITestService_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t ITestService::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t ITestService::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = ITestService::fromBinder(binder); return STATUS_OK; } bool ITestService::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!ITestService::default_impl); if (impl) { ITestService::default_impl = impl; return true; } return false; } const std::shared_ptr& ITestService::getDefaultImpl() { return ITestService::default_impl; } std::shared_ptr ITestService::default_impl = nullptr; ::ndk::ScopedAStatus ITestServiceDefault::UnimplementedMethod(int32_t /*in_arg*/, int32_t* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::Deprecated() { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::TestOneway() { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatBoolean(bool /*in_token*/, bool* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatByte(int8_t /*in_token*/, int8_t* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatChar(char16_t /*in_token*/, char16_t* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatInt(int32_t /*in_token*/, int32_t* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatLong(int64_t /*in_token*/, int64_t* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatFloat(float /*in_token*/, float* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatDouble(double /*in_token*/, double* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatString(const std::string& /*in_token*/, std::string* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatByteEnum(::aidl::android::aidl::tests::ByteEnum /*in_token*/, ::aidl::android::aidl::tests::ByteEnum* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatIntEnum(::aidl::android::aidl::tests::IntEnum /*in_token*/, ::aidl::android::aidl::tests::IntEnum* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatLongEnum(::aidl::android::aidl::tests::LongEnum /*in_token*/, ::aidl::android::aidl::tests::LongEnum* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseBoolean(const std::vector& /*in_input*/, std::vector* /*out_repeated*/, std::vector* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseByte(const std::vector& /*in_input*/, std::vector* /*out_repeated*/, std::vector* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseChar(const std::vector& /*in_input*/, std::vector* /*out_repeated*/, std::vector* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseInt(const std::vector& /*in_input*/, std::vector* /*out_repeated*/, std::vector* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseLong(const std::vector& /*in_input*/, std::vector* /*out_repeated*/, std::vector* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseFloat(const std::vector& /*in_input*/, std::vector* /*out_repeated*/, std::vector* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseDouble(const std::vector& /*in_input*/, std::vector* /*out_repeated*/, std::vector* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseString(const std::vector& /*in_input*/, std::vector* /*out_repeated*/, std::vector* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseByteEnum(const std::vector<::aidl::android::aidl::tests::ByteEnum>& /*in_input*/, std::vector<::aidl::android::aidl::tests::ByteEnum>* /*out_repeated*/, std::vector<::aidl::android::aidl::tests::ByteEnum>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseIntEnum(const std::vector<::aidl::android::aidl::tests::IntEnum>& /*in_input*/, std::vector<::aidl::android::aidl::tests::IntEnum>* /*out_repeated*/, std::vector<::aidl::android::aidl::tests::IntEnum>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseLongEnum(const std::vector<::aidl::android::aidl::tests::LongEnum>& /*in_input*/, std::vector<::aidl::android::aidl::tests::LongEnum>* /*out_repeated*/, std::vector<::aidl::android::aidl::tests::LongEnum>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::GetOtherTestService(const std::string& /*in_name*/, std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::SetOtherTestService(const std::string& /*in_name*/, const std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>& /*in_service*/, bool* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::VerifyName(const std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>& /*in_service*/, const std::string& /*in_name*/, bool* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::GetInterfaceArray(const std::vector& /*in_names*/, std::vector>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::VerifyNamesWithInterfaceArray(const std::vector>& /*in_services*/, const std::vector& /*in_names*/, bool* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::GetNullableInterfaceArray(const std::optional>>& /*in_names*/, std::optional>>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::VerifyNamesWithNullableInterfaceArray(const std::optional>>& /*in_services*/, const std::optional>>& /*in_names*/, bool* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::GetInterfaceList(const std::optional>>& /*in_names*/, std::optional>>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::VerifyNamesWithInterfaceList(const std::optional>>& /*in_services*/, const std::optional>>& /*in_names*/, bool* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseStringList(const std::vector& /*in_input*/, std::vector* /*out_repeated*/, std::vector* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatParcelFileDescriptor(const ::ndk::ScopedFileDescriptor& /*in_read*/, ::ndk::ScopedFileDescriptor* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseParcelFileDescriptorArray(const std::vector<::ndk::ScopedFileDescriptor>& /*in_input*/, std::vector<::ndk::ScopedFileDescriptor>* /*out_repeated*/, std::vector<::ndk::ScopedFileDescriptor>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ThrowServiceException(int32_t /*in_code*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatNullableIntArray(const std::optional>& /*in_input*/, std::optional>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatNullableByteEnumArray(const std::optional>& /*in_input*/, std::optional>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatNullableIntEnumArray(const std::optional>& /*in_input*/, std::optional>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatNullableLongEnumArray(const std::optional>& /*in_input*/, std::optional>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatNullableString(const std::optional& /*in_input*/, std::optional* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatNullableStringList(const std::optional>>& /*in_input*/, std::optional>>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatNullableParcelable(const std::optional<::aidl::android::aidl::tests::ITestService::Empty>& /*in_input*/, std::optional<::aidl::android::aidl::tests::ITestService::Empty>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatNullableParcelableArray(const std::optional>>& /*in_input*/, std::optional>>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatNullableParcelableList(const std::optional>>& /*in_input*/, std::optional>>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::TakesAnIBinder(const ::ndk::SpAIBinder& /*in_input*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::TakesANullableIBinder(const ::ndk::SpAIBinder& /*in_input*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::TakesAnIBinderList(const std::vector<::ndk::SpAIBinder>& /*in_input*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::TakesANullableIBinderList(const std::optional>& /*in_input*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatUtf8CppString(const std::string& /*in_token*/, std::string* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatNullableUtf8CppString(const std::optional& /*in_token*/, std::optional* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseUtf8CppString(const std::vector& /*in_input*/, std::vector* /*out_repeated*/, std::vector* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseNullableUtf8CppString(const std::optional>>& /*in_input*/, std::optional>>* /*out_repeated*/, std::optional>>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseUtf8CppStringList(const std::optional>>& /*in_input*/, std::optional>>* /*out_repeated*/, std::optional>>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::GetCallback(bool /*in_return_null*/, std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::FillOutStructuredParcelable(::aidl::android::aidl::tests::StructuredParcelable* /*in_parcel*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatExtendableParcelable(const ::aidl::android::aidl::tests::extension::ExtendableParcelable& /*in_ep*/, ::aidl::android::aidl::tests::extension::ExtendableParcelable* /*out_ep2*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseList(const ::aidl::android::aidl::tests::RecursiveList& /*in_list*/, ::aidl::android::aidl::tests::RecursiveList* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseIBinderArray(const std::vector<::ndk::SpAIBinder>& /*in_input*/, std::vector<::ndk::SpAIBinder>* /*out_repeated*/, std::vector<::ndk::SpAIBinder>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseNullableIBinderArray(const std::optional>& /*in_input*/, std::optional>* /*out_repeated*/, std::optional>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatSimpleParcelable(const ::aidl::android::aidl::tests::SimpleParcelable& /*in_input*/, ::aidl::android::aidl::tests::SimpleParcelable* /*out_repeat*/, ::aidl::android::aidl::tests::SimpleParcelable* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseSimpleParcelables(const std::vector<::aidl::android::aidl::tests::SimpleParcelable>& /*in_input*/, std::vector<::aidl::android::aidl::tests::SimpleParcelable>* /*out_repeated*/, std::vector<::aidl::android::aidl::tests::SimpleParcelable>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::GetOldNameInterface(std::shared_ptr<::aidl::android::aidl::tests::IOldName>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::GetNewNameInterface(std::shared_ptr<::aidl::android::aidl::tests::INewName>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::GetUnionTags(const std::vector<::aidl::android::aidl::tests::Union>& /*in_input*/, std::vector<::aidl::android::aidl::tests::Union::Tag>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::GetCppJavaTests(::ndk::SpAIBinder* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::getBackendType(::aidl::android::aidl::tests::BackendType* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::GetCircular(::aidl::android::aidl::tests::CircularParcelable* /*out_cp*/, std::shared_ptr<::aidl::android::aidl::tests::ICircular>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::SpAIBinder ITestServiceDefault::asBinder() { return ::ndk::SpAIBinder(); } bool ITestServiceDefault::isRemote() { return false; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { const char* ITestService::Empty::descriptor = "android.aidl.tests.ITestService.Empty"; binder_status_t ITestService::Empty::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t ITestService::Empty::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { const char* ITestService::CompilerChecks::descriptor = "android.aidl.tests.ITestService.CompilerChecks"; binder_status_t ITestService::CompilerChecks::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &binder); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &nullable_binder); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &binder_array); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &nullable_binder_array); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &binder_list); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &nullable_binder_list); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &pfd); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &nullable_pfd); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &pfd_array); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &nullable_pfd_array); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &pfd_list); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &nullable_pfd_list); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &parcel); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &nullable_parcel); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &parcel_array); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &nullable_parcel_array); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &parcel_list); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &nullable_parcel_list); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t ITestService::CompilerChecks::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, binder); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, nullable_binder); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, binder_array); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, nullable_binder_array); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, binder_list); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, nullable_binder_list); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, pfd); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, nullable_pfd); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, pfd_array); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, nullable_pfd_array); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, pfd_list); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, nullable_pfd_list); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, parcel); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, nullable_parcel); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, parcel_array); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, nullable_parcel_array); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, parcel_list); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, nullable_parcel_list); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { static binder_status_t _aidl_android_aidl_tests_ITestService_CompilerChecks_Foo_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; (void)_aidl_binder; (void)_aidl_code; return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_tests_ITestService_CompilerChecks_Foo_clazz = ::ndk::ICInterface::defineClass(ITestService::CompilerChecks::IFoo::descriptor, _aidl_android_aidl_tests_ITestService_CompilerChecks_Foo_onTransact); ITestService::CompilerChecks::BpFoo::BpFoo(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} ITestService::CompilerChecks::BpFoo::~BpFoo() {} // Source for BnFoo ITestService::CompilerChecks::BnFoo::BnFoo() {} ITestService::CompilerChecks::BnFoo::~BnFoo() {} ::ndk::SpAIBinder ITestService::CompilerChecks::BnFoo::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_tests_ITestService_CompilerChecks_Foo_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for IFoo const char* ITestService::CompilerChecks::IFoo::descriptor = "android.aidl.tests.ITestService.CompilerChecks.Foo"; ITestService::CompilerChecks::IFoo::IFoo() {} ITestService::CompilerChecks::IFoo::~IFoo() {} std::shared_ptr ITestService::CompilerChecks::IFoo::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_tests_ITestService_CompilerChecks_Foo_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t ITestService::CompilerChecks::IFoo::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t ITestService::CompilerChecks::IFoo::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = IFoo::fromBinder(binder); return STATUS_OK; } bool ITestService::CompilerChecks::IFoo::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!IFoo::default_impl); if (impl) { IFoo::default_impl = impl; return true; } return false; } const std::shared_ptr& ITestService::CompilerChecks::IFoo::getDefaultImpl() { return IFoo::default_impl; } std::shared_ptr ITestService::CompilerChecks::IFoo::default_impl = nullptr; ::ndk::SpAIBinder ITestService::CompilerChecks::IFooDefault::asBinder() { return ::ndk::SpAIBinder(); } bool ITestService::CompilerChecks::IFooDefault::isRemote() { return false; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { const char* ITestService::CompilerChecks::HasDeprecated::descriptor = "android.aidl.tests.ITestService.CompilerChecks.HasDeprecated"; #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" binder_status_t ITestService::CompilerChecks::HasDeprecated::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &deprecated); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t ITestService::CompilerChecks::HasDeprecated::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, deprecated); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } #pragma clang diagnostic pop } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { const char* ITestService::CompilerChecks::UsingHasDeprecated::descriptor = "android.aidl.tests.ITestService.CompilerChecks.UsingHasDeprecated"; binder_status_t ITestService::CompilerChecks::UsingHasDeprecated::readFromParcel(const AParcel* _parcel) { binder_status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_tag)) != STATUS_OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case n: { int32_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case m: { ::aidl::android::aidl::tests::ITestService::CompilerChecks::HasDeprecated _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::aidl::android::aidl::tests::ITestService::CompilerChecks::HasDeprecated>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } } return STATUS_BAD_VALUE; } binder_status_t ITestService::CompilerChecks::UsingHasDeprecated::writeToParcel(AParcel* _parcel) const { binder_status_t _aidl_ret_status = ::ndk::AParcel_writeData(_parcel, static_cast(getTag())); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; switch (getTag()) { case n: return ::ndk::AParcel_writeData(_parcel, get()); case m: return ::ndk::AParcel_writeData(_parcel, get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { static binder_status_t _aidl_android_aidl_tests_ITestService_CompilerChecks_NoPrefixInterface_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*foo*/): { ::ndk::ScopedAStatus _aidl_status = _aidl_impl->foo(); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_tests_ITestService_CompilerChecks_NoPrefixInterface_clazz = ::ndk::ICInterface::defineClass(ITestService::CompilerChecks::INoPrefixInterface::descriptor, _aidl_android_aidl_tests_ITestService_CompilerChecks_NoPrefixInterface_onTransact); ITestService::CompilerChecks::BpNoPrefixInterface::BpNoPrefixInterface(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} ITestService::CompilerChecks::BpNoPrefixInterface::~BpNoPrefixInterface() {} ::ndk::ScopedAStatus ITestService::CompilerChecks::BpNoPrefixInterface::foo() { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*foo*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && INoPrefixInterface::getDefaultImpl()) { _aidl_status = INoPrefixInterface::getDefaultImpl()->foo(); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } // Source for BnNoPrefixInterface ITestService::CompilerChecks::BnNoPrefixInterface::BnNoPrefixInterface() {} ITestService::CompilerChecks::BnNoPrefixInterface::~BnNoPrefixInterface() {} ::ndk::SpAIBinder ITestService::CompilerChecks::BnNoPrefixInterface::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_tests_ITestService_CompilerChecks_NoPrefixInterface_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for INoPrefixInterface const char* ITestService::CompilerChecks::INoPrefixInterface::descriptor = "android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface"; ITestService::CompilerChecks::INoPrefixInterface::INoPrefixInterface() {} ITestService::CompilerChecks::INoPrefixInterface::~INoPrefixInterface() {} std::shared_ptr ITestService::CompilerChecks::INoPrefixInterface::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_tests_ITestService_CompilerChecks_NoPrefixInterface_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t ITestService::CompilerChecks::INoPrefixInterface::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t ITestService::CompilerChecks::INoPrefixInterface::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = INoPrefixInterface::fromBinder(binder); return STATUS_OK; } bool ITestService::CompilerChecks::INoPrefixInterface::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!INoPrefixInterface::default_impl); if (impl) { INoPrefixInterface::default_impl = impl; return true; } return false; } const std::shared_ptr& ITestService::CompilerChecks::INoPrefixInterface::getDefaultImpl() { return INoPrefixInterface::default_impl; } std::shared_ptr ITestService::CompilerChecks::INoPrefixInterface::default_impl = nullptr; ::ndk::ScopedAStatus ITestService::CompilerChecks::INoPrefixInterfaceDefault::foo() { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::SpAIBinder ITestService::CompilerChecks::INoPrefixInterfaceDefault::asBinder() { return ::ndk::SpAIBinder(); } bool ITestService::CompilerChecks::INoPrefixInterfaceDefault::isRemote() { return false; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { const char* ITestService::CompilerChecks::INoPrefixInterface::Nested::descriptor = "android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.Nested"; binder_status_t ITestService::CompilerChecks::INoPrefixInterface::Nested::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t ITestService::CompilerChecks::INoPrefixInterface::Nested::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { static binder_status_t _aidl_android_aidl_tests_ITestService_CompilerChecks_NoPrefixInterface_NestedNoPrefixInterface_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*foo*/): { ::ndk::ScopedAStatus _aidl_status = _aidl_impl->foo(); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_tests_ITestService_CompilerChecks_NoPrefixInterface_NestedNoPrefixInterface_clazz = ::ndk::ICInterface::defineClass(ITestService::CompilerChecks::INoPrefixInterface::INestedNoPrefixInterface::descriptor, _aidl_android_aidl_tests_ITestService_CompilerChecks_NoPrefixInterface_NestedNoPrefixInterface_onTransact); ITestService::CompilerChecks::INoPrefixInterface::BpNestedNoPrefixInterface::BpNestedNoPrefixInterface(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} ITestService::CompilerChecks::INoPrefixInterface::BpNestedNoPrefixInterface::~BpNestedNoPrefixInterface() {} ::ndk::ScopedAStatus ITestService::CompilerChecks::INoPrefixInterface::BpNestedNoPrefixInterface::foo() { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*foo*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && INestedNoPrefixInterface::getDefaultImpl()) { _aidl_status = INestedNoPrefixInterface::getDefaultImpl()->foo(); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } // Source for BnNestedNoPrefixInterface ITestService::CompilerChecks::INoPrefixInterface::BnNestedNoPrefixInterface::BnNestedNoPrefixInterface() {} ITestService::CompilerChecks::INoPrefixInterface::BnNestedNoPrefixInterface::~BnNestedNoPrefixInterface() {} ::ndk::SpAIBinder ITestService::CompilerChecks::INoPrefixInterface::BnNestedNoPrefixInterface::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_tests_ITestService_CompilerChecks_NoPrefixInterface_NestedNoPrefixInterface_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for INestedNoPrefixInterface const char* ITestService::CompilerChecks::INoPrefixInterface::INestedNoPrefixInterface::descriptor = "android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.NestedNoPrefixInterface"; ITestService::CompilerChecks::INoPrefixInterface::INestedNoPrefixInterface::INestedNoPrefixInterface() {} ITestService::CompilerChecks::INoPrefixInterface::INestedNoPrefixInterface::~INestedNoPrefixInterface() {} std::shared_ptr ITestService::CompilerChecks::INoPrefixInterface::INestedNoPrefixInterface::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_tests_ITestService_CompilerChecks_NoPrefixInterface_NestedNoPrefixInterface_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t ITestService::CompilerChecks::INoPrefixInterface::INestedNoPrefixInterface::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t ITestService::CompilerChecks::INoPrefixInterface::INestedNoPrefixInterface::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = INestedNoPrefixInterface::fromBinder(binder); return STATUS_OK; } bool ITestService::CompilerChecks::INoPrefixInterface::INestedNoPrefixInterface::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!INestedNoPrefixInterface::default_impl); if (impl) { INestedNoPrefixInterface::default_impl = impl; return true; } return false; } const std::shared_ptr& ITestService::CompilerChecks::INoPrefixInterface::INestedNoPrefixInterface::getDefaultImpl() { return INestedNoPrefixInterface::default_impl; } std::shared_ptr ITestService::CompilerChecks::INoPrefixInterface::INestedNoPrefixInterface::default_impl = nullptr; ::ndk::ScopedAStatus ITestService::CompilerChecks::INoPrefixInterface::INestedNoPrefixInterfaceDefault::foo() { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::SpAIBinder ITestService::CompilerChecks::INoPrefixInterface::INestedNoPrefixInterfaceDefault::asBinder() { return ::ndk::SpAIBinder(); } bool ITestService::CompilerChecks::INoPrefixInterface::INestedNoPrefixInterfaceDefault::isRemote() { return false; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_ITestServi0100644 0000000 0000000 00000000034 15172120304 033172 xustar000000000 0000000 28 mtime=1776853188.4610000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/ITestService.cpp.d0100644 0000000 0000000 00000002225 15172120304 031272 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/ITestService.cpp : \ system/tools/aidl/tests/android/aidl/tests/ITestService.aidl \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ICircular.aidl \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl \ system/tools/aidl/tests/android/aidl/tests/SimpleParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_IntEnum.cp0100644 0000000 0000000 00000000034 15172120304 033111 xustar000000000 0000000 28 mtime=1776853188.4620000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/IntEnum.cpp0100644 0000000 0000000 00000001226 15172120304 030056 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/IntEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl */ // This file is intentionally left blank as placeholder for enum declaration. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_IntEnum.cp0100644 0000000 0000000 00000000034 15172120304 033111 xustar000000000 0000000 28 mtime=1776853188.4620000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/IntEnum.cpp.d0100644 0000000 0000000 00000000253 15172120304 030277 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/IntEnum.cpp : \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_ListOfInte0100644 0000000 0000000 00000000034 15172120304 033151 xustar000000000 0000000 28 mtime=1776853188.4620000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/ListOfInterfaces.cpp0100644 0000000 0000000 00000062470 15172120304 031713 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ListOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ListOfInterfaces.aidl */ #include "aidl/android/aidl/tests/ListOfInterfaces.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { const char* ListOfInterfaces::descriptor = "android.aidl.tests.ListOfInterfaces"; binder_status_t ListOfInterfaces::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t ListOfInterfaces::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { static binder_status_t _aidl_android_aidl_tests_ListOfInterfaces_IEmptyInterface_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; (void)_aidl_binder; (void)_aidl_code; return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_tests_ListOfInterfaces_IEmptyInterface_clazz = ::ndk::ICInterface::defineClass(ListOfInterfaces::IEmptyInterface::descriptor, _aidl_android_aidl_tests_ListOfInterfaces_IEmptyInterface_onTransact); ListOfInterfaces::BpEmptyInterface::BpEmptyInterface(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} ListOfInterfaces::BpEmptyInterface::~BpEmptyInterface() {} // Source for BnEmptyInterface ListOfInterfaces::BnEmptyInterface::BnEmptyInterface() {} ListOfInterfaces::BnEmptyInterface::~BnEmptyInterface() {} ::ndk::SpAIBinder ListOfInterfaces::BnEmptyInterface::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_tests_ListOfInterfaces_IEmptyInterface_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for IEmptyInterface const char* ListOfInterfaces::IEmptyInterface::descriptor = "android.aidl.tests.ListOfInterfaces.IEmptyInterface"; ListOfInterfaces::IEmptyInterface::IEmptyInterface() {} ListOfInterfaces::IEmptyInterface::~IEmptyInterface() {} std::shared_ptr ListOfInterfaces::IEmptyInterface::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_tests_ListOfInterfaces_IEmptyInterface_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t ListOfInterfaces::IEmptyInterface::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t ListOfInterfaces::IEmptyInterface::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = IEmptyInterface::fromBinder(binder); return STATUS_OK; } bool ListOfInterfaces::IEmptyInterface::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!IEmptyInterface::default_impl); if (impl) { IEmptyInterface::default_impl = impl; return true; } return false; } const std::shared_ptr& ListOfInterfaces::IEmptyInterface::getDefaultImpl() { return IEmptyInterface::default_impl; } std::shared_ptr ListOfInterfaces::IEmptyInterface::default_impl = nullptr; ::ndk::SpAIBinder ListOfInterfaces::IEmptyInterfaceDefault::asBinder() { return ::ndk::SpAIBinder(); } bool ListOfInterfaces::IEmptyInterfaceDefault::isRemote() { return false; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { static binder_status_t _aidl_android_aidl_tests_ListOfInterfaces_IMyInterface_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*methodWithInterfaces*/): { std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface> in_iface; std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface> in_nullable_iface; std::vector> in_iface_list_in; std::vector> out_iface_list_out; std::vector> in_iface_list_inout; std::optional>> in_nullable_iface_list_in; std::optional>> out_nullable_iface_list_out; std::optional>> in_nullable_iface_list_inout; std::optional>> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_iface); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_nullable_iface); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_iface_list_in); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_iface_list_inout); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_nullable_iface_list_in); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_nullable_iface_list_inout); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->methodWithInterfaces(in_iface, in_nullable_iface, in_iface_list_in, &out_iface_list_out, &in_iface_list_inout, in_nullable_iface_list_in, &out_nullable_iface_list_out, &in_nullable_iface_list_inout, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_iface_list_out); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, in_iface_list_inout); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, out_nullable_iface_list_out); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, in_nullable_iface_list_inout); if (_aidl_ret_status != STATUS_OK) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_tests_ListOfInterfaces_IMyInterface_clazz = ::ndk::ICInterface::defineClass(ListOfInterfaces::IMyInterface::descriptor, _aidl_android_aidl_tests_ListOfInterfaces_IMyInterface_onTransact); ListOfInterfaces::BpMyInterface::BpMyInterface(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} ListOfInterfaces::BpMyInterface::~BpMyInterface() {} ::ndk::ScopedAStatus ListOfInterfaces::BpMyInterface::methodWithInterfaces(const std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& in_iface, const std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& in_nullable_iface, const std::vector>& in_iface_list_in, std::vector>* out_iface_list_out, std::vector>* in_iface_list_inout, const std::optional>>& in_nullable_iface_list_in, std::optional>>* out_nullable_iface_list_out, std::optional>>* in_nullable_iface_list_inout, std::optional>>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_iface); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_nullable_iface); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_iface_list_in); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), *in_iface_list_inout); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_nullable_iface_list_in); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), *in_nullable_iface_list_inout); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*methodWithInterfaces*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IMyInterface::getDefaultImpl()) { _aidl_status = IMyInterface::getDefaultImpl()->methodWithInterfaces(in_iface, in_nullable_iface, in_iface_list_in, out_iface_list_out, in_iface_list_inout, in_nullable_iface_list_in, out_nullable_iface_list_out, in_nullable_iface_list_inout, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_iface_list_out); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), in_iface_list_inout); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), out_nullable_iface_list_out); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), in_nullable_iface_list_inout); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } // Source for BnMyInterface ListOfInterfaces::BnMyInterface::BnMyInterface() {} ListOfInterfaces::BnMyInterface::~BnMyInterface() {} ::ndk::SpAIBinder ListOfInterfaces::BnMyInterface::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_tests_ListOfInterfaces_IMyInterface_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for IMyInterface const char* ListOfInterfaces::IMyInterface::descriptor = "android.aidl.tests.ListOfInterfaces.IMyInterface"; ListOfInterfaces::IMyInterface::IMyInterface() {} ListOfInterfaces::IMyInterface::~IMyInterface() {} std::shared_ptr ListOfInterfaces::IMyInterface::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_tests_ListOfInterfaces_IMyInterface_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t ListOfInterfaces::IMyInterface::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t ListOfInterfaces::IMyInterface::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = IMyInterface::fromBinder(binder); return STATUS_OK; } bool ListOfInterfaces::IMyInterface::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!IMyInterface::default_impl); if (impl) { IMyInterface::default_impl = impl; return true; } return false; } const std::shared_ptr& ListOfInterfaces::IMyInterface::getDefaultImpl() { return IMyInterface::default_impl; } std::shared_ptr ListOfInterfaces::IMyInterface::default_impl = nullptr; ::ndk::ScopedAStatus ListOfInterfaces::IMyInterfaceDefault::methodWithInterfaces(const std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& /*in_iface*/, const std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& /*in_nullable_iface*/, const std::vector>& /*in_iface_list_in*/, std::vector>* /*out_iface_list_out*/, std::vector>* /*in_iface_list_inout*/, const std::optional>>& /*in_nullable_iface_list_in*/, std::optional>>* /*out_nullable_iface_list_out*/, std::optional>>* /*in_nullable_iface_list_inout*/, std::optional>>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::SpAIBinder ListOfInterfaces::IMyInterfaceDefault::asBinder() { return ::ndk::SpAIBinder(); } bool ListOfInterfaces::IMyInterfaceDefault::isRemote() { return false; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { const char* ListOfInterfaces::MyParcelable::descriptor = "android.aidl.tests.ListOfInterfaces.MyParcelable"; binder_status_t ListOfInterfaces::MyParcelable::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &iface); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &nullable_iface); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &iface_list); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &nullable_iface_list); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t ListOfInterfaces::MyParcelable::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, iface); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, nullable_iface); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, iface_list); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, nullable_iface_list); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { const char* ListOfInterfaces::MyUnion::descriptor = "android.aidl.tests.ListOfInterfaces.MyUnion"; binder_status_t ListOfInterfaces::MyUnion::readFromParcel(const AParcel* _parcel) { binder_status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_tag)) != STATUS_OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case iface: { std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface> _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case nullable_iface: { std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface> _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readNullableData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case iface_list: { std::vector> _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v>>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case nullable_iface_list: { std::optional>> _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readNullableData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v>>>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } } return STATUS_BAD_VALUE; } binder_status_t ListOfInterfaces::MyUnion::writeToParcel(AParcel* _parcel) const { binder_status_t _aidl_ret_status = ::ndk::AParcel_writeData(_parcel, static_cast(getTag())); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; switch (getTag()) { case iface: return ::ndk::AParcel_writeData(_parcel, get()); case nullable_iface: return ::ndk::AParcel_writeNullableData(_parcel, get()); case iface_list: return ::ndk::AParcel_writeData(_parcel, get()); case nullable_iface_list: return ::ndk::AParcel_writeNullableData(_parcel, get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_ListOfInte0100644 0000000 0000000 00000000034 15172120304 033151 xustar000000000 0000000 28 mtime=1776853188.4630000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/ListOfInterfaces.cpp.d0100644 0000000 0000000 00000000275 15172120304 032130 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/ListOfInterfaces.cpp : \ system/tools/aidl/tests/android/aidl/tests/ListOfInterfaces.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_LongEnum.c0100644 0000000 0000000 00000000034 15172120304 033076 xustar000000000 0000000 28 mtime=1776853188.4630000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/LongEnum.cpp0100644 0000000 0000000 00000001230 15172120304 030216 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/LongEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl */ // This file is intentionally left blank as placeholder for enum declaration. ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_LongEnum.c0100644 0000000 0000000 00000000034 15172120304 033076 xustar000000000 0000000 28 mtime=1776853188.4630000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/LongEnum.cpp.d0100644 0000000 0000000 00000000255 15172120304 030446 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/LongEnum.cpp : \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_OtherParce0100644 0000000 0000000 00000000216 15172120304 033167 xustar000000000 0000000 114 path=tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/OtherParcelableForToString.cpp 28 mtime=1776853188.4630000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/OtherParcelableForToString0100644 0000000 0000000 00000005176 15172120304 033123 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/OtherParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl */ #include "aidl/android/aidl/tests/OtherParcelableForToString.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { const char* OtherParcelableForToString::descriptor = "android.aidl.tests.OtherParcelableForToString"; binder_status_t OtherParcelableForToString::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &field); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t OtherParcelableForToString::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, field); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_OtherParce0100644 0000000 0000000 00000000220 15172120304 033162 xustar000000000 0000000 116 path=tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/OtherParcelableForToString.cpp.d 28 mtime=1776853188.4630000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/OtherParcelableForToString0100644 0000000 0000000 00000000321 15172120304 033106 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/OtherParcelableForToString.cpp : \ system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_Parcelable0100644 0000000 0000000 00000000034 15172120304 033163 xustar000000000 0000000 28 mtime=1776853188.4630000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/ParcelableForToString.cpp0100644 0000000 0000000 00000031647 15172120304 032704 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ParcelableForToString.aidl */ #include "aidl/android/aidl/tests/ParcelableForToString.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { const char* ParcelableForToString::descriptor = "android.aidl.tests.ParcelableForToString"; binder_status_t ParcelableForToString::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &intValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &intArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &longValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &longArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &doubleValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &doubleArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &floatValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &floatArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &byteValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &byteArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &booleanValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &booleanArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &stringValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &stringArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &stringList); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &parcelableValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &parcelableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &enumValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &enumArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &nullArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &nullList); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &parcelableGeneric); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &unionValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t ParcelableForToString::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, intValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, intArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, longValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, longArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, doubleValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, doubleArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, floatValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, floatArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, byteValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, byteArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, booleanValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, booleanArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, stringValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, stringArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, stringList); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, parcelableValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, parcelableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, enumValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, enumArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, nullArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, nullList); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, parcelableGeneric); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, unionValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_Parcelable0100644 0000000 0000000 00000000213 15172120304 033162 xustar000000000 0000000 111 path=tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/ParcelableForToString.cpp.d 28 mtime=1776853188.4630000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/ParcelableForToString.cpp.0100644 0000000 0000000 00000001352 15172120304 032750 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/ParcelableForToString.cpp : \ system/tools/aidl/tests/android/aidl/tests/ParcelableForToString.aidl \ system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_RecursiveL0100644 0000000 0000000 00000000034 15172120304 033214 xustar000000000 0000000 28 mtime=1776853188.4630000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/RecursiveList.cpp0100644 0000000 0000000 00000006006 15172120304 031303 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/RecursiveList.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl */ #include "aidl/android/aidl/tests/RecursiveList.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { const char* RecursiveList::descriptor = "android.aidl.tests.RecursiveList"; binder_status_t RecursiveList::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &value); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &next); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t RecursiveList::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, value); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, next); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_RecursiveL0100644 0000000 0000000 00000000034 15172120304 033214 xustar000000000 0000000 28 mtime=1776853188.4630000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/RecursiveList.cpp.d0100644 0000000 0000000 00000000267 15172120304 031530 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/RecursiveList.cpp : \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_Structured0100644 0000000 0000000 00000000034 15172120304 033275 xustar000000000 0000000 28 mtime=1776853188.4630000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/StructuredParcelable.cpp0100644 0000000 0000000 00000073423 15172120304 032626 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/StructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl */ #include "aidl/android/aidl/tests/StructuredParcelable.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { const char* StructuredParcelable::descriptor = "android.aidl.tests.StructuredParcelable"; binder_status_t StructuredParcelable::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &shouldContainThreeFs); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &f); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &shouldBeJerry); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &shouldBeByteBar); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &shouldBeIntBar); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &shouldBeLongBar); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &shouldContainTwoByteFoos); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &shouldContainTwoIntFoos); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &shouldContainTwoLongFoos); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &stringDefaultsToFoo); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &byteDefaultsToFour); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &intDefaultsToFive); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &longDefaultsToNegativeSeven); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &booleanDefaultsToTrue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &charDefaultsToC); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &floatDefaultsToPi); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &doubleWithDefault); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &arrayDefaultsTo123); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &arrayDefaultsToEmpty); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &boolDefault); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &byteDefault); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &intDefault); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &longDefault); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &floatDefault); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &doubleDefault); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &checkDoubleFromFloat); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &checkStringArray1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &checkStringArray2); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &int32_min); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &int32_max); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &int64_max); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &hexInt32_neg_1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &ibinder); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &empty); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &int8_1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &int32_1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &int64_1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &hexInt32_pos_1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &hexInt64_pos_1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &const_exprs_1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &const_exprs_2); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &const_exprs_3); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &const_exprs_4); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &const_exprs_5); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &const_exprs_6); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &const_exprs_7); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &const_exprs_8); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &const_exprs_9); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &const_exprs_10); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &addString1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &addString2); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &shouldSetBit0AndBit2); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &u); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &shouldBeConstS1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &defaultWithFoo); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t StructuredParcelable::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, shouldContainThreeFs); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, f); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, shouldBeJerry); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, shouldBeByteBar); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, shouldBeIntBar); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, shouldBeLongBar); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, shouldContainTwoByteFoos); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, shouldContainTwoIntFoos); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, shouldContainTwoLongFoos); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, stringDefaultsToFoo); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, byteDefaultsToFour); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, intDefaultsToFive); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, longDefaultsToNegativeSeven); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, booleanDefaultsToTrue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, charDefaultsToC); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, floatDefaultsToPi); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, doubleWithDefault); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, arrayDefaultsTo123); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, arrayDefaultsToEmpty); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, boolDefault); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, byteDefault); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, intDefault); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, longDefault); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, floatDefault); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, doubleDefault); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, checkDoubleFromFloat); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, checkStringArray1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, checkStringArray2); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, int32_min); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, int32_max); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, int64_max); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, hexInt32_neg_1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, ibinder); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, empty); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, int8_1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, int32_1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, int64_1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, hexInt32_pos_1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, hexInt64_pos_1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, const_exprs_1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, const_exprs_2); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, const_exprs_3); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, const_exprs_4); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, const_exprs_5); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, const_exprs_6); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, const_exprs_7); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, const_exprs_8); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, const_exprs_9); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, const_exprs_10); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, addString1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, addString2); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, shouldSetBit0AndBit2); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, u); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, shouldBeConstS1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, defaultWithFoo); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { const char* StructuredParcelable::Empty::descriptor = "android.aidl.tests.StructuredParcelable.Empty"; binder_status_t StructuredParcelable::Empty::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t StructuredParcelable::Empty::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_Structured0100644 0000000 0000000 00000000212 15172120304 033273 xustar000000000 0000000 110 path=tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/StructuredParcelable.cpp.d 28 mtime=1776853188.4640000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/StructuredParcelable.cpp.d0100644 0000000 0000000 00000001000 15172120304 033026 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/StructuredParcelable.cpp : \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_Union.cpp0100644 0000000 0000000 00000000034 15172120304 033002 xustar000000000 0000000 28 mtime=1776853188.4640000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/Union.cpp0100644 0000000 0000000 00000011325 15172120304 027570 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/Union.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/Union.aidl */ #include "aidl/android/aidl/tests/Union.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { const char* Union::descriptor = "android.aidl.tests.Union"; const char* Union::S1 = "a string constant in union"; binder_status_t Union::readFromParcel(const AParcel* _parcel) { binder_status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_tag)) != STATUS_OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case ns: { std::vector _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case n: { int32_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case m: { int32_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case s: { std::string _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case ibinder: { ::ndk::SpAIBinder _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readNullableData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::ndk::SpAIBinder>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case ss: { std::vector _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case be: { ::aidl::android::aidl::tests::ByteEnum _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::aidl::android::aidl::tests::ByteEnum>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } } return STATUS_BAD_VALUE; } binder_status_t Union::writeToParcel(AParcel* _parcel) const { binder_status_t _aidl_ret_status = ::ndk::AParcel_writeData(_parcel, static_cast(getTag())); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; switch (getTag()) { case ns: return ::ndk::AParcel_writeData(_parcel, get()); case n: return ::ndk::AParcel_writeData(_parcel, get()); case m: return ::ndk::AParcel_writeData(_parcel, get()); case s: return ::ndk::AParcel_writeData(_parcel, get()); case ibinder: return ::ndk::AParcel_writeNullableData(_parcel, get()); case ss: return ::ndk::AParcel_writeData(_parcel, get()); case be: return ::ndk::AParcel_writeData(_parcel, get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_Union.cpp.0100644 0000000 0000000 00000000034 15172120304 033060 xustar000000000 0000000 28 mtime=1776853188.4640000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/Union.cpp.d0100644 0000000 0000000 00000000344 15172120304 030011 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/Union.cpp : \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_UnionWithF0100644 0000000 0000000 00000000034 15172120304 033163 xustar000000000 0000000 28 mtime=1776853188.4640000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/UnionWithFd.cpp0100644 0000000 0000000 00000004675 15172120304 030710 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/UnionWithFd.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/UnionWithFd.aidl */ #include "aidl/android/aidl/tests/UnionWithFd.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { const char* UnionWithFd::descriptor = "android.aidl.tests.UnionWithFd"; binder_status_t UnionWithFd::readFromParcel(const AParcel* _parcel) { binder_status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_tag)) != STATUS_OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case num: { int32_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case pfd: { ::ndk::ScopedFileDescriptor _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::ndk::ScopedFileDescriptor>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } } return STATUS_BAD_VALUE; } binder_status_t UnionWithFd::writeToParcel(AParcel* _parcel) const { binder_status_t _aidl_ret_status = ::ndk::AParcel_writeData(_parcel, static_cast(getTag())); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; switch (getTag()) { case num: return ::ndk::AParcel_writeData(_parcel, get()); case pfd: return ::ndk::AParcel_writeData(_parcel, get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_UnionWithF0100644 0000000 0000000 00000000034 15172120304 033163 xustar000000000 0000000 28 mtime=1776853188.4640000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/UnionWithFd.cpp.d0100644 0000000 0000000 00000000263 15172120304 031117 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/UnionWithFd.cpp : \ system/tools/aidl/tests/android/aidl/tests/UnionWithFd.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_extension_0100644 0000000 0000000 00000000034 15172120304 033304 xustar000000000 0000000 28 mtime=1776853188.4640000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/0040755 0000000 0000000 00000000000 15172120304 030011 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_extension_0100644 0000000 0000000 00000000222 15172120304 033303 xustar000000000 0000000 118 path=tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/ExtendableParcelable.cpp 28 mtime=1776853188.4640000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/ExtendableParcel0100644 0000000 0000000 00000010742 15172120304 033137 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/extension/ExtendableParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl */ #include "aidl/android/aidl/tests/extension/ExtendableParcelable.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { namespace extension { const char* ExtendableParcelable::descriptor = "android.aidl.tests.extension.ExtendableParcelable"; binder_status_t ExtendableParcelable::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &a); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &b); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &ext); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &c); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &ext2); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t ExtendableParcelable::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, a); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, b); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, ext); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, c); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, ext2); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace extension } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_extension_0100644 0000000 0000000 00000000224 15172120304 033305 xustar000000000 0000000 120 path=tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/ExtendableParcelable.cpp.d 28 mtime=1776853188.4640000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/ExtendableParcel0100644 0000000 0000000 00000000331 15172120304 033130 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/ExtendableParcelable.cpp : \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_extension_0100644 0000000 0000000 00000000034 15172120304 033304 xustar000000000 0000000 28 mtime=1776853188.4640000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/MyExt.cpp0100644 0000000 0000000 00000006010 15172120304 031555 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/extension/MyExt.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl */ #include "aidl/android/aidl/tests/extension/MyExt.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { namespace extension { const char* MyExt::descriptor = "android.aidl.tests.extension.MyExt"; binder_status_t MyExt::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &a); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &b); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t MyExt::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, a); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, b); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace extension } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_extension_0100644 0000000 0000000 00000000034 15172120304 033304 xustar000000000 0000000 28 mtime=1776853188.4640000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/MyExt.cpp.d0100644 0000000 0000000 00000000273 15172120304 032004 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/MyExt.cpp : \ system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_extension_0100644 0000000 0000000 00000000034 15172120304 033304 xustar000000000 0000000 28 mtime=1776853188.4640000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/MyExt2.cpp0100644 0000000 0000000 00000006734 15172120304 031654 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/extension/MyExt2.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt2.aidl */ #include "aidl/android/aidl/tests/extension/MyExt2.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { namespace extension { const char* MyExt2::descriptor = "android.aidl.tests.extension.MyExt2"; binder_status_t MyExt2::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &a); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &b); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &c); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t MyExt2::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, a); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, b); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, c); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace extension } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_extension_0100644 0000000 0000000 00000000034 15172120304 033304 xustar000000000 0000000 28 mtime=1776853188.4640000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/MyExt2.cpp.d0100644 0000000 0000000 00000000401 15172120304 032057 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/MyExt2.cpp : \ system/tools/aidl/tests/android/aidl/tests/extension/MyExt2.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_extension_0100644 0000000 0000000 00000000034 15172120304 033304 xustar000000000 0000000 28 mtime=1776853188.4640000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/MyExtLike.cpp0100644 0000000 0000000 00000006044 15172120304 032371 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/extension/MyExtLike.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExtLike.aidl */ #include "aidl/android/aidl/tests/extension/MyExtLike.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { namespace extension { const char* MyExtLike::descriptor = "android.aidl.tests.extension.MyExtLike"; binder_status_t MyExtLike::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &a); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &b); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t MyExtLike::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, a); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, b); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace extension } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_extension_0100644 0000000 0000000 00000000034 15172120304 033304 xustar000000000 0000000 28 mtime=1776853188.4640000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/MyExtLike.cpp.d0100644 0000000 0000000 00000000303 15172120304 032603 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/MyExtLike.cpp : \ system/tools/aidl/tests/android/aidl/tests/extension/MyExtLike.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_nested_0100644 0000000 0000000 00000000034 15172120304 032552 xustar000000000 0000000 28 mtime=1776853188.4640000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/nested/0040755 0000000 0000000 00000000000 15172120304 027257 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_nested_Dee0100644 0000000 0000000 00000000034 15172120304 033170 xustar000000000 0000000 28 mtime=1776853188.4650000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/nested/DeeplyNested.cpp0100644 0000000 0000000 00000020713 15172120304 032350 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/nested/DeeplyNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/DeeplyNested.aidl */ #include "aidl/android/aidl/tests/nested/DeeplyNested.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { namespace nested { const char* DeeplyNested::descriptor = "android.aidl.tests.nested.DeeplyNested"; binder_status_t DeeplyNested::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t DeeplyNested::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { namespace nested { const char* DeeplyNested::A::descriptor = "android.aidl.tests.nested.DeeplyNested.A"; binder_status_t DeeplyNested::A::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &e); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t DeeplyNested::A::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, e); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { namespace nested { const char* DeeplyNested::B::descriptor = "android.aidl.tests.nested.DeeplyNested.B"; binder_status_t DeeplyNested::B::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t DeeplyNested::B::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { namespace nested { const char* DeeplyNested::B::C::descriptor = "android.aidl.tests.nested.DeeplyNested.B.C"; binder_status_t DeeplyNested::B::C::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t DeeplyNested::B::C::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { namespace nested { const char* DeeplyNested::B::C::D::descriptor = "android.aidl.tests.nested.DeeplyNested.B.C.D"; binder_status_t DeeplyNested::B::C::D::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t DeeplyNested::B::C::D::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_nested_Dee0100644 0000000 0000000 00000000034 15172120304 033170 xustar000000000 0000000 28 mtime=1776853188.4650000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/nested/DeeplyNested.cpp.d0100644 0000000 0000000 00000000303 15172120304 032563 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/nested/DeeplyNested.cpp : \ system/tools/aidl/tests/android/aidl/tests/nested/DeeplyNested.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_nested_INe0100644 0000000 0000000 00000000034 15172120304 033146 xustar000000000 0000000 28 mtime=1776853188.4650000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/nested/INestedService.cpp0100644 0000000 0000000 00000043413 15172120304 032641 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/nested/INestedService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/INestedService.aidl */ #include "aidl/android/aidl/tests/nested/INestedService.h" #include #include #include namespace aidl { namespace android { namespace aidl { namespace tests { namespace nested { static binder_status_t _aidl_android_aidl_tests_nested_INestedService_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*flipStatus*/): { ::aidl::android::aidl::tests::nested::ParcelableWithNested in_p; ::aidl::android::aidl::tests::nested::INestedService::Result _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_p); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->flipStatus(in_p, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 1 /*flipStatusWithCallback*/): { ::aidl::android::aidl::tests::nested::ParcelableWithNested::Status in_status; std::shared_ptr<::aidl::android::aidl::tests::nested::INestedService::ICallback> in_cb; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_status); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_cb); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->flipStatusWithCallback(in_status, in_cb); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_tests_nested_INestedService_clazz = ::ndk::ICInterface::defineClass(INestedService::descriptor, _aidl_android_aidl_tests_nested_INestedService_onTransact); BpNestedService::BpNestedService(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} BpNestedService::~BpNestedService() {} ::ndk::ScopedAStatus BpNestedService::flipStatus(const ::aidl::android::aidl::tests::nested::ParcelableWithNested& in_p, ::aidl::android::aidl::tests::nested::INestedService::Result* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_p); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*flipStatus*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && INestedService::getDefaultImpl()) { _aidl_status = INestedService::getDefaultImpl()->flipStatus(in_p, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpNestedService::flipStatusWithCallback(::aidl::android::aidl::tests::nested::ParcelableWithNested::Status in_status, const std::shared_ptr<::aidl::android::aidl::tests::nested::INestedService::ICallback>& in_cb) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_status); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_cb); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 1 /*flipStatusWithCallback*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && INestedService::getDefaultImpl()) { _aidl_status = INestedService::getDefaultImpl()->flipStatusWithCallback(in_status, in_cb); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } // Source for BnNestedService BnNestedService::BnNestedService() {} BnNestedService::~BnNestedService() {} ::ndk::SpAIBinder BnNestedService::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_tests_nested_INestedService_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for INestedService const char* INestedService::descriptor = "android.aidl.tests.nested.INestedService"; INestedService::INestedService() {} INestedService::~INestedService() {} std::shared_ptr INestedService::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_tests_nested_INestedService_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t INestedService::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t INestedService::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = INestedService::fromBinder(binder); return STATUS_OK; } bool INestedService::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!INestedService::default_impl); if (impl) { INestedService::default_impl = impl; return true; } return false; } const std::shared_ptr& INestedService::getDefaultImpl() { return INestedService::default_impl; } std::shared_ptr INestedService::default_impl = nullptr; ::ndk::ScopedAStatus INestedServiceDefault::flipStatus(const ::aidl::android::aidl::tests::nested::ParcelableWithNested& /*in_p*/, ::aidl::android::aidl::tests::nested::INestedService::Result* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus INestedServiceDefault::flipStatusWithCallback(::aidl::android::aidl::tests::nested::ParcelableWithNested::Status /*in_status*/, const std::shared_ptr<::aidl::android::aidl::tests::nested::INestedService::ICallback>& /*in_cb*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::SpAIBinder INestedServiceDefault::asBinder() { return ::ndk::SpAIBinder(); } bool INestedServiceDefault::isRemote() { return false; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { namespace nested { const char* INestedService::Result::descriptor = "android.aidl.tests.nested.INestedService.Result"; binder_status_t INestedService::Result::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &status); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t INestedService::Result::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, status); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { namespace nested { static binder_status_t _aidl_android_aidl_tests_nested_INestedService_ICallback_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*done*/): { ::aidl::android::aidl::tests::nested::ParcelableWithNested::Status in_status; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_status); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->done(in_status); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_tests_nested_INestedService_ICallback_clazz = ::ndk::ICInterface::defineClass(INestedService::ICallback::descriptor, _aidl_android_aidl_tests_nested_INestedService_ICallback_onTransact); INestedService::BpCallback::BpCallback(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} INestedService::BpCallback::~BpCallback() {} ::ndk::ScopedAStatus INestedService::BpCallback::done(::aidl::android::aidl::tests::nested::ParcelableWithNested::Status in_status) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_status); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*done*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ICallback::getDefaultImpl()) { _aidl_status = ICallback::getDefaultImpl()->done(in_status); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } // Source for BnCallback INestedService::BnCallback::BnCallback() {} INestedService::BnCallback::~BnCallback() {} ::ndk::SpAIBinder INestedService::BnCallback::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_tests_nested_INestedService_ICallback_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for ICallback const char* INestedService::ICallback::descriptor = "android.aidl.tests.nested.INestedService.ICallback"; INestedService::ICallback::ICallback() {} INestedService::ICallback::~ICallback() {} std::shared_ptr INestedService::ICallback::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_tests_nested_INestedService_ICallback_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t INestedService::ICallback::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t INestedService::ICallback::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = ICallback::fromBinder(binder); return STATUS_OK; } bool INestedService::ICallback::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!ICallback::default_impl); if (impl) { ICallback::default_impl = impl; return true; } return false; } const std::shared_ptr& INestedService::ICallback::getDefaultImpl() { return ICallback::default_impl; } std::shared_ptr INestedService::ICallback::default_impl = nullptr; ::ndk::ScopedAStatus INestedService::ICallbackDefault::done(::aidl::android::aidl::tests::nested::ParcelableWithNested::Status /*in_status*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::SpAIBinder INestedService::ICallbackDefault::asBinder() { return ::ndk::SpAIBinder(); } bool INestedService::ICallbackDefault::isRemote() { return false; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_nested_INe0100644 0000000 0000000 00000000213 15172120304 033145 xustar000000000 0000000 111 path=tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/nested/INestedService.cpp.d 28 mtime=1776853188.4650000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/nested/INestedService.cpp.0100644 0000000 0000000 00000000427 15172120304 032715 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/nested/INestedService.cpp : \ system/tools/aidl/tests/android/aidl/tests/nested/INestedService.aidl \ system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_nested_Par0100644 0000000 0000000 00000000217 15172120304 033220 xustar000000000 0000000 115 path=tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/nested/ParcelableWithNested.cpp 28 mtime=1776853188.4650000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/nested/ParcelableWithNeste0100644 0000000 0000000 00000005234 15172120304 033070 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/nested/ParcelableWithNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl */ #include "aidl/android/aidl/tests/nested/ParcelableWithNested.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { namespace nested { const char* ParcelableWithNested::descriptor = "android.aidl.tests.nested.ParcelableWithNested"; binder_status_t ParcelableWithNested::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &status); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t ParcelableWithNested::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, status); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_nested_Par0100644 0000000 0000000 00000000221 15172120304 033213 xustar000000000 0000000 117 path=tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/nested/ParcelableWithNested.cpp.d 28 mtime=1776853188.4650000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/nested/ParcelableWithNeste0100644 0000000 0000000 00000000323 15172120304 033062 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/nested/ParcelableWithNested.cpp : \ system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_unions_0100644 0000000 0000000 00000000034 15172120304 032603 xustar000000000 0000000 28 mtime=1776853188.4650000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/unions/0040755 0000000 0000000 00000000000 15172120304 027310 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_unions_Enu0100644 0000000 0000000 00000000034 15172120304 033253 xustar000000000 0000000 28 mtime=1776853188.4660000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/unions/EnumUnion.cpp0100644 0000000 0000000 00000006541 15172120304 031734 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/unions/EnumUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl */ #include "aidl/android/aidl/tests/unions/EnumUnion.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { namespace unions { const char* EnumUnion::descriptor = "android.aidl.tests.unions.EnumUnion"; #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" binder_status_t EnumUnion::readFromParcel(const AParcel* _parcel) { binder_status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_tag)) != STATUS_OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case intEnum: { ::aidl::android::aidl::tests::IntEnum _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::aidl::android::aidl::tests::IntEnum>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case longEnum: { ::aidl::android::aidl::tests::LongEnum _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::aidl::android::aidl::tests::LongEnum>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case deprecatedField: { int32_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } } return STATUS_BAD_VALUE; } binder_status_t EnumUnion::writeToParcel(AParcel* _parcel) const { binder_status_t _aidl_ret_status = ::ndk::AParcel_writeData(_parcel, static_cast(getTag())); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; switch (getTag()) { case intEnum: return ::ndk::AParcel_writeData(_parcel, get()); case longEnum: return ::ndk::AParcel_writeData(_parcel, get()); #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" case deprecatedField: return ::ndk::AParcel_writeData(_parcel, get()); #pragma clang diagnostic pop } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } #pragma clang diagnostic pop } // namespace unions } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_unions_Enu0100644 0000000 0000000 00000000034 15172120304 033253 xustar000000000 0000000 28 mtime=1776853188.4660000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/unions/EnumUnion.cpp.d0100644 0000000 0000000 00000000466 15172120304 032156 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/unions/EnumUnion.cpp : \ system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_unions_Uni0100644 0000000 0000000 00000000034 15172120304 033257 xustar000000000 0000000 28 mtime=1776853188.4660000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/unions/UnionInUnion.cpp0100644 0000000 0000000 00000005113 15172120304 032401 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/unions/UnionInUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/UnionInUnion.aidl */ #include "aidl/android/aidl/tests/unions/UnionInUnion.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { namespace unions { const char* UnionInUnion::descriptor = "android.aidl.tests.unions.UnionInUnion"; binder_status_t UnionInUnion::readFromParcel(const AParcel* _parcel) { binder_status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_tag)) != STATUS_OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case first: { ::aidl::android::aidl::tests::unions::EnumUnion _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::aidl::android::aidl::tests::unions::EnumUnion>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case second: { int32_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } } return STATUS_BAD_VALUE; } binder_status_t UnionInUnion::writeToParcel(AParcel* _parcel) const { binder_status_t _aidl_ret_status = ::ndk::AParcel_writeData(_parcel, static_cast(getTag())); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; switch (getTag()) { case first: return ::ndk::AParcel_writeData(_parcel, get()); case second: return ::ndk::AParcel_writeData(_parcel, get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace unions } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_android_aidl_tests_unions_Uni0100644 0000000 0000000 00000000034 15172120304 033257 xustar000000000 0000000 28 mtime=1776853188.4660000 tests/golden_output/aidl-test-interface-ndk-source/gen/android/aidl/tests/unions/UnionInUnion.cpp.d0100644 0000000 0000000 00000000601 15172120304 032620 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/unions/UnionInUnion.cpp : \ system/tools/aidl/tests/android/aidl/tests/unions/UnionInUnion.aidl \ system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_0100644 0000000 0000000 00000000034 15172120304 027000 xustar000000000 0000000 28 mtime=1776853188.4660000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/0040755 0000000 0000000 00000000000 15172120304 023725 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_0100644 0000000 0000000 00000000034 15172120304 027771 xustar000000000 0000000 28 mtime=1776853188.4660000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/0040755 0000000 0000000 00000000000 15172120304 024636 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_0100644 0000000 0000000 00000000034 15172120304 031471 xustar000000000 0000000 28 mtime=1776853188.4660000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/0040755 0000000 0000000 00000000000 15172120304 026256 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_0100644 0000000 0000000 00000000034 15172120304 032462 xustar000000000 0000000 28 mtime=1776853188.4660000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/0040755 0000000 0000000 00000000000 15172120304 027167 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000034 15172120304 033176 xustar000000000 0000000 28 mtime=1776853188.4660000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/0040755 0000000 0000000 00000000000 15172120304 030331 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000220 15172120304 033173 xustar000000000 0000000 116 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/ArrayOfInterfaces.h 28 mtime=1776853188.4660000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/ArrayOfInterf0100644 0000000 0000000 00000037645 15172120304 033003 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ArrayOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ArrayOfInterfaces.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace aidl { namespace android { namespace aidl { namespace tests { class ArrayOfInterfaces { public: typedef std::false_type fixed_size; static const char* descriptor; class IEmptyInterfaceDelegator; class IEmptyInterface : public ::ndk::ICInterface { public: typedef IEmptyInterfaceDelegator DefaultDelegator; static const char* descriptor; IEmptyInterface(); virtual ~IEmptyInterface(); static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); private: static std::shared_ptr default_impl; }; class IEmptyInterfaceDefault : public IEmptyInterface { public: ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; class BpEmptyInterface : public ::ndk::BpCInterface { public: explicit BpEmptyInterface(const ::ndk::SpAIBinder& binder); virtual ~BpEmptyInterface(); }; class BnEmptyInterface : public ::ndk::BnCInterface { public: BnEmptyInterface(); virtual ~BnEmptyInterface(); protected: ::ndk::SpAIBinder createBinder() override; private: }; class IMyInterfaceDelegator; class IMyInterface : public ::ndk::ICInterface { public: typedef IMyInterfaceDelegator DefaultDelegator; static const char* descriptor; IMyInterface(); virtual ~IMyInterface(); static constexpr uint32_t TRANSACTION_methodWithInterfaces = FIRST_CALL_TRANSACTION + 0; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus methodWithInterfaces(const std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& in_iface, const std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& in_nullable_iface, const std::vector>& in_iface_array_in, std::vector>* out_iface_array_out, std::vector>* in_iface_array_inout, const std::optional>>& in_nullable_iface_array_in, std::optional>>* out_nullable_iface_array_out, std::optional>>* in_nullable_iface_array_inout, std::optional>>* _aidl_return) = 0; private: static std::shared_ptr default_impl; }; class IMyInterfaceDefault : public IMyInterface { public: ::ndk::ScopedAStatus methodWithInterfaces(const std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& in_iface, const std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& in_nullable_iface, const std::vector>& in_iface_array_in, std::vector>* out_iface_array_out, std::vector>* in_iface_array_inout, const std::optional>>& in_nullable_iface_array_in, std::optional>>* out_nullable_iface_array_out, std::optional>>* in_nullable_iface_array_inout, std::optional>>* _aidl_return) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; class BpMyInterface : public ::ndk::BpCInterface { public: explicit BpMyInterface(const ::ndk::SpAIBinder& binder); virtual ~BpMyInterface(); ::ndk::ScopedAStatus methodWithInterfaces(const std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& in_iface, const std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& in_nullable_iface, const std::vector>& in_iface_array_in, std::vector>* out_iface_array_out, std::vector>* in_iface_array_inout, const std::optional>>& in_nullable_iface_array_in, std::optional>>* out_nullable_iface_array_out, std::optional>>* in_nullable_iface_array_inout, std::optional>>* _aidl_return) override; }; class BnMyInterface : public ::ndk::BnCInterface { public: BnMyInterface(); virtual ~BnMyInterface(); protected: ::ndk::SpAIBinder createBinder() override; private: }; class MyParcelable { public: typedef std::false_type fixed_size; static const char* descriptor; std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface> iface; std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface> nullable_iface; std::vector> iface_array; std::optional>> nullable_iface_array; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const MyParcelable& _rhs) const { return std::tie(iface, nullable_iface, iface_array, nullable_iface_array) == std::tie(_rhs.iface, _rhs.nullable_iface, _rhs.iface_array, _rhs.nullable_iface_array); } inline bool operator<(const MyParcelable& _rhs) const { return std::tie(iface, nullable_iface, iface_array, nullable_iface_array) < std::tie(_rhs.iface, _rhs.nullable_iface, _rhs.iface_array, _rhs.nullable_iface_array); } inline bool operator!=(const MyParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyParcelable& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "MyParcelable{"; _aidl_os << "iface: " << ::android::internal::ToString(iface); _aidl_os << ", nullable_iface: " << ::android::internal::ToString(nullable_iface); _aidl_os << ", iface_array: " << ::android::internal::ToString(iface_array); _aidl_os << ", nullable_iface_array: " << ::android::internal::ToString(nullable_iface_array); _aidl_os << "}"; return _aidl_os.str(); } }; class MyUnion { public: typedef std::false_type fixed_size; static const char* descriptor; enum class Tag : int32_t { iface = 0, nullable_iface = 1, iface_array = 2, nullable_iface_array = 3, }; // Expose tag symbols for legacy code static const inline Tag iface = Tag::iface; static const inline Tag nullable_iface = Tag::nullable_iface; static const inline Tag iface_array = Tag::iface_array; static const inline Tag nullable_iface_array = Tag::nullable_iface_array; template static constexpr bool _not_self = !std::is_same_v>, MyUnion>; MyUnion() : _value(std::in_place_index(iface)>, std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>()) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr MyUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit MyUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static MyUnion make(_Tp&&... _args) { return MyUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static MyUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return MyUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } binder_status_t readFromParcel(const AParcel* _parcel); binder_status_t writeToParcel(AParcel* _parcel) const; inline bool operator==(const MyUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const MyUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const MyUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyUnion& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream os; os << "MyUnion{"; switch (getTag()) { case iface: os << "iface: " << ::android::internal::ToString(get()); break; case nullable_iface: os << "nullable_iface: " << ::android::internal::ToString(get()); break; case iface_array: os << "iface_array: " << ::android::internal::ToString(get()); break; case nullable_iface_array: os << "nullable_iface_array: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant, std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>, std::vector>, std::optional>>> _value; }; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const ArrayOfInterfaces&) const { return std::tie() == std::tie(); } inline bool operator<(const ArrayOfInterfaces&) const { return std::tie() < std::tie(); } inline bool operator!=(const ArrayOfInterfaces& _rhs) const { return !(*this == _rhs); } inline bool operator>(const ArrayOfInterfaces& _rhs) const { return _rhs < *this; } inline bool operator>=(const ArrayOfInterfaces& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const ArrayOfInterfaces& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "ArrayOfInterfaces{"; _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(ArrayOfInterfaces::MyUnion::Tag val) { switch(val) { case ArrayOfInterfaces::MyUnion::Tag::iface: return "iface"; case ArrayOfInterfaces::MyUnion::Tag::nullable_iface: return "nullable_iface"; case ArrayOfInterfaces::MyUnion::Tag::iface_array: return "iface_array"; case ArrayOfInterfaces::MyUnion::Tag::nullable_iface_array: return "nullable_iface_array"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::tests::ArrayOfInterfaces::MyUnion::Tag::iface, aidl::android::aidl::tests::ArrayOfInterfaces::MyUnion::Tag::nullable_iface, aidl::android::aidl::tests::ArrayOfInterfaces::MyUnion::Tag::iface_array, aidl::android::aidl::tests::ArrayOfInterfaces::MyUnion::Tag::nullable_iface_array, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000212 15172120304 033174 xustar000000000 0000000 110 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BackendType.h 28 mtime=1776853188.4670000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BackendType.h0100644 0000000 0000000 00000004114 15172120304 032670 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/BackendType.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/BackendType.aidl */ #pragma once #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { enum class BackendType : int8_t { CPP = 0, JAVA = 1, NDK = 2, RUST = 3, }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(BackendType val) { switch(val) { case BackendType::CPP: return "CPP"; case BackendType::JAVA: return "JAVA"; case BackendType::NDK: return "NDK"; case BackendType::RUST: return "RUST"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::tests::BackendType::CPP, aidl::android::aidl::tests::BackendType::JAVA, aidl::android::aidl::tests::BackendType::NDK, aidl::android::aidl::tests::BackendType::RUST, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000222 15172120304 033175 xustar000000000 0000000 118 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnArrayOfInterfaces.h 28 mtime=1776853188.4670000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnArrayOfInte0100644 0000000 0000000 00000001232 15172120304 032712 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ArrayOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ArrayOfInterfaces.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000214 15172120304 033176 xustar000000000 0000000 112 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnBackendType.h 28 mtime=1776853188.4670000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnBackendType0100644 0000000 0000000 00000001206 15172120304 032721 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/BackendType.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/BackendType.aidl */ #error TODO(b/111362593) enums do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000034 15172120304 033176 xustar000000000 0000000 28 mtime=1776853188.4670000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnByteEnum.h0100644 0000000 0000000 00000001200 15172120304 032500 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ByteEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl */ #error TODO(b/111362593) enums do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000034 15172120304 033176 xustar000000000 0000000 28 mtime=1776853188.4670000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnCircular.h0100644 0000000 0000000 00000002751 15172120304 032530 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ICircular.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ICircular.aidl */ #pragma once #include "aidl/android/aidl/tests/ICircular.h" #include #include #ifndef __BIONIC__ #ifndef __assert2 #define __assert2(a,b,c,d) ((void)0) #endif #endif namespace aidl { namespace android { namespace aidl { namespace tests { class BnCircular : public ::ndk::BnCInterface { public: BnCircular(); virtual ~BnCircular(); protected: ::ndk::SpAIBinder createBinder() override; private: }; class ICircularDelegator : public BnCircular { public: explicit ICircularDelegator(const std::shared_ptr &impl) : _impl(impl) { } ::ndk::ScopedAStatus GetTestService(std::shared_ptr<::aidl::android::aidl::tests::ITestService>* _aidl_return) override { return _impl->GetTestService(_aidl_return); } protected: private: std::shared_ptr _impl; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000223 15172120304 033176 xustar000000000 0000000 119 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnCircularParcelable.h 28 mtime=1776853188.4670000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnCircularPar0100644 0000000 0000000 00000001234 15172120304 032740 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/CircularParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000227 15172120304 033202 xustar000000000 0000000 123 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnConstantExpressionEnum.h 28 mtime=1776853188.4670000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnConstantExp0100644 0000000 0000000 00000001234 15172120304 032777 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ConstantExpressionEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl */ #error TODO(b/111362593) enums do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000213 15172120304 033175 xustar000000000 0000000 111 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnDeprecated.h 28 mtime=1776853188.4670000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnDeprecated.0100644 0000000 0000000 00000002631 15172120304 032651 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/IDeprecated.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IDeprecated.aidl */ #pragma once #include "aidl/android/aidl/tests/IDeprecated.h" #include #include #ifndef __BIONIC__ #ifndef __assert2 #define __assert2(a,b,c,d) ((void)0) #endif #endif namespace aidl { namespace android { namespace aidl { namespace tests { class __attribute__((deprecated("test"))) BnDeprecated : public ::ndk::BnCInterface { public: BnDeprecated(); virtual ~BnDeprecated(); protected: ::ndk::SpAIBinder createBinder() override; private: }; class __attribute__((deprecated("test"))) IDeprecatedDelegator : public BnDeprecated { public: explicit IDeprecatedDelegator(const std::shared_ptr &impl) : _impl(impl) { } protected: private: std::shared_ptr _impl; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000217 15172120304 033201 xustar000000000 0000000 115 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnDeprecatedEnum.h 28 mtime=1776853188.4670000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnDeprecatedE0100644 0000000 0000000 00000001214 15172120304 032674 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/DeprecatedEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedEnum.aidl */ #error TODO(b/111362593) enums do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000225 15172120304 033200 xustar000000000 0000000 121 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnDeprecatedParcelable.h 28 mtime=1776853188.4670000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnDeprecatedP0100644 0000000 0000000 00000001240 15172120304 032706 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/DeprecatedParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedParcelable.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000212 15172120304 033174 xustar000000000 0000000 110 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnFixedSize.h 28 mtime=1776853188.4670000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnFixedSize.h0100644 0000000 0000000 00000001212 15172120304 032645 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/FixedSize.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/FixedSize.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000234 15172120304 033200 xustar000000000 0000000 128 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnGenericStructuredParcelable.h 28 mtime=1776853188.4670000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnGenericStru0100644 0000000 0000000 00000001256 15172120304 032767 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/GenericStructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000034 15172120304 033176 xustar000000000 0000000 28 mtime=1776853188.4670000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnIntEnum.h0100644 0000000 0000000 00000001176 15172120304 032343 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/IntEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl */ #error TODO(b/111362593) enums do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000221 15172120304 033174 xustar000000000 0000000 117 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnListOfInterfaces.h 28 mtime=1776853188.4670000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnListOfInter0100644 0000000 0000000 00000001230 15172120304 032727 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ListOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ListOfInterfaces.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000034 15172120304 033176 xustar000000000 0000000 28 mtime=1776853188.4670000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnLongEnum.h0100644 0000000 0000000 00000001200 15172120304 032474 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/LongEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl */ #error TODO(b/111362593) enums do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000216 15172120304 033200 xustar000000000 0000000 114 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnNamedCallback.h 28 mtime=1776853188.4670000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnNamedCallba0100644 0000000 0000000 00000002747 15172120304 032666 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/INamedCallback.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl */ #pragma once #include "aidl/android/aidl/tests/INamedCallback.h" #include #include #ifndef __BIONIC__ #ifndef __assert2 #define __assert2(a,b,c,d) ((void)0) #endif #endif namespace aidl { namespace android { namespace aidl { namespace tests { class BnNamedCallback : public ::ndk::BnCInterface { public: BnNamedCallback(); virtual ~BnNamedCallback(); protected: ::ndk::SpAIBinder createBinder() override; private: }; class INamedCallbackDelegator : public BnNamedCallback { public: explicit INamedCallbackDelegator(const std::shared_ptr &impl) : _impl(impl) { } ::ndk::ScopedAStatus GetName(std::string* _aidl_return) override { return _impl->GetName(_aidl_return); } protected: private: std::shared_ptr _impl; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000034 15172120304 033176 xustar000000000 0000000 28 mtime=1776853188.4670000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnNewName.h0100644 0000000 0000000 00000002641 15172120304 032314 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/INewName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INewName.aidl */ #pragma once #include "aidl/android/aidl/tests/INewName.h" #include #include #ifndef __BIONIC__ #ifndef __assert2 #define __assert2(a,b,c,d) ((void)0) #endif #endif namespace aidl { namespace android { namespace aidl { namespace tests { class BnNewName : public ::ndk::BnCInterface { public: BnNewName(); virtual ~BnNewName(); protected: ::ndk::SpAIBinder createBinder() override; private: }; class INewNameDelegator : public BnNewName { public: explicit INewNameDelegator(const std::shared_ptr &impl) : _impl(impl) { } ::ndk::ScopedAStatus RealName(std::string* _aidl_return) override { return _impl->RealName(_aidl_return); } protected: private: std::shared_ptr _impl; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000034 15172120304 033176 xustar000000000 0000000 28 mtime=1776853188.4670000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnOldName.h0100644 0000000 0000000 00000002641 15172120304 032301 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/IOldName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IOldName.aidl */ #pragma once #include "aidl/android/aidl/tests/IOldName.h" #include #include #ifndef __BIONIC__ #ifndef __assert2 #define __assert2(a,b,c,d) ((void)0) #endif #endif namespace aidl { namespace android { namespace aidl { namespace tests { class BnOldName : public ::ndk::BnCInterface { public: BnOldName(); virtual ~BnOldName(); protected: ::ndk::SpAIBinder createBinder() override; private: }; class IOldNameDelegator : public BnOldName { public: explicit IOldNameDelegator(const std::shared_ptr &impl) : _impl(impl) { } ::ndk::ScopedAStatus RealName(std::string* _aidl_return) override { return _impl->RealName(_aidl_return); } protected: private: std::shared_ptr _impl; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000233 15172120304 033177 xustar000000000 0000000 127 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnOtherParcelableForToString.h 28 mtime=1776853188.4670000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnOtherParcel0100644 0000000 0000000 00000001254 15172120304 032743 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/OtherParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000226 15172120304 033201 xustar000000000 0000000 122 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnParcelableForToString.h 28 mtime=1776853188.4670000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnParcelableF0100644 0000000 0000000 00000001242 15172120304 032670 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ParcelableForToString.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000216 15172120304 033200 xustar000000000 0000000 114 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnRecursiveList.h 28 mtime=1776853188.4670000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnRecursiveLi0100644 0000000 0000000 00000001222 15172120304 032762 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/RecursiveList.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000225 15172120304 033200 xustar000000000 0000000 121 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnStructuredParcelable.h 28 mtime=1776853188.4670000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnStructuredP0100644 0000000 0000000 00000001240 15172120304 033012 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/StructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000214 15172120304 033176 xustar000000000 0000000 112 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnTestService.h 28 mtime=1776853188.4680000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnTestService0100644 0000000 0000000 00000043124 15172120304 032775 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ITestService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ITestService.aidl */ #pragma once #include "aidl/android/aidl/tests/ITestService.h" #include #include #ifndef __BIONIC__ #ifndef __assert2 #define __assert2(a,b,c,d) ((void)0) #endif #endif namespace aidl { namespace android { namespace aidl { namespace tests { class BnTestService : public ::ndk::BnCInterface { public: BnTestService(); virtual ~BnTestService(); protected: ::ndk::SpAIBinder createBinder() override; private: }; class ITestServiceDelegator : public BnTestService { public: explicit ITestServiceDelegator(const std::shared_ptr &impl) : _impl(impl) { } ::ndk::ScopedAStatus UnimplementedMethod(int32_t in_arg, int32_t* _aidl_return) override { return _impl->UnimplementedMethod(in_arg, _aidl_return); } ::ndk::ScopedAStatus Deprecated() override __attribute__((deprecated("to make sure we have something in system/tools/aidl which does a compile check of deprecated and make sure this is reflected in goldens"))) { return _impl->Deprecated(); } ::ndk::ScopedAStatus TestOneway() override { return _impl->TestOneway(); } ::ndk::ScopedAStatus RepeatBoolean(bool in_token, bool* _aidl_return) override { return _impl->RepeatBoolean(in_token, _aidl_return); } ::ndk::ScopedAStatus RepeatByte(int8_t in_token, int8_t* _aidl_return) override { return _impl->RepeatByte(in_token, _aidl_return); } ::ndk::ScopedAStatus RepeatChar(char16_t in_token, char16_t* _aidl_return) override { return _impl->RepeatChar(in_token, _aidl_return); } ::ndk::ScopedAStatus RepeatInt(int32_t in_token, int32_t* _aidl_return) override { return _impl->RepeatInt(in_token, _aidl_return); } ::ndk::ScopedAStatus RepeatLong(int64_t in_token, int64_t* _aidl_return) override { return _impl->RepeatLong(in_token, _aidl_return); } ::ndk::ScopedAStatus RepeatFloat(float in_token, float* _aidl_return) override { return _impl->RepeatFloat(in_token, _aidl_return); } ::ndk::ScopedAStatus RepeatDouble(double in_token, double* _aidl_return) override { return _impl->RepeatDouble(in_token, _aidl_return); } ::ndk::ScopedAStatus RepeatString(const std::string& in_token, std::string* _aidl_return) override { return _impl->RepeatString(in_token, _aidl_return); } ::ndk::ScopedAStatus RepeatByteEnum(::aidl::android::aidl::tests::ByteEnum in_token, ::aidl::android::aidl::tests::ByteEnum* _aidl_return) override { return _impl->RepeatByteEnum(in_token, _aidl_return); } ::ndk::ScopedAStatus RepeatIntEnum(::aidl::android::aidl::tests::IntEnum in_token, ::aidl::android::aidl::tests::IntEnum* _aidl_return) override { return _impl->RepeatIntEnum(in_token, _aidl_return); } ::ndk::ScopedAStatus RepeatLongEnum(::aidl::android::aidl::tests::LongEnum in_token, ::aidl::android::aidl::tests::LongEnum* _aidl_return) override { return _impl->RepeatLongEnum(in_token, _aidl_return); } ::ndk::ScopedAStatus ReverseBoolean(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override { return _impl->ReverseBoolean(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus ReverseByte(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override { return _impl->ReverseByte(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus ReverseChar(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override { return _impl->ReverseChar(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus ReverseInt(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override { return _impl->ReverseInt(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus ReverseLong(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override { return _impl->ReverseLong(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus ReverseFloat(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override { return _impl->ReverseFloat(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus ReverseDouble(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override { return _impl->ReverseDouble(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus ReverseString(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override { return _impl->ReverseString(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus ReverseByteEnum(const std::vector<::aidl::android::aidl::tests::ByteEnum>& in_input, std::vector<::aidl::android::aidl::tests::ByteEnum>* out_repeated, std::vector<::aidl::android::aidl::tests::ByteEnum>* _aidl_return) override { return _impl->ReverseByteEnum(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus ReverseIntEnum(const std::vector<::aidl::android::aidl::tests::IntEnum>& in_input, std::vector<::aidl::android::aidl::tests::IntEnum>* out_repeated, std::vector<::aidl::android::aidl::tests::IntEnum>* _aidl_return) override { return _impl->ReverseIntEnum(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus ReverseLongEnum(const std::vector<::aidl::android::aidl::tests::LongEnum>& in_input, std::vector<::aidl::android::aidl::tests::LongEnum>* out_repeated, std::vector<::aidl::android::aidl::tests::LongEnum>* _aidl_return) override { return _impl->ReverseLongEnum(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus GetOtherTestService(const std::string& in_name, std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>* _aidl_return) override { return _impl->GetOtherTestService(in_name, _aidl_return); } ::ndk::ScopedAStatus SetOtherTestService(const std::string& in_name, const std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>& in_service, bool* _aidl_return) override { return _impl->SetOtherTestService(in_name, in_service, _aidl_return); } ::ndk::ScopedAStatus VerifyName(const std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>& in_service, const std::string& in_name, bool* _aidl_return) override { return _impl->VerifyName(in_service, in_name, _aidl_return); } ::ndk::ScopedAStatus GetInterfaceArray(const std::vector& in_names, std::vector>* _aidl_return) override { return _impl->GetInterfaceArray(in_names, _aidl_return); } ::ndk::ScopedAStatus VerifyNamesWithInterfaceArray(const std::vector>& in_services, const std::vector& in_names, bool* _aidl_return) override { return _impl->VerifyNamesWithInterfaceArray(in_services, in_names, _aidl_return); } ::ndk::ScopedAStatus GetNullableInterfaceArray(const std::optional>>& in_names, std::optional>>* _aidl_return) override { return _impl->GetNullableInterfaceArray(in_names, _aidl_return); } ::ndk::ScopedAStatus VerifyNamesWithNullableInterfaceArray(const std::optional>>& in_services, const std::optional>>& in_names, bool* _aidl_return) override { return _impl->VerifyNamesWithNullableInterfaceArray(in_services, in_names, _aidl_return); } ::ndk::ScopedAStatus GetInterfaceList(const std::optional>>& in_names, std::optional>>* _aidl_return) override { return _impl->GetInterfaceList(in_names, _aidl_return); } ::ndk::ScopedAStatus VerifyNamesWithInterfaceList(const std::optional>>& in_services, const std::optional>>& in_names, bool* _aidl_return) override { return _impl->VerifyNamesWithInterfaceList(in_services, in_names, _aidl_return); } ::ndk::ScopedAStatus ReverseStringList(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override { return _impl->ReverseStringList(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus RepeatParcelFileDescriptor(const ::ndk::ScopedFileDescriptor& in_read, ::ndk::ScopedFileDescriptor* _aidl_return) override { return _impl->RepeatParcelFileDescriptor(in_read, _aidl_return); } ::ndk::ScopedAStatus ReverseParcelFileDescriptorArray(const std::vector<::ndk::ScopedFileDescriptor>& in_input, std::vector<::ndk::ScopedFileDescriptor>* out_repeated, std::vector<::ndk::ScopedFileDescriptor>* _aidl_return) override { return _impl->ReverseParcelFileDescriptorArray(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus ThrowServiceException(int32_t in_code) override { return _impl->ThrowServiceException(in_code); } ::ndk::ScopedAStatus RepeatNullableIntArray(const std::optional>& in_input, std::optional>* _aidl_return) override { return _impl->RepeatNullableIntArray(in_input, _aidl_return); } ::ndk::ScopedAStatus RepeatNullableByteEnumArray(const std::optional>& in_input, std::optional>* _aidl_return) override { return _impl->RepeatNullableByteEnumArray(in_input, _aidl_return); } ::ndk::ScopedAStatus RepeatNullableIntEnumArray(const std::optional>& in_input, std::optional>* _aidl_return) override { return _impl->RepeatNullableIntEnumArray(in_input, _aidl_return); } ::ndk::ScopedAStatus RepeatNullableLongEnumArray(const std::optional>& in_input, std::optional>* _aidl_return) override { return _impl->RepeatNullableLongEnumArray(in_input, _aidl_return); } ::ndk::ScopedAStatus RepeatNullableString(const std::optional& in_input, std::optional* _aidl_return) override { return _impl->RepeatNullableString(in_input, _aidl_return); } ::ndk::ScopedAStatus RepeatNullableStringList(const std::optional>>& in_input, std::optional>>* _aidl_return) override { return _impl->RepeatNullableStringList(in_input, _aidl_return); } ::ndk::ScopedAStatus RepeatNullableParcelable(const std::optional<::aidl::android::aidl::tests::ITestService::Empty>& in_input, std::optional<::aidl::android::aidl::tests::ITestService::Empty>* _aidl_return) override { return _impl->RepeatNullableParcelable(in_input, _aidl_return); } ::ndk::ScopedAStatus RepeatNullableParcelableArray(const std::optional>>& in_input, std::optional>>* _aidl_return) override { return _impl->RepeatNullableParcelableArray(in_input, _aidl_return); } ::ndk::ScopedAStatus RepeatNullableParcelableList(const std::optional>>& in_input, std::optional>>* _aidl_return) override { return _impl->RepeatNullableParcelableList(in_input, _aidl_return); } ::ndk::ScopedAStatus TakesAnIBinder(const ::ndk::SpAIBinder& in_input) override { return _impl->TakesAnIBinder(in_input); } ::ndk::ScopedAStatus TakesANullableIBinder(const ::ndk::SpAIBinder& in_input) override { return _impl->TakesANullableIBinder(in_input); } ::ndk::ScopedAStatus TakesAnIBinderList(const std::vector<::ndk::SpAIBinder>& in_input) override { return _impl->TakesAnIBinderList(in_input); } ::ndk::ScopedAStatus TakesANullableIBinderList(const std::optional>& in_input) override { return _impl->TakesANullableIBinderList(in_input); } ::ndk::ScopedAStatus RepeatUtf8CppString(const std::string& in_token, std::string* _aidl_return) override { return _impl->RepeatUtf8CppString(in_token, _aidl_return); } ::ndk::ScopedAStatus RepeatNullableUtf8CppString(const std::optional& in_token, std::optional* _aidl_return) override { return _impl->RepeatNullableUtf8CppString(in_token, _aidl_return); } ::ndk::ScopedAStatus ReverseUtf8CppString(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override { return _impl->ReverseUtf8CppString(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus ReverseNullableUtf8CppString(const std::optional>>& in_input, std::optional>>* out_repeated, std::optional>>* _aidl_return) override { return _impl->ReverseNullableUtf8CppString(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus ReverseUtf8CppStringList(const std::optional>>& in_input, std::optional>>* out_repeated, std::optional>>* _aidl_return) override { return _impl->ReverseUtf8CppStringList(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus GetCallback(bool in_return_null, std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>* _aidl_return) override { return _impl->GetCallback(in_return_null, _aidl_return); } ::ndk::ScopedAStatus FillOutStructuredParcelable(::aidl::android::aidl::tests::StructuredParcelable* in_parcel) override { return _impl->FillOutStructuredParcelable(in_parcel); } ::ndk::ScopedAStatus RepeatExtendableParcelable(const ::aidl::android::aidl::tests::extension::ExtendableParcelable& in_ep, ::aidl::android::aidl::tests::extension::ExtendableParcelable* out_ep2) override { return _impl->RepeatExtendableParcelable(in_ep, out_ep2); } ::ndk::ScopedAStatus ReverseList(const ::aidl::android::aidl::tests::RecursiveList& in_list, ::aidl::android::aidl::tests::RecursiveList* _aidl_return) override { return _impl->ReverseList(in_list, _aidl_return); } ::ndk::ScopedAStatus ReverseIBinderArray(const std::vector<::ndk::SpAIBinder>& in_input, std::vector<::ndk::SpAIBinder>* out_repeated, std::vector<::ndk::SpAIBinder>* _aidl_return) override { return _impl->ReverseIBinderArray(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus ReverseNullableIBinderArray(const std::optional>& in_input, std::optional>* out_repeated, std::optional>* _aidl_return) override { return _impl->ReverseNullableIBinderArray(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus RepeatSimpleParcelable(const ::aidl::android::aidl::tests::SimpleParcelable& in_input, ::aidl::android::aidl::tests::SimpleParcelable* out_repeat, ::aidl::android::aidl::tests::SimpleParcelable* _aidl_return) override { return _impl->RepeatSimpleParcelable(in_input, out_repeat, _aidl_return); } ::ndk::ScopedAStatus ReverseSimpleParcelables(const std::vector<::aidl::android::aidl::tests::SimpleParcelable>& in_input, std::vector<::aidl::android::aidl::tests::SimpleParcelable>* out_repeated, std::vector<::aidl::android::aidl::tests::SimpleParcelable>* _aidl_return) override { return _impl->ReverseSimpleParcelables(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus GetOldNameInterface(std::shared_ptr<::aidl::android::aidl::tests::IOldName>* _aidl_return) override { return _impl->GetOldNameInterface(_aidl_return); } ::ndk::ScopedAStatus GetNewNameInterface(std::shared_ptr<::aidl::android::aidl::tests::INewName>* _aidl_return) override { return _impl->GetNewNameInterface(_aidl_return); } ::ndk::ScopedAStatus GetUnionTags(const std::vector<::aidl::android::aidl::tests::Union>& in_input, std::vector<::aidl::android::aidl::tests::Union::Tag>* _aidl_return) override { return _impl->GetUnionTags(in_input, _aidl_return); } ::ndk::ScopedAStatus GetCppJavaTests(::ndk::SpAIBinder* _aidl_return) override { return _impl->GetCppJavaTests(_aidl_return); } ::ndk::ScopedAStatus getBackendType(::aidl::android::aidl::tests::BackendType* _aidl_return) override { return _impl->getBackendType(_aidl_return); } ::ndk::ScopedAStatus GetCircular(::aidl::android::aidl::tests::CircularParcelable* out_cp, std::shared_ptr<::aidl::android::aidl::tests::ICircular>* _aidl_return) override { return _impl->GetCircular(out_cp, _aidl_return); } protected: private: std::shared_ptr _impl; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000034 15172120304 033176 xustar000000000 0000000 28 mtime=1776853188.4680000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnUnion.h0100644 0000000 0000000 00000001202 15172120304 032042 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/Union.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/Union.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000214 15172120304 033176 xustar000000000 0000000 112 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnUnionWithFd.h 28 mtime=1776853188.4680000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnUnionWithFd0100644 0000000 0000000 00000001216 15172120304 032727 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/UnionWithFd.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/UnionWithFd.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000222 15172120304 033175 xustar000000000 0000000 118 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpArrayOfInterfaces.h 28 mtime=1776853188.4680000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpArrayOfInte0100644 0000000 0000000 00000001232 15172120304 032714 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ArrayOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ArrayOfInterfaces.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000214 15172120304 033176 xustar000000000 0000000 112 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpBackendType.h 28 mtime=1776853188.4680000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpBackendType0100644 0000000 0000000 00000001206 15172120304 032723 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/BackendType.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/BackendType.aidl */ #error TODO(b/111362593) enums do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000034 15172120304 033176 xustar000000000 0000000 28 mtime=1776853188.4680000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpByteEnum.h0100644 0000000 0000000 00000001200 15172120304 032502 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ByteEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl */ #error TODO(b/111362593) enums do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000034 15172120304 033176 xustar000000000 0000000 28 mtime=1776853188.4680000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpCircular.h0100644 0000000 0000000 00000002142 15172120304 032524 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ICircular.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ICircular.aidl */ #pragma once #include "aidl/android/aidl/tests/ICircular.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { class BpCircular : public ::ndk::BpCInterface { public: explicit BpCircular(const ::ndk::SpAIBinder& binder); virtual ~BpCircular(); ::ndk::ScopedAStatus GetTestService(std::shared_ptr<::aidl::android::aidl::tests::ITestService>* _aidl_return) override; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000223 15172120304 033176 xustar000000000 0000000 119 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpCircularParcelable.h 28 mtime=1776853188.4680000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpCircularPar0100644 0000000 0000000 00000001234 15172120304 032742 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/CircularParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000227 15172120304 033202 xustar000000000 0000000 123 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpConstantExpressionEnum.h 28 mtime=1776853188.4680000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpConstantExp0100644 0000000 0000000 00000001234 15172120304 033001 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ConstantExpressionEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl */ #error TODO(b/111362593) enums do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000213 15172120304 033175 xustar000000000 0000000 111 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpDeprecated.h 28 mtime=1776853188.4680000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpDeprecated.0100644 0000000 0000000 00000002031 15172120304 032645 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/IDeprecated.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IDeprecated.aidl */ #pragma once #include "aidl/android/aidl/tests/IDeprecated.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { class __attribute__((deprecated("test"))) BpDeprecated : public ::ndk::BpCInterface { public: explicit BpDeprecated(const ::ndk::SpAIBinder& binder); virtual ~BpDeprecated(); }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000217 15172120304 033201 xustar000000000 0000000 115 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpDeprecatedEnum.h 28 mtime=1776853188.4690000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpDeprecatedE0100644 0000000 0000000 00000001214 15172120304 032676 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/DeprecatedEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedEnum.aidl */ #error TODO(b/111362593) enums do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000225 15172120304 033200 xustar000000000 0000000 121 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpDeprecatedParcelable.h 28 mtime=1776853188.4690000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpDeprecatedP0100644 0000000 0000000 00000001240 15172120304 032710 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/DeprecatedParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedParcelable.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000212 15172120304 033174 xustar000000000 0000000 110 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpFixedSize.h 28 mtime=1776853188.4690000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpFixedSize.h0100644 0000000 0000000 00000001212 15172120304 032647 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/FixedSize.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/FixedSize.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000234 15172120304 033200 xustar000000000 0000000 128 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpGenericStructuredParcelable.h 28 mtime=1776853188.4690000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpGenericStru0100644 0000000 0000000 00000001256 15172120304 032771 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/GenericStructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000034 15172120304 033176 xustar000000000 0000000 28 mtime=1776853188.4690000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpIntEnum.h0100644 0000000 0000000 00000001176 15172120304 032345 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/IntEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl */ #error TODO(b/111362593) enums do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000221 15172120304 033174 xustar000000000 0000000 117 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpListOfInterfaces.h 28 mtime=1776853188.4690000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpListOfInter0100644 0000000 0000000 00000001230 15172120304 032731 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ListOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ListOfInterfaces.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000034 15172120304 033176 xustar000000000 0000000 28 mtime=1776853188.4690000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpLongEnum.h0100644 0000000 0000000 00000001200 15172120304 032476 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/LongEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl */ #error TODO(b/111362593) enums do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000216 15172120304 033200 xustar000000000 0000000 114 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpNamedCallback.h 28 mtime=1776853188.4690000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpNamedCallba0100644 0000000 0000000 00000002116 15172120304 032656 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/INamedCallback.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl */ #pragma once #include "aidl/android/aidl/tests/INamedCallback.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { class BpNamedCallback : public ::ndk::BpCInterface { public: explicit BpNamedCallback(const ::ndk::SpAIBinder& binder); virtual ~BpNamedCallback(); ::ndk::ScopedAStatus GetName(std::string* _aidl_return) override; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000034 15172120304 033176 xustar000000000 0000000 28 mtime=1776853188.4690000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpNewName.h0100644 0000000 0000000 00000002045 15172120304 032314 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/INewName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INewName.aidl */ #pragma once #include "aidl/android/aidl/tests/INewName.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { class BpNewName : public ::ndk::BpCInterface { public: explicit BpNewName(const ::ndk::SpAIBinder& binder); virtual ~BpNewName(); ::ndk::ScopedAStatus RealName(std::string* _aidl_return) override; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000034 15172120304 033176 xustar000000000 0000000 28 mtime=1776853188.4690000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpOldName.h0100644 0000000 0000000 00000002045 15172120304 032301 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/IOldName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IOldName.aidl */ #pragma once #include "aidl/android/aidl/tests/IOldName.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { class BpOldName : public ::ndk::BpCInterface { public: explicit BpOldName(const ::ndk::SpAIBinder& binder); virtual ~BpOldName(); ::ndk::ScopedAStatus RealName(std::string* _aidl_return) override; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000233 15172120304 033177 xustar000000000 0000000 127 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpOtherParcelableForToString.h 28 mtime=1776853188.4690000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpOtherParcel0100644 0000000 0000000 00000001254 15172120304 032745 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/OtherParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000226 15172120304 033201 xustar000000000 0000000 122 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpParcelableForToString.h 28 mtime=1776853188.4690000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpParcelableF0100644 0000000 0000000 00000001242 15172120304 032672 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ParcelableForToString.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000216 15172120304 033200 xustar000000000 0000000 114 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpRecursiveList.h 28 mtime=1776853188.4690000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpRecursiveLi0100644 0000000 0000000 00000001222 15172120304 032764 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/RecursiveList.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000225 15172120304 033200 xustar000000000 0000000 121 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpStructuredParcelable.h 28 mtime=1776853188.4690000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpStructuredP0100644 0000000 0000000 00000001240 15172120304 033014 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/StructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000214 15172120304 033176 xustar000000000 0000000 112 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpTestService.h 28 mtime=1776853188.4690000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpTestService0100644 0000000 0000000 00000030751 15172120304 033001 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ITestService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ITestService.aidl */ #pragma once #include "aidl/android/aidl/tests/ITestService.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { class BpTestService : public ::ndk::BpCInterface { public: explicit BpTestService(const ::ndk::SpAIBinder& binder); virtual ~BpTestService(); ::ndk::ScopedAStatus UnimplementedMethod(int32_t in_arg, int32_t* _aidl_return) override; ::ndk::ScopedAStatus Deprecated() override __attribute__((deprecated("to make sure we have something in system/tools/aidl which does a compile check of deprecated and make sure this is reflected in goldens"))); ::ndk::ScopedAStatus TestOneway() override; ::ndk::ScopedAStatus RepeatBoolean(bool in_token, bool* _aidl_return) override; ::ndk::ScopedAStatus RepeatByte(int8_t in_token, int8_t* _aidl_return) override; ::ndk::ScopedAStatus RepeatChar(char16_t in_token, char16_t* _aidl_return) override; ::ndk::ScopedAStatus RepeatInt(int32_t in_token, int32_t* _aidl_return) override; ::ndk::ScopedAStatus RepeatLong(int64_t in_token, int64_t* _aidl_return) override; ::ndk::ScopedAStatus RepeatFloat(float in_token, float* _aidl_return) override; ::ndk::ScopedAStatus RepeatDouble(double in_token, double* _aidl_return) override; ::ndk::ScopedAStatus RepeatString(const std::string& in_token, std::string* _aidl_return) override; ::ndk::ScopedAStatus RepeatByteEnum(::aidl::android::aidl::tests::ByteEnum in_token, ::aidl::android::aidl::tests::ByteEnum* _aidl_return) override; ::ndk::ScopedAStatus RepeatIntEnum(::aidl::android::aidl::tests::IntEnum in_token, ::aidl::android::aidl::tests::IntEnum* _aidl_return) override; ::ndk::ScopedAStatus RepeatLongEnum(::aidl::android::aidl::tests::LongEnum in_token, ::aidl::android::aidl::tests::LongEnum* _aidl_return) override; ::ndk::ScopedAStatus ReverseBoolean(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseByte(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseChar(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseInt(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseLong(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseFloat(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseDouble(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseString(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseByteEnum(const std::vector<::aidl::android::aidl::tests::ByteEnum>& in_input, std::vector<::aidl::android::aidl::tests::ByteEnum>* out_repeated, std::vector<::aidl::android::aidl::tests::ByteEnum>* _aidl_return) override; ::ndk::ScopedAStatus ReverseIntEnum(const std::vector<::aidl::android::aidl::tests::IntEnum>& in_input, std::vector<::aidl::android::aidl::tests::IntEnum>* out_repeated, std::vector<::aidl::android::aidl::tests::IntEnum>* _aidl_return) override; ::ndk::ScopedAStatus ReverseLongEnum(const std::vector<::aidl::android::aidl::tests::LongEnum>& in_input, std::vector<::aidl::android::aidl::tests::LongEnum>* out_repeated, std::vector<::aidl::android::aidl::tests::LongEnum>* _aidl_return) override; ::ndk::ScopedAStatus GetOtherTestService(const std::string& in_name, std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>* _aidl_return) override; ::ndk::ScopedAStatus SetOtherTestService(const std::string& in_name, const std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>& in_service, bool* _aidl_return) override; ::ndk::ScopedAStatus VerifyName(const std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>& in_service, const std::string& in_name, bool* _aidl_return) override; ::ndk::ScopedAStatus GetInterfaceArray(const std::vector& in_names, std::vector>* _aidl_return) override; ::ndk::ScopedAStatus VerifyNamesWithInterfaceArray(const std::vector>& in_services, const std::vector& in_names, bool* _aidl_return) override; ::ndk::ScopedAStatus GetNullableInterfaceArray(const std::optional>>& in_names, std::optional>>* _aidl_return) override; ::ndk::ScopedAStatus VerifyNamesWithNullableInterfaceArray(const std::optional>>& in_services, const std::optional>>& in_names, bool* _aidl_return) override; ::ndk::ScopedAStatus GetInterfaceList(const std::optional>>& in_names, std::optional>>* _aidl_return) override; ::ndk::ScopedAStatus VerifyNamesWithInterfaceList(const std::optional>>& in_services, const std::optional>>& in_names, bool* _aidl_return) override; ::ndk::ScopedAStatus ReverseStringList(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus RepeatParcelFileDescriptor(const ::ndk::ScopedFileDescriptor& in_read, ::ndk::ScopedFileDescriptor* _aidl_return) override; ::ndk::ScopedAStatus ReverseParcelFileDescriptorArray(const std::vector<::ndk::ScopedFileDescriptor>& in_input, std::vector<::ndk::ScopedFileDescriptor>* out_repeated, std::vector<::ndk::ScopedFileDescriptor>* _aidl_return) override; ::ndk::ScopedAStatus ThrowServiceException(int32_t in_code) override; ::ndk::ScopedAStatus RepeatNullableIntArray(const std::optional>& in_input, std::optional>* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableByteEnumArray(const std::optional>& in_input, std::optional>* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableIntEnumArray(const std::optional>& in_input, std::optional>* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableLongEnumArray(const std::optional>& in_input, std::optional>* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableString(const std::optional& in_input, std::optional* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableStringList(const std::optional>>& in_input, std::optional>>* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableParcelable(const std::optional<::aidl::android::aidl::tests::ITestService::Empty>& in_input, std::optional<::aidl::android::aidl::tests::ITestService::Empty>* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableParcelableArray(const std::optional>>& in_input, std::optional>>* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableParcelableList(const std::optional>>& in_input, std::optional>>* _aidl_return) override; ::ndk::ScopedAStatus TakesAnIBinder(const ::ndk::SpAIBinder& in_input) override; ::ndk::ScopedAStatus TakesANullableIBinder(const ::ndk::SpAIBinder& in_input) override; ::ndk::ScopedAStatus TakesAnIBinderList(const std::vector<::ndk::SpAIBinder>& in_input) override; ::ndk::ScopedAStatus TakesANullableIBinderList(const std::optional>& in_input) override; ::ndk::ScopedAStatus RepeatUtf8CppString(const std::string& in_token, std::string* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableUtf8CppString(const std::optional& in_token, std::optional* _aidl_return) override; ::ndk::ScopedAStatus ReverseUtf8CppString(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseNullableUtf8CppString(const std::optional>>& in_input, std::optional>>* out_repeated, std::optional>>* _aidl_return) override; ::ndk::ScopedAStatus ReverseUtf8CppStringList(const std::optional>>& in_input, std::optional>>* out_repeated, std::optional>>* _aidl_return) override; ::ndk::ScopedAStatus GetCallback(bool in_return_null, std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>* _aidl_return) override; ::ndk::ScopedAStatus FillOutStructuredParcelable(::aidl::android::aidl::tests::StructuredParcelable* in_parcel) override; ::ndk::ScopedAStatus RepeatExtendableParcelable(const ::aidl::android::aidl::tests::extension::ExtendableParcelable& in_ep, ::aidl::android::aidl::tests::extension::ExtendableParcelable* out_ep2) override; ::ndk::ScopedAStatus ReverseList(const ::aidl::android::aidl::tests::RecursiveList& in_list, ::aidl::android::aidl::tests::RecursiveList* _aidl_return) override; ::ndk::ScopedAStatus ReverseIBinderArray(const std::vector<::ndk::SpAIBinder>& in_input, std::vector<::ndk::SpAIBinder>* out_repeated, std::vector<::ndk::SpAIBinder>* _aidl_return) override; ::ndk::ScopedAStatus ReverseNullableIBinderArray(const std::optional>& in_input, std::optional>* out_repeated, std::optional>* _aidl_return) override; ::ndk::ScopedAStatus RepeatSimpleParcelable(const ::aidl::android::aidl::tests::SimpleParcelable& in_input, ::aidl::android::aidl::tests::SimpleParcelable* out_repeat, ::aidl::android::aidl::tests::SimpleParcelable* _aidl_return) override; ::ndk::ScopedAStatus ReverseSimpleParcelables(const std::vector<::aidl::android::aidl::tests::SimpleParcelable>& in_input, std::vector<::aidl::android::aidl::tests::SimpleParcelable>* out_repeated, std::vector<::aidl::android::aidl::tests::SimpleParcelable>* _aidl_return) override; ::ndk::ScopedAStatus GetOldNameInterface(std::shared_ptr<::aidl::android::aidl::tests::IOldName>* _aidl_return) override; ::ndk::ScopedAStatus GetNewNameInterface(std::shared_ptr<::aidl::android::aidl::tests::INewName>* _aidl_return) override; ::ndk::ScopedAStatus GetUnionTags(const std::vector<::aidl::android::aidl::tests::Union>& in_input, std::vector<::aidl::android::aidl::tests::Union::Tag>* _aidl_return) override; ::ndk::ScopedAStatus GetCppJavaTests(::ndk::SpAIBinder* _aidl_return) override; ::ndk::ScopedAStatus getBackendType(::aidl::android::aidl::tests::BackendType* _aidl_return) override; ::ndk::ScopedAStatus GetCircular(::aidl::android::aidl::tests::CircularParcelable* out_cp, std::shared_ptr<::aidl::android::aidl::tests::ICircular>* _aidl_return) override; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000034 15172120304 033176 xustar000000000 0000000 28 mtime=1776853188.4690000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpUnion.h0100644 0000000 0000000 00000001202 15172120304 032044 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/Union.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/Union.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000214 15172120304 033176 xustar000000000 0000000 112 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpUnionWithFd.h 28 mtime=1776853188.4690000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpUnionWithFd0100644 0000000 0000000 00000001216 15172120304 032731 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/UnionWithFd.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/UnionWithFd.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000034 15172120304 033176 xustar000000000 0000000 28 mtime=1776853188.4690000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/ByteEnum.h0100644 0000000 0000000 00000003672 15172120304 032237 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ByteEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl */ #pragma once #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { enum class ByteEnum : int8_t { FOO = 1, BAR = 2, BAZ = 3, }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(ByteEnum val) { switch(val) { case ByteEnum::FOO: return "FOO"; case ByteEnum::BAR: return "BAR"; case ByteEnum::BAZ: return "BAZ"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::tests::ByteEnum::FOO, aidl::android::aidl::tests::ByteEnum::BAR, aidl::android::aidl::tests::ByteEnum::BAZ, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000221 15172120304 033174 xustar000000000 0000000 117 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/CircularParcelable.h 28 mtime=1776853188.4700000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/CircularParce0100644 0000000 0000000 00000004753 15172120304 033001 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/CircularParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl::android::aidl::tests { class ITestService; } // namespace aidl::android::aidl::tests namespace aidl { namespace android { namespace aidl { namespace tests { class CircularParcelable { public: typedef std::false_type fixed_size; static const char* descriptor; std::shared_ptr<::aidl::android::aidl::tests::ITestService> testService; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const CircularParcelable& _rhs) const { return std::tie(testService) == std::tie(_rhs.testService); } inline bool operator<(const CircularParcelable& _rhs) const { return std::tie(testService) < std::tie(_rhs.testService); } inline bool operator!=(const CircularParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const CircularParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const CircularParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const CircularParcelable& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "CircularParcelable{"; _aidl_os << "testService: " << ::android::internal::ToString(testService); _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000225 15172120304 033200 xustar000000000 0000000 121 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/ConstantExpressionEnum.h 28 mtime=1776853188.4700000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/ConstantExpre0100644 0000000 0000000 00000005175 15172120304 033056 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ConstantExpressionEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl */ #pragma once #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { enum class ConstantExpressionEnum : int32_t { decInt32_1 = 1, decInt32_2 = 1, decInt64_1 = 1, decInt64_2 = 1, decInt64_3 = 1, decInt64_4 = 1, hexInt32_1 = 1, hexInt32_2 = 1, hexInt32_3 = 1, hexInt64_1 = 1, }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(ConstantExpressionEnum val) { switch(val) { case ConstantExpressionEnum::decInt32_1: return "decInt32_1"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::tests::ConstantExpressionEnum::decInt32_1, aidl::android::aidl::tests::ConstantExpressionEnum::decInt32_2, aidl::android::aidl::tests::ConstantExpressionEnum::decInt64_1, aidl::android::aidl::tests::ConstantExpressionEnum::decInt64_2, aidl::android::aidl::tests::ConstantExpressionEnum::decInt64_3, aidl::android::aidl::tests::ConstantExpressionEnum::decInt64_4, aidl::android::aidl::tests::ConstantExpressionEnum::hexInt32_1, aidl::android::aidl::tests::ConstantExpressionEnum::hexInt32_2, aidl::android::aidl::tests::ConstantExpressionEnum::hexInt32_3, aidl::android::aidl::tests::ConstantExpressionEnum::hexInt64_1, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000215 15172120304 033177 xustar000000000 0000000 113 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/DeprecatedEnum.h 28 mtime=1776853188.4700000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/DeprecatedEnu0100644 0000000 0000000 00000004305 15172120304 032763 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/DeprecatedEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedEnum.aidl */ #pragma once #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { enum class __attribute__((deprecated("test"))) DeprecatedEnum : int32_t { A = 0, B = 1, C = 2, }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" [[nodiscard]] static inline std::string toString(DeprecatedEnum val) { switch(val) { case DeprecatedEnum::A: return "A"; case DeprecatedEnum::B: return "B"; case DeprecatedEnum::C: return "C"; default: return std::to_string(static_cast(val)); } } #pragma clang diagnostic pop } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" #pragma clang diagnostic ignored "-Wdeprecated-declarations" template <> constexpr inline std::array enum_values = { aidl::android::aidl::tests::DeprecatedEnum::A, aidl::android::aidl::tests::DeprecatedEnum::B, aidl::android::aidl::tests::DeprecatedEnum::C, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000223 15172120304 033176 xustar000000000 0000000 119 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/DeprecatedParcelable.h 28 mtime=1776853188.4700000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/DeprecatedPar0100644 0000000 0000000 00000004261 15172120304 032757 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/DeprecatedParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedParcelable.aidl */ #pragma once #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { class __attribute__((deprecated("test"))) DeprecatedParcelable { public: typedef std::false_type fixed_size; static const char* descriptor; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const DeprecatedParcelable&) const { return std::tie() == std::tie(); } inline bool operator<(const DeprecatedParcelable&) const { return std::tie() < std::tie(); } inline bool operator!=(const DeprecatedParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const DeprecatedParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const DeprecatedParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const DeprecatedParcelable& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "DeprecatedParcelable{"; _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000034 15172120304 033176 xustar000000000 0000000 28 mtime=1776853188.4700000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/FixedSize.h0100644 0000000 0000000 00000027613 15172120304 032402 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/FixedSize.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/FixedSize.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace aidl { namespace android { namespace aidl { namespace tests { class FixedSize { public: typedef std::false_type fixed_size; static const char* descriptor; class FixedUnion { public: typedef std::true_type fixed_size; static const char* descriptor; enum class Tag : int8_t { booleanValue = 0, byteValue = 1, charValue = 2, intValue = 3, longValue = 4, floatValue = 5, doubleValue = 6, enumValue = 7, }; // Expose tag symbols for legacy code static const inline Tag booleanValue = Tag::booleanValue; static const inline Tag byteValue = Tag::byteValue; static const inline Tag charValue = Tag::charValue; static const inline Tag intValue = Tag::intValue; static const inline Tag longValue = Tag::longValue; static const inline Tag floatValue = Tag::floatValue; static const inline Tag doubleValue = Tag::doubleValue; static const inline Tag enumValue = Tag::enumValue; template using _at = typename std::tuple_element(_Tag), std::tuple>::type; template static FixedUnion make(_Type&& _arg) { FixedUnion _inst; _inst.set<_Tag>(std::forward<_Type>(_arg)); return _inst; } constexpr Tag getTag() const { return _tag; } template const _at<_Tag>& get() const { if (_Tag != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return *(_at<_Tag>*)(&_value); } template _at<_Tag>& get() { if (_Tag != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return *(_at<_Tag>*)(&_value); } template void set(_Type&& _arg) { _tag = _Tag; get<_Tag>() = std::forward<_Type>(_arg); } binder_status_t readFromParcel(const AParcel* _parcel); binder_status_t writeToParcel(AParcel* _parcel) const; static int _cmp(const FixedUnion& _lhs, const FixedUnion& _rhs) { return _cmp_value(_lhs.getTag(), _rhs.getTag()) || _cmp_value_at(_lhs, _rhs); } template static int _cmp_value_at(const FixedUnion& _lhs, const FixedUnion& _rhs) { if constexpr (_Tag == booleanValue) { return _cmp_value(_lhs.get<_Tag>(), _rhs.get<_Tag>()); } else { return (_lhs.getTag() == _Tag) ? _cmp_value(_lhs.get<_Tag>(), _rhs.get<_Tag>()) : _cmp_value_at(static_cast(_Tag)-1)>(_lhs, _rhs); } } template static int _cmp_value(const _Type& _lhs, const _Type& _rhs) { return (_lhs == _rhs) ? 0 : (_lhs < _rhs) ? -1 : 1; } inline bool operator!=(const FixedUnion&_rhs) const { return _cmp(*this, _rhs) != 0; } inline bool operator<(const FixedUnion&_rhs) const { return _cmp(*this, _rhs) < 0; } inline bool operator<=(const FixedUnion&_rhs) const { return _cmp(*this, _rhs) <= 0; } inline bool operator==(const FixedUnion&_rhs) const { return _cmp(*this, _rhs) == 0; } inline bool operator>(const FixedUnion&_rhs) const { return _cmp(*this, _rhs) > 0; } inline bool operator>=(const FixedUnion&_rhs) const { return _cmp(*this, _rhs) >= 0; } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream os; os << "FixedUnion{"; switch (getTag()) { case booleanValue: os << "booleanValue: " << ::android::internal::ToString(get()); break; case byteValue: os << "byteValue: " << ::android::internal::ToString(get()); break; case charValue: os << "charValue: " << ::android::internal::ToString(get()); break; case intValue: os << "intValue: " << ::android::internal::ToString(get()); break; case longValue: os << "longValue: " << ::android::internal::ToString(get()); break; case floatValue: os << "floatValue: " << ::android::internal::ToString(get()); break; case doubleValue: os << "doubleValue: " << ::android::internal::ToString(get()); break; case enumValue: os << "enumValue: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: Tag _tag = booleanValue; union _value_t { _value_t() {} ~_value_t() {} bool booleanValue __attribute__((aligned (1))) = bool(false); int8_t byteValue __attribute__((aligned (1))); char16_t charValue __attribute__((aligned (2))); int32_t intValue __attribute__((aligned (4))); int64_t longValue __attribute__((aligned (8))); float floatValue __attribute__((aligned (4))); double doubleValue __attribute__((aligned (8))); ::aidl::android::aidl::tests::LongEnum enumValue __attribute__((aligned (8))); } _value; }; class FixedParcelable { public: typedef std::true_type fixed_size; static const char* descriptor; bool booleanValue __attribute__((aligned (1))) = false; int8_t byteValue __attribute__((aligned (1))) = 0; char16_t charValue __attribute__((aligned (2))) = '\0'; int32_t intValue __attribute__((aligned (4))) = 0; int64_t longValue __attribute__((aligned (8))) = 0L; float floatValue __attribute__((aligned (4))) = 0.000000f; double doubleValue __attribute__((aligned (8))) = 0.000000; ::aidl::android::aidl::tests::LongEnum enumValue __attribute__((aligned (8))) = ::aidl::android::aidl::tests::LongEnum::FOO; ::aidl::android::aidl::tests::FixedSize::FixedUnion parcelableValue; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const FixedParcelable& _rhs) const { return std::tie(booleanValue, byteValue, charValue, intValue, longValue, floatValue, doubleValue, enumValue, parcelableValue) == std::tie(_rhs.booleanValue, _rhs.byteValue, _rhs.charValue, _rhs.intValue, _rhs.longValue, _rhs.floatValue, _rhs.doubleValue, _rhs.enumValue, _rhs.parcelableValue); } inline bool operator<(const FixedParcelable& _rhs) const { return std::tie(booleanValue, byteValue, charValue, intValue, longValue, floatValue, doubleValue, enumValue, parcelableValue) < std::tie(_rhs.booleanValue, _rhs.byteValue, _rhs.charValue, _rhs.intValue, _rhs.longValue, _rhs.floatValue, _rhs.doubleValue, _rhs.enumValue, _rhs.parcelableValue); } inline bool operator!=(const FixedParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const FixedParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const FixedParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const FixedParcelable& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "FixedParcelable{"; _aidl_os << "booleanValue: " << ::android::internal::ToString(booleanValue); _aidl_os << ", byteValue: " << ::android::internal::ToString(byteValue); _aidl_os << ", charValue: " << ::android::internal::ToString(charValue); _aidl_os << ", intValue: " << ::android::internal::ToString(intValue); _aidl_os << ", longValue: " << ::android::internal::ToString(longValue); _aidl_os << ", floatValue: " << ::android::internal::ToString(floatValue); _aidl_os << ", doubleValue: " << ::android::internal::ToString(doubleValue); _aidl_os << ", enumValue: " << ::android::internal::ToString(enumValue); _aidl_os << ", parcelableValue: " << ::android::internal::ToString(parcelableValue); _aidl_os << "}"; return _aidl_os.str(); } }; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const FixedSize&) const { return std::tie() == std::tie(); } inline bool operator<(const FixedSize&) const { return std::tie() < std::tie(); } inline bool operator!=(const FixedSize& _rhs) const { return !(*this == _rhs); } inline bool operator>(const FixedSize& _rhs) const { return _rhs < *this; } inline bool operator>=(const FixedSize& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const FixedSize& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "FixedSize{"; _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(FixedSize::FixedUnion::Tag val) { switch(val) { case FixedSize::FixedUnion::Tag::booleanValue: return "booleanValue"; case FixedSize::FixedUnion::Tag::byteValue: return "byteValue"; case FixedSize::FixedUnion::Tag::charValue: return "charValue"; case FixedSize::FixedUnion::Tag::intValue: return "intValue"; case FixedSize::FixedUnion::Tag::longValue: return "longValue"; case FixedSize::FixedUnion::Tag::floatValue: return "floatValue"; case FixedSize::FixedUnion::Tag::doubleValue: return "doubleValue"; case FixedSize::FixedUnion::Tag::enumValue: return "enumValue"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::tests::FixedSize::FixedUnion::Tag::booleanValue, aidl::android::aidl::tests::FixedSize::FixedUnion::Tag::byteValue, aidl::android::aidl::tests::FixedSize::FixedUnion::Tag::charValue, aidl::android::aidl::tests::FixedSize::FixedUnion::Tag::intValue, aidl::android::aidl::tests::FixedSize::FixedUnion::Tag::longValue, aidl::android::aidl::tests::FixedSize::FixedUnion::Tag::floatValue, aidl::android::aidl::tests::FixedSize::FixedUnion::Tag::doubleValue, aidl::android::aidl::tests::FixedSize::FixedUnion::Tag::enumValue, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000232 15172120304 033176 xustar000000000 0000000 126 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/GenericStructuredParcelable.h 28 mtime=1776853188.4700000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/GenericStruct0100644 0000000 0000000 00000012110 15172120304 033025 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/GenericStructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl */ #pragma once #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { template class GenericStructuredParcelable { public: typedef std::false_type fixed_size; static const char* descriptor; int32_t a = 0; int32_t b = 0; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const GenericStructuredParcelable& _rhs) const { return std::tie(a, b) == std::tie(_rhs.a, _rhs.b); } inline bool operator<(const GenericStructuredParcelable& _rhs) const { return std::tie(a, b) < std::tie(_rhs.a, _rhs.b); } inline bool operator!=(const GenericStructuredParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const GenericStructuredParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const GenericStructuredParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const GenericStructuredParcelable& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "GenericStructuredParcelable{"; _aidl_os << "a: " << ::android::internal::ToString(a); _aidl_os << ", b: " << ::android::internal::ToString(b); _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl #include "aidl/android/aidl/tests/GenericStructuredParcelable.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { template const char* GenericStructuredParcelable::descriptor = "android.aidl.tests.GenericStructuredParcelable"; template binder_status_t GenericStructuredParcelable::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &a); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &b); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } template binder_status_t GenericStructuredParcelable::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, a); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, b); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000034 15172120304 033176 xustar000000000 0000000 28 mtime=1776853188.4700000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/ICircular.h0100644 0000000 0000000 00000004367 15172120304 032366 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ICircular.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ICircular.aidl */ #pragma once #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl::android::aidl::tests { class ITestService; } // namespace aidl::android::aidl::tests namespace aidl { namespace android { namespace aidl { namespace tests { class ICircularDelegator; class ICircular : public ::ndk::ICInterface { public: typedef ICircularDelegator DefaultDelegator; static const char* descriptor; ICircular(); virtual ~ICircular(); static constexpr uint32_t TRANSACTION_GetTestService = FIRST_CALL_TRANSACTION + 0; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus GetTestService(std::shared_ptr<::aidl::android::aidl::tests::ITestService>* _aidl_return) = 0; private: static std::shared_ptr default_impl; }; class ICircularDefault : public ICircular { public: ::ndk::ScopedAStatus GetTestService(std::shared_ptr<::aidl::android::aidl::tests::ITestService>* _aidl_return) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000212 15172120304 033174 xustar000000000 0000000 110 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/IDeprecated.h 28 mtime=1776853188.4700000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/IDeprecated.h0100644 0000000 0000000 00000003567 15172120304 032663 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/IDeprecated.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IDeprecated.aidl */ #pragma once #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { class IDeprecatedDelegator; class __attribute__((deprecated("test"))) IDeprecated : public ::ndk::ICInterface { public: typedef IDeprecatedDelegator DefaultDelegator; static const char* descriptor; IDeprecated(); virtual ~IDeprecated(); static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); private: static std::shared_ptr default_impl; }; class __attribute__((deprecated("test"))) IDeprecatedDefault : public IDeprecated { public: ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000215 15172120304 033177 xustar000000000 0000000 113 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/INamedCallback.h 28 mtime=1776853188.4700000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/INamedCallbac0100644 0000000 0000000 00000004065 15172120304 032655 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/INamedCallback.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl */ #pragma once #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { class INamedCallbackDelegator; class INamedCallback : public ::ndk::ICInterface { public: typedef INamedCallbackDelegator DefaultDelegator; static const char* descriptor; INamedCallback(); virtual ~INamedCallback(); static constexpr uint32_t TRANSACTION_GetName = FIRST_CALL_TRANSACTION + 0; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus GetName(std::string* _aidl_return) = 0; private: static std::shared_ptr default_impl; }; class INamedCallbackDefault : public INamedCallback { public: ::ndk::ScopedAStatus GetName(std::string* _aidl_return) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000034 15172120304 033176 xustar000000000 0000000 28 mtime=1776853188.4710000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/INewName.h0100644 0000000 0000000 00000003736 15172120304 032153 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/INewName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INewName.aidl */ #pragma once #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { class INewNameDelegator; class INewName : public ::ndk::ICInterface { public: typedef INewNameDelegator DefaultDelegator; static const char* descriptor; INewName(); virtual ~INewName(); static constexpr uint32_t TRANSACTION_RealName = FIRST_CALL_TRANSACTION + 0; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus RealName(std::string* _aidl_return) = 0; private: static std::shared_ptr default_impl; }; class INewNameDefault : public INewName { public: ::ndk::ScopedAStatus RealName(std::string* _aidl_return) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000034 15172120304 033176 xustar000000000 0000000 28 mtime=1776853188.4710000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/IOldName.h0100644 0000000 0000000 00000003736 15172120304 032140 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/IOldName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IOldName.aidl */ #pragma once #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { class IOldNameDelegator; class IOldName : public ::ndk::ICInterface { public: typedef IOldNameDelegator DefaultDelegator; static const char* descriptor; IOldName(); virtual ~IOldName(); static constexpr uint32_t TRANSACTION_RealName = FIRST_CALL_TRANSACTION + 0; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus RealName(std::string* _aidl_return) = 0; private: static std::shared_ptr default_impl; }; class IOldNameDefault : public IOldName { public: ::ndk::ScopedAStatus RealName(std::string* _aidl_return) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000213 15172120304 033175 xustar000000000 0000000 111 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/ITestService.h 28 mtime=1776853188.4710000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/ITestService.0100644 0000000 0000000 00000153104 15172120304 032704 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ITestService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ITestService.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace aidl::android::aidl::tests { class CircularParcelable; class ICircular; class INamedCallback; class INewName; class IOldName; class RecursiveList; class StructuredParcelable; } // namespace aidl::android::aidl::tests namespace aidl::android::aidl::tests::extension { class ExtendableParcelable; } // namespace aidl::android::aidl::tests::extension namespace aidl { namespace android { namespace aidl { namespace tests { class ITestServiceDelegator; class ITestService : public ::ndk::ICInterface { public: typedef ITestServiceDelegator DefaultDelegator; static const char* descriptor; ITestService(); virtual ~ITestService(); class Empty { public: typedef std::false_type fixed_size; static const char* descriptor; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const Empty&) const { return std::tie() == std::tie(); } inline bool operator<(const Empty&) const { return std::tie() < std::tie(); } inline bool operator!=(const Empty& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Empty& _rhs) const { return _rhs < *this; } inline bool operator>=(const Empty& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Empty& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "Empty{"; _aidl_os << "}"; return _aidl_os.str(); } }; class CompilerChecks { public: typedef std::false_type fixed_size; static const char* descriptor; class IFooDelegator; class IFoo : public ::ndk::ICInterface { public: typedef IFooDelegator DefaultDelegator; static const char* descriptor; IFoo(); virtual ~IFoo(); static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); private: static std::shared_ptr default_impl; }; class IFooDefault : public IFoo { public: ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; class BpFoo : public ::ndk::BpCInterface { public: explicit BpFoo(const ::ndk::SpAIBinder& binder); virtual ~BpFoo(); }; class BnFoo : public ::ndk::BnCInterface { public: BnFoo(); virtual ~BnFoo(); protected: ::ndk::SpAIBinder createBinder() override; private: }; #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" class HasDeprecated { public: typedef std::false_type fixed_size; static const char* descriptor; int32_t __attribute__((deprecated("field"))) deprecated = 0; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const HasDeprecated& _rhs) const { return std::tie(deprecated) == std::tie(_rhs.deprecated); } inline bool operator<(const HasDeprecated& _rhs) const { return std::tie(deprecated) < std::tie(_rhs.deprecated); } inline bool operator!=(const HasDeprecated& _rhs) const { return !(*this == _rhs); } inline bool operator>(const HasDeprecated& _rhs) const { return _rhs < *this; } inline bool operator>=(const HasDeprecated& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const HasDeprecated& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "HasDeprecated{"; _aidl_os << "deprecated: " << ::android::internal::ToString(deprecated); _aidl_os << "}"; return _aidl_os.str(); } }; #pragma clang diagnostic pop class UsingHasDeprecated { public: typedef std::false_type fixed_size; static const char* descriptor; enum class Tag : int32_t { n = 0, m = 1, }; // Expose tag symbols for legacy code static const inline Tag n = Tag::n; static const inline Tag m = Tag::m; template static constexpr bool _not_self = !std::is_same_v>, UsingHasDeprecated>; UsingHasDeprecated() : _value(std::in_place_index(n)>, int32_t(0)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr UsingHasDeprecated(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit UsingHasDeprecated(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static UsingHasDeprecated make(_Tp&&... _args) { return UsingHasDeprecated(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static UsingHasDeprecated make(std::initializer_list<_Tp> _il, _Up&&... _args) { return UsingHasDeprecated(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } binder_status_t readFromParcel(const AParcel* _parcel); binder_status_t writeToParcel(AParcel* _parcel) const; inline bool operator==(const UsingHasDeprecated& _rhs) const { return _value == _rhs._value; } inline bool operator<(const UsingHasDeprecated& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const UsingHasDeprecated& _rhs) const { return !(*this == _rhs); } inline bool operator>(const UsingHasDeprecated& _rhs) const { return _rhs < *this; } inline bool operator>=(const UsingHasDeprecated& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const UsingHasDeprecated& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream os; os << "UsingHasDeprecated{"; switch (getTag()) { case n: os << "n: " << ::android::internal::ToString(get()); break; case m: os << "m: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant _value; }; class INoPrefixInterfaceDelegator; class INoPrefixInterface : public ::ndk::ICInterface { public: typedef INoPrefixInterfaceDelegator DefaultDelegator; static const char* descriptor; INoPrefixInterface(); virtual ~INoPrefixInterface(); class Nested { public: typedef std::false_type fixed_size; static const char* descriptor; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const Nested&) const { return std::tie() == std::tie(); } inline bool operator<(const Nested&) const { return std::tie() < std::tie(); } inline bool operator!=(const Nested& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Nested& _rhs) const { return _rhs < *this; } inline bool operator>=(const Nested& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Nested& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "Nested{"; _aidl_os << "}"; return _aidl_os.str(); } }; class INestedNoPrefixInterfaceDelegator; class INestedNoPrefixInterface : public ::ndk::ICInterface { public: typedef INestedNoPrefixInterfaceDelegator DefaultDelegator; static const char* descriptor; INestedNoPrefixInterface(); virtual ~INestedNoPrefixInterface(); static constexpr uint32_t TRANSACTION_foo = FIRST_CALL_TRANSACTION + 0; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus foo() = 0; private: static std::shared_ptr default_impl; }; class INestedNoPrefixInterfaceDefault : public INestedNoPrefixInterface { public: ::ndk::ScopedAStatus foo() override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; class BpNestedNoPrefixInterface : public ::ndk::BpCInterface { public: explicit BpNestedNoPrefixInterface(const ::ndk::SpAIBinder& binder); virtual ~BpNestedNoPrefixInterface(); ::ndk::ScopedAStatus foo() override; }; class BnNestedNoPrefixInterface : public ::ndk::BnCInterface { public: BnNestedNoPrefixInterface(); virtual ~BnNestedNoPrefixInterface(); protected: ::ndk::SpAIBinder createBinder() override; private: }; static constexpr uint32_t TRANSACTION_foo = FIRST_CALL_TRANSACTION + 0; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus foo() = 0; private: static std::shared_ptr default_impl; }; class INoPrefixInterfaceDefault : public INoPrefixInterface { public: ::ndk::ScopedAStatus foo() override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; class BpNoPrefixInterface : public ::ndk::BpCInterface { public: explicit BpNoPrefixInterface(const ::ndk::SpAIBinder& binder); virtual ~BpNoPrefixInterface(); ::ndk::ScopedAStatus foo() override; }; class BnNoPrefixInterface : public ::ndk::BnCInterface { public: BnNoPrefixInterface(); virtual ~BnNoPrefixInterface(); protected: ::ndk::SpAIBinder createBinder() override; private: }; ::ndk::SpAIBinder binder; ::ndk::SpAIBinder nullable_binder; std::vector<::ndk::SpAIBinder> binder_array; std::optional> nullable_binder_array; std::vector<::ndk::SpAIBinder> binder_list; std::optional> nullable_binder_list; ::ndk::ScopedFileDescriptor pfd; ::ndk::ScopedFileDescriptor nullable_pfd; std::vector<::ndk::ScopedFileDescriptor> pfd_array; std::optional> nullable_pfd_array; std::vector<::ndk::ScopedFileDescriptor> pfd_list; std::optional> nullable_pfd_list; ::aidl::android::aidl::tests::ITestService::Empty parcel; std::optional<::aidl::android::aidl::tests::ITestService::Empty> nullable_parcel; std::vector<::aidl::android::aidl::tests::ITestService::Empty> parcel_array; std::optional>> nullable_parcel_array; std::vector<::aidl::android::aidl::tests::ITestService::Empty> parcel_list; std::optional>> nullable_parcel_list; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const CompilerChecks& _rhs) const { return std::tie(binder, nullable_binder, binder_array, nullable_binder_array, binder_list, nullable_binder_list, pfd, nullable_pfd, pfd_array, nullable_pfd_array, pfd_list, nullable_pfd_list, parcel, nullable_parcel, parcel_array, nullable_parcel_array, parcel_list, nullable_parcel_list) == std::tie(_rhs.binder, _rhs.nullable_binder, _rhs.binder_array, _rhs.nullable_binder_array, _rhs.binder_list, _rhs.nullable_binder_list, _rhs.pfd, _rhs.nullable_pfd, _rhs.pfd_array, _rhs.nullable_pfd_array, _rhs.pfd_list, _rhs.nullable_pfd_list, _rhs.parcel, _rhs.nullable_parcel, _rhs.parcel_array, _rhs.nullable_parcel_array, _rhs.parcel_list, _rhs.nullable_parcel_list); } inline bool operator<(const CompilerChecks& _rhs) const { return std::tie(binder, nullable_binder, binder_array, nullable_binder_array, binder_list, nullable_binder_list, pfd, nullable_pfd, pfd_array, nullable_pfd_array, pfd_list, nullable_pfd_list, parcel, nullable_parcel, parcel_array, nullable_parcel_array, parcel_list, nullable_parcel_list) < std::tie(_rhs.binder, _rhs.nullable_binder, _rhs.binder_array, _rhs.nullable_binder_array, _rhs.binder_list, _rhs.nullable_binder_list, _rhs.pfd, _rhs.nullable_pfd, _rhs.pfd_array, _rhs.nullable_pfd_array, _rhs.pfd_list, _rhs.nullable_pfd_list, _rhs.parcel, _rhs.nullable_parcel, _rhs.parcel_array, _rhs.nullable_parcel_array, _rhs.parcel_list, _rhs.nullable_parcel_list); } inline bool operator!=(const CompilerChecks& _rhs) const { return !(*this == _rhs); } inline bool operator>(const CompilerChecks& _rhs) const { return _rhs < *this; } inline bool operator>=(const CompilerChecks& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const CompilerChecks& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "CompilerChecks{"; _aidl_os << "binder: " << ::android::internal::ToString(binder); _aidl_os << ", nullable_binder: " << ::android::internal::ToString(nullable_binder); _aidl_os << ", binder_array: " << ::android::internal::ToString(binder_array); _aidl_os << ", nullable_binder_array: " << ::android::internal::ToString(nullable_binder_array); _aidl_os << ", binder_list: " << ::android::internal::ToString(binder_list); _aidl_os << ", nullable_binder_list: " << ::android::internal::ToString(nullable_binder_list); _aidl_os << ", pfd: " << ::android::internal::ToString(pfd); _aidl_os << ", nullable_pfd: " << ::android::internal::ToString(nullable_pfd); _aidl_os << ", pfd_array: " << ::android::internal::ToString(pfd_array); _aidl_os << ", nullable_pfd_array: " << ::android::internal::ToString(nullable_pfd_array); _aidl_os << ", pfd_list: " << ::android::internal::ToString(pfd_list); _aidl_os << ", nullable_pfd_list: " << ::android::internal::ToString(nullable_pfd_list); _aidl_os << ", parcel: " << ::android::internal::ToString(parcel); _aidl_os << ", nullable_parcel: " << ::android::internal::ToString(nullable_parcel); _aidl_os << ", parcel_array: " << ::android::internal::ToString(parcel_array); _aidl_os << ", nullable_parcel_array: " << ::android::internal::ToString(nullable_parcel_array); _aidl_os << ", parcel_list: " << ::android::internal::ToString(parcel_list); _aidl_os << ", nullable_parcel_list: " << ::android::internal::ToString(nullable_parcel_list); _aidl_os << "}"; return _aidl_os.str(); } }; enum : int32_t { CONSTANT = 42 }; enum : int32_t { CONSTANT2 = -42 }; enum : int32_t { CONSTANT3 = 42 }; enum : int32_t { CONSTANT4 = 4 }; enum : int32_t { CONSTANT5 = -4 }; enum : int32_t { CONSTANT6 = 0 }; enum : int32_t { CONSTANT7 = 0 }; enum : int32_t { CONSTANT8 = 0 }; enum : int32_t { CONSTANT9 = 86 }; enum : int32_t { CONSTANT10 = 165 }; enum : int32_t { CONSTANT11 = 250 }; enum : int32_t { CONSTANT12 = -1 }; enum : int8_t { BYTE_CONSTANT = 17 }; enum : int64_t { LONG_CONSTANT = 1099511627776L }; static const char* STRING_CONSTANT; static const char* STRING_CONSTANT2; static constexpr float FLOAT_CONSTANT = 1.000000f; static constexpr float FLOAT_CONSTANT2 = -1.000000f; static constexpr float FLOAT_CONSTANT3 = 1.000000f; static constexpr float FLOAT_CONSTANT4 = 2.200000f; static constexpr float FLOAT_CONSTANT5 = -2.200000f; static constexpr float FLOAT_CONSTANT6 = -0.000000f; static constexpr float FLOAT_CONSTANT7 = 0.000000f; static constexpr double DOUBLE_CONSTANT = 1.000000; static constexpr double DOUBLE_CONSTANT2 = -1.000000; static constexpr double DOUBLE_CONSTANT3 = 1.000000; static constexpr double DOUBLE_CONSTANT4 = 2.200000; static constexpr double DOUBLE_CONSTANT5 = -2.200000; static constexpr double DOUBLE_CONSTANT6 = -0.000000; static constexpr double DOUBLE_CONSTANT7 = 0.000000; static constexpr double DOUBLE_CONSTANT8 = 1.100000; static constexpr double DOUBLE_CONSTANT9 = -1.100000; static const char* STRING_CONSTANT_UTF8; enum : int32_t { A1 = 1 }; enum : int32_t { A2 = 1 }; enum : int32_t { A3 = 1 }; enum : int32_t { A4 = 1 }; enum : int32_t { A5 = 1 }; enum : int32_t { A6 = 1 }; enum : int32_t { A7 = 1 }; enum : int32_t { A8 = 1 }; enum : int32_t { A9 = 1 }; enum : int32_t { A10 = 1 }; enum : int32_t { A11 = 1 }; enum : int32_t { A12 = 1 }; enum : int32_t { A13 = 1 }; enum : int32_t { A14 = 1 }; enum : int32_t { A15 = 1 }; enum : int32_t { A16 = 1 }; enum : int32_t { A17 = 1 }; enum : int32_t { A18 = 1 }; enum : int32_t { A19 = 1 }; enum : int32_t { A20 = 1 }; enum : int32_t { A21 = 1 }; enum : int32_t { A22 = 1 }; enum : int32_t { A23 = 1 }; enum : int32_t { A24 = 1 }; enum : int32_t { A25 = 1 }; enum : int32_t { A26 = 1 }; enum : int32_t { A27 = 1 }; enum : int32_t { A28 = 1 }; enum : int32_t { A29 = 1 }; enum : int32_t { A30 = 1 }; enum : int32_t { A31 = 1 }; enum : int32_t { A32 = 1 }; enum : int32_t { A33 = 1 }; enum : int32_t { A34 = 1 }; enum : int32_t { A35 = 1 }; enum : int32_t { A36 = 1 }; enum : int32_t { A37 = 1 }; enum : int32_t { A38 = 1 }; enum : int32_t { A39 = 1 }; enum : int32_t { A40 = 1 }; enum : int32_t { A41 = 1 }; enum : int32_t { A42 = 1 }; enum : int32_t { A43 = 1 }; enum : int32_t { A44 = 1 }; enum : int32_t { A45 = 1 }; enum : int32_t { A46 = 1 }; enum : int32_t { A47 = 1 }; enum : int32_t { A48 = 1 }; enum : int32_t { A49 = 1 }; enum : int32_t { A50 = 1 }; enum : int32_t { A51 = 1 }; enum : int32_t { A52 = 1 }; enum : int32_t { A53 = 1 }; enum : int32_t { A54 = 1 }; enum : int32_t { A55 = 1 }; enum : int32_t { A56 = 1 }; enum : int32_t { A57 = 1 }; static constexpr uint32_t TRANSACTION_UnimplementedMethod = FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_Deprecated = FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_TestOneway = FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_RepeatBoolean = FIRST_CALL_TRANSACTION + 3; static constexpr uint32_t TRANSACTION_RepeatByte = FIRST_CALL_TRANSACTION + 4; static constexpr uint32_t TRANSACTION_RepeatChar = FIRST_CALL_TRANSACTION + 5; static constexpr uint32_t TRANSACTION_RepeatInt = FIRST_CALL_TRANSACTION + 6; static constexpr uint32_t TRANSACTION_RepeatLong = FIRST_CALL_TRANSACTION + 7; static constexpr uint32_t TRANSACTION_RepeatFloat = FIRST_CALL_TRANSACTION + 8; static constexpr uint32_t TRANSACTION_RepeatDouble = FIRST_CALL_TRANSACTION + 9; static constexpr uint32_t TRANSACTION_RepeatString = FIRST_CALL_TRANSACTION + 10; static constexpr uint32_t TRANSACTION_RepeatByteEnum = FIRST_CALL_TRANSACTION + 11; static constexpr uint32_t TRANSACTION_RepeatIntEnum = FIRST_CALL_TRANSACTION + 12; static constexpr uint32_t TRANSACTION_RepeatLongEnum = FIRST_CALL_TRANSACTION + 13; static constexpr uint32_t TRANSACTION_ReverseBoolean = FIRST_CALL_TRANSACTION + 14; static constexpr uint32_t TRANSACTION_ReverseByte = FIRST_CALL_TRANSACTION + 15; static constexpr uint32_t TRANSACTION_ReverseChar = FIRST_CALL_TRANSACTION + 16; static constexpr uint32_t TRANSACTION_ReverseInt = FIRST_CALL_TRANSACTION + 17; static constexpr uint32_t TRANSACTION_ReverseLong = FIRST_CALL_TRANSACTION + 18; static constexpr uint32_t TRANSACTION_ReverseFloat = FIRST_CALL_TRANSACTION + 19; static constexpr uint32_t TRANSACTION_ReverseDouble = FIRST_CALL_TRANSACTION + 20; static constexpr uint32_t TRANSACTION_ReverseString = FIRST_CALL_TRANSACTION + 21; static constexpr uint32_t TRANSACTION_ReverseByteEnum = FIRST_CALL_TRANSACTION + 22; static constexpr uint32_t TRANSACTION_ReverseIntEnum = FIRST_CALL_TRANSACTION + 23; static constexpr uint32_t TRANSACTION_ReverseLongEnum = FIRST_CALL_TRANSACTION + 24; static constexpr uint32_t TRANSACTION_GetOtherTestService = FIRST_CALL_TRANSACTION + 25; static constexpr uint32_t TRANSACTION_SetOtherTestService = FIRST_CALL_TRANSACTION + 26; static constexpr uint32_t TRANSACTION_VerifyName = FIRST_CALL_TRANSACTION + 27; static constexpr uint32_t TRANSACTION_GetInterfaceArray = FIRST_CALL_TRANSACTION + 28; static constexpr uint32_t TRANSACTION_VerifyNamesWithInterfaceArray = FIRST_CALL_TRANSACTION + 29; static constexpr uint32_t TRANSACTION_GetNullableInterfaceArray = FIRST_CALL_TRANSACTION + 30; static constexpr uint32_t TRANSACTION_VerifyNamesWithNullableInterfaceArray = FIRST_CALL_TRANSACTION + 31; static constexpr uint32_t TRANSACTION_GetInterfaceList = FIRST_CALL_TRANSACTION + 32; static constexpr uint32_t TRANSACTION_VerifyNamesWithInterfaceList = FIRST_CALL_TRANSACTION + 33; static constexpr uint32_t TRANSACTION_ReverseStringList = FIRST_CALL_TRANSACTION + 34; static constexpr uint32_t TRANSACTION_RepeatParcelFileDescriptor = FIRST_CALL_TRANSACTION + 35; static constexpr uint32_t TRANSACTION_ReverseParcelFileDescriptorArray = FIRST_CALL_TRANSACTION + 36; static constexpr uint32_t TRANSACTION_ThrowServiceException = FIRST_CALL_TRANSACTION + 37; static constexpr uint32_t TRANSACTION_RepeatNullableIntArray = FIRST_CALL_TRANSACTION + 38; static constexpr uint32_t TRANSACTION_RepeatNullableByteEnumArray = FIRST_CALL_TRANSACTION + 39; static constexpr uint32_t TRANSACTION_RepeatNullableIntEnumArray = FIRST_CALL_TRANSACTION + 40; static constexpr uint32_t TRANSACTION_RepeatNullableLongEnumArray = FIRST_CALL_TRANSACTION + 41; static constexpr uint32_t TRANSACTION_RepeatNullableString = FIRST_CALL_TRANSACTION + 42; static constexpr uint32_t TRANSACTION_RepeatNullableStringList = FIRST_CALL_TRANSACTION + 43; static constexpr uint32_t TRANSACTION_RepeatNullableParcelable = FIRST_CALL_TRANSACTION + 44; static constexpr uint32_t TRANSACTION_RepeatNullableParcelableArray = FIRST_CALL_TRANSACTION + 45; static constexpr uint32_t TRANSACTION_RepeatNullableParcelableList = FIRST_CALL_TRANSACTION + 46; static constexpr uint32_t TRANSACTION_TakesAnIBinder = FIRST_CALL_TRANSACTION + 47; static constexpr uint32_t TRANSACTION_TakesANullableIBinder = FIRST_CALL_TRANSACTION + 48; static constexpr uint32_t TRANSACTION_TakesAnIBinderList = FIRST_CALL_TRANSACTION + 49; static constexpr uint32_t TRANSACTION_TakesANullableIBinderList = FIRST_CALL_TRANSACTION + 50; static constexpr uint32_t TRANSACTION_RepeatUtf8CppString = FIRST_CALL_TRANSACTION + 51; static constexpr uint32_t TRANSACTION_RepeatNullableUtf8CppString = FIRST_CALL_TRANSACTION + 52; static constexpr uint32_t TRANSACTION_ReverseUtf8CppString = FIRST_CALL_TRANSACTION + 53; static constexpr uint32_t TRANSACTION_ReverseNullableUtf8CppString = FIRST_CALL_TRANSACTION + 54; static constexpr uint32_t TRANSACTION_ReverseUtf8CppStringList = FIRST_CALL_TRANSACTION + 55; static constexpr uint32_t TRANSACTION_GetCallback = FIRST_CALL_TRANSACTION + 56; static constexpr uint32_t TRANSACTION_FillOutStructuredParcelable = FIRST_CALL_TRANSACTION + 57; static constexpr uint32_t TRANSACTION_RepeatExtendableParcelable = FIRST_CALL_TRANSACTION + 58; static constexpr uint32_t TRANSACTION_ReverseList = FIRST_CALL_TRANSACTION + 59; static constexpr uint32_t TRANSACTION_ReverseIBinderArray = FIRST_CALL_TRANSACTION + 60; static constexpr uint32_t TRANSACTION_ReverseNullableIBinderArray = FIRST_CALL_TRANSACTION + 61; static constexpr uint32_t TRANSACTION_RepeatSimpleParcelable = FIRST_CALL_TRANSACTION + 62; static constexpr uint32_t TRANSACTION_ReverseSimpleParcelables = FIRST_CALL_TRANSACTION + 63; static constexpr uint32_t TRANSACTION_GetOldNameInterface = FIRST_CALL_TRANSACTION + 64; static constexpr uint32_t TRANSACTION_GetNewNameInterface = FIRST_CALL_TRANSACTION + 65; static constexpr uint32_t TRANSACTION_GetUnionTags = FIRST_CALL_TRANSACTION + 66; static constexpr uint32_t TRANSACTION_GetCppJavaTests = FIRST_CALL_TRANSACTION + 67; static constexpr uint32_t TRANSACTION_getBackendType = FIRST_CALL_TRANSACTION + 68; static constexpr uint32_t TRANSACTION_GetCircular = FIRST_CALL_TRANSACTION + 69; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus UnimplementedMethod(int32_t in_arg, int32_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus Deprecated() __attribute__((deprecated("to make sure we have something in system/tools/aidl which does a compile check of deprecated and make sure this is reflected in goldens"))) = 0; virtual ::ndk::ScopedAStatus TestOneway() = 0; virtual ::ndk::ScopedAStatus RepeatBoolean(bool in_token, bool* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatByte(int8_t in_token, int8_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatChar(char16_t in_token, char16_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatInt(int32_t in_token, int32_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatLong(int64_t in_token, int64_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatFloat(float in_token, float* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatDouble(double in_token, double* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatString(const std::string& in_token, std::string* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatByteEnum(::aidl::android::aidl::tests::ByteEnum in_token, ::aidl::android::aidl::tests::ByteEnum* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatIntEnum(::aidl::android::aidl::tests::IntEnum in_token, ::aidl::android::aidl::tests::IntEnum* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatLongEnum(::aidl::android::aidl::tests::LongEnum in_token, ::aidl::android::aidl::tests::LongEnum* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseBoolean(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseByte(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseChar(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseInt(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseLong(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseFloat(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseDouble(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseString(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseByteEnum(const std::vector<::aidl::android::aidl::tests::ByteEnum>& in_input, std::vector<::aidl::android::aidl::tests::ByteEnum>* out_repeated, std::vector<::aidl::android::aidl::tests::ByteEnum>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseIntEnum(const std::vector<::aidl::android::aidl::tests::IntEnum>& in_input, std::vector<::aidl::android::aidl::tests::IntEnum>* out_repeated, std::vector<::aidl::android::aidl::tests::IntEnum>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseLongEnum(const std::vector<::aidl::android::aidl::tests::LongEnum>& in_input, std::vector<::aidl::android::aidl::tests::LongEnum>* out_repeated, std::vector<::aidl::android::aidl::tests::LongEnum>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus GetOtherTestService(const std::string& in_name, std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus SetOtherTestService(const std::string& in_name, const std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>& in_service, bool* _aidl_return) = 0; virtual ::ndk::ScopedAStatus VerifyName(const std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>& in_service, const std::string& in_name, bool* _aidl_return) = 0; virtual ::ndk::ScopedAStatus GetInterfaceArray(const std::vector& in_names, std::vector>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus VerifyNamesWithInterfaceArray(const std::vector>& in_services, const std::vector& in_names, bool* _aidl_return) = 0; virtual ::ndk::ScopedAStatus GetNullableInterfaceArray(const std::optional>>& in_names, std::optional>>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus VerifyNamesWithNullableInterfaceArray(const std::optional>>& in_services, const std::optional>>& in_names, bool* _aidl_return) = 0; virtual ::ndk::ScopedAStatus GetInterfaceList(const std::optional>>& in_names, std::optional>>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus VerifyNamesWithInterfaceList(const std::optional>>& in_services, const std::optional>>& in_names, bool* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseStringList(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatParcelFileDescriptor(const ::ndk::ScopedFileDescriptor& in_read, ::ndk::ScopedFileDescriptor* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseParcelFileDescriptorArray(const std::vector<::ndk::ScopedFileDescriptor>& in_input, std::vector<::ndk::ScopedFileDescriptor>* out_repeated, std::vector<::ndk::ScopedFileDescriptor>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ThrowServiceException(int32_t in_code) = 0; virtual ::ndk::ScopedAStatus RepeatNullableIntArray(const std::optional>& in_input, std::optional>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatNullableByteEnumArray(const std::optional>& in_input, std::optional>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatNullableIntEnumArray(const std::optional>& in_input, std::optional>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatNullableLongEnumArray(const std::optional>& in_input, std::optional>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatNullableString(const std::optional& in_input, std::optional* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatNullableStringList(const std::optional>>& in_input, std::optional>>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatNullableParcelable(const std::optional<::aidl::android::aidl::tests::ITestService::Empty>& in_input, std::optional<::aidl::android::aidl::tests::ITestService::Empty>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatNullableParcelableArray(const std::optional>>& in_input, std::optional>>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatNullableParcelableList(const std::optional>>& in_input, std::optional>>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus TakesAnIBinder(const ::ndk::SpAIBinder& in_input) = 0; virtual ::ndk::ScopedAStatus TakesANullableIBinder(const ::ndk::SpAIBinder& in_input) = 0; virtual ::ndk::ScopedAStatus TakesAnIBinderList(const std::vector<::ndk::SpAIBinder>& in_input) = 0; virtual ::ndk::ScopedAStatus TakesANullableIBinderList(const std::optional>& in_input) = 0; virtual ::ndk::ScopedAStatus RepeatUtf8CppString(const std::string& in_token, std::string* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatNullableUtf8CppString(const std::optional& in_token, std::optional* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseUtf8CppString(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseNullableUtf8CppString(const std::optional>>& in_input, std::optional>>* out_repeated, std::optional>>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseUtf8CppStringList(const std::optional>>& in_input, std::optional>>* out_repeated, std::optional>>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus GetCallback(bool in_return_null, std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus FillOutStructuredParcelable(::aidl::android::aidl::tests::StructuredParcelable* in_parcel) = 0; virtual ::ndk::ScopedAStatus RepeatExtendableParcelable(const ::aidl::android::aidl::tests::extension::ExtendableParcelable& in_ep, ::aidl::android::aidl::tests::extension::ExtendableParcelable* out_ep2) = 0; virtual ::ndk::ScopedAStatus ReverseList(const ::aidl::android::aidl::tests::RecursiveList& in_list, ::aidl::android::aidl::tests::RecursiveList* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseIBinderArray(const std::vector<::ndk::SpAIBinder>& in_input, std::vector<::ndk::SpAIBinder>* out_repeated, std::vector<::ndk::SpAIBinder>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseNullableIBinderArray(const std::optional>& in_input, std::optional>* out_repeated, std::optional>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatSimpleParcelable(const ::aidl::android::aidl::tests::SimpleParcelable& in_input, ::aidl::android::aidl::tests::SimpleParcelable* out_repeat, ::aidl::android::aidl::tests::SimpleParcelable* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseSimpleParcelables(const std::vector<::aidl::android::aidl::tests::SimpleParcelable>& in_input, std::vector<::aidl::android::aidl::tests::SimpleParcelable>* out_repeated, std::vector<::aidl::android::aidl::tests::SimpleParcelable>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus GetOldNameInterface(std::shared_ptr<::aidl::android::aidl::tests::IOldName>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus GetNewNameInterface(std::shared_ptr<::aidl::android::aidl::tests::INewName>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus GetUnionTags(const std::vector<::aidl::android::aidl::tests::Union>& in_input, std::vector<::aidl::android::aidl::tests::Union::Tag>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus GetCppJavaTests(::ndk::SpAIBinder* _aidl_return) = 0; virtual ::ndk::ScopedAStatus getBackendType(::aidl::android::aidl::tests::BackendType* _aidl_return) = 0; virtual ::ndk::ScopedAStatus GetCircular(::aidl::android::aidl::tests::CircularParcelable* out_cp, std::shared_ptr<::aidl::android::aidl::tests::ICircular>* _aidl_return) = 0; private: static std::shared_ptr default_impl; }; class ITestServiceDefault : public ITestService { public: ::ndk::ScopedAStatus UnimplementedMethod(int32_t in_arg, int32_t* _aidl_return) override; ::ndk::ScopedAStatus Deprecated() override __attribute__((deprecated("to make sure we have something in system/tools/aidl which does a compile check of deprecated and make sure this is reflected in goldens"))); ::ndk::ScopedAStatus TestOneway() override; ::ndk::ScopedAStatus RepeatBoolean(bool in_token, bool* _aidl_return) override; ::ndk::ScopedAStatus RepeatByte(int8_t in_token, int8_t* _aidl_return) override; ::ndk::ScopedAStatus RepeatChar(char16_t in_token, char16_t* _aidl_return) override; ::ndk::ScopedAStatus RepeatInt(int32_t in_token, int32_t* _aidl_return) override; ::ndk::ScopedAStatus RepeatLong(int64_t in_token, int64_t* _aidl_return) override; ::ndk::ScopedAStatus RepeatFloat(float in_token, float* _aidl_return) override; ::ndk::ScopedAStatus RepeatDouble(double in_token, double* _aidl_return) override; ::ndk::ScopedAStatus RepeatString(const std::string& in_token, std::string* _aidl_return) override; ::ndk::ScopedAStatus RepeatByteEnum(::aidl::android::aidl::tests::ByteEnum in_token, ::aidl::android::aidl::tests::ByteEnum* _aidl_return) override; ::ndk::ScopedAStatus RepeatIntEnum(::aidl::android::aidl::tests::IntEnum in_token, ::aidl::android::aidl::tests::IntEnum* _aidl_return) override; ::ndk::ScopedAStatus RepeatLongEnum(::aidl::android::aidl::tests::LongEnum in_token, ::aidl::android::aidl::tests::LongEnum* _aidl_return) override; ::ndk::ScopedAStatus ReverseBoolean(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseByte(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseChar(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseInt(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseLong(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseFloat(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseDouble(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseString(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseByteEnum(const std::vector<::aidl::android::aidl::tests::ByteEnum>& in_input, std::vector<::aidl::android::aidl::tests::ByteEnum>* out_repeated, std::vector<::aidl::android::aidl::tests::ByteEnum>* _aidl_return) override; ::ndk::ScopedAStatus ReverseIntEnum(const std::vector<::aidl::android::aidl::tests::IntEnum>& in_input, std::vector<::aidl::android::aidl::tests::IntEnum>* out_repeated, std::vector<::aidl::android::aidl::tests::IntEnum>* _aidl_return) override; ::ndk::ScopedAStatus ReverseLongEnum(const std::vector<::aidl::android::aidl::tests::LongEnum>& in_input, std::vector<::aidl::android::aidl::tests::LongEnum>* out_repeated, std::vector<::aidl::android::aidl::tests::LongEnum>* _aidl_return) override; ::ndk::ScopedAStatus GetOtherTestService(const std::string& in_name, std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>* _aidl_return) override; ::ndk::ScopedAStatus SetOtherTestService(const std::string& in_name, const std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>& in_service, bool* _aidl_return) override; ::ndk::ScopedAStatus VerifyName(const std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>& in_service, const std::string& in_name, bool* _aidl_return) override; ::ndk::ScopedAStatus GetInterfaceArray(const std::vector& in_names, std::vector>* _aidl_return) override; ::ndk::ScopedAStatus VerifyNamesWithInterfaceArray(const std::vector>& in_services, const std::vector& in_names, bool* _aidl_return) override; ::ndk::ScopedAStatus GetNullableInterfaceArray(const std::optional>>& in_names, std::optional>>* _aidl_return) override; ::ndk::ScopedAStatus VerifyNamesWithNullableInterfaceArray(const std::optional>>& in_services, const std::optional>>& in_names, bool* _aidl_return) override; ::ndk::ScopedAStatus GetInterfaceList(const std::optional>>& in_names, std::optional>>* _aidl_return) override; ::ndk::ScopedAStatus VerifyNamesWithInterfaceList(const std::optional>>& in_services, const std::optional>>& in_names, bool* _aidl_return) override; ::ndk::ScopedAStatus ReverseStringList(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus RepeatParcelFileDescriptor(const ::ndk::ScopedFileDescriptor& in_read, ::ndk::ScopedFileDescriptor* _aidl_return) override; ::ndk::ScopedAStatus ReverseParcelFileDescriptorArray(const std::vector<::ndk::ScopedFileDescriptor>& in_input, std::vector<::ndk::ScopedFileDescriptor>* out_repeated, std::vector<::ndk::ScopedFileDescriptor>* _aidl_return) override; ::ndk::ScopedAStatus ThrowServiceException(int32_t in_code) override; ::ndk::ScopedAStatus RepeatNullableIntArray(const std::optional>& in_input, std::optional>* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableByteEnumArray(const std::optional>& in_input, std::optional>* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableIntEnumArray(const std::optional>& in_input, std::optional>* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableLongEnumArray(const std::optional>& in_input, std::optional>* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableString(const std::optional& in_input, std::optional* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableStringList(const std::optional>>& in_input, std::optional>>* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableParcelable(const std::optional<::aidl::android::aidl::tests::ITestService::Empty>& in_input, std::optional<::aidl::android::aidl::tests::ITestService::Empty>* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableParcelableArray(const std::optional>>& in_input, std::optional>>* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableParcelableList(const std::optional>>& in_input, std::optional>>* _aidl_return) override; ::ndk::ScopedAStatus TakesAnIBinder(const ::ndk::SpAIBinder& in_input) override; ::ndk::ScopedAStatus TakesANullableIBinder(const ::ndk::SpAIBinder& in_input) override; ::ndk::ScopedAStatus TakesAnIBinderList(const std::vector<::ndk::SpAIBinder>& in_input) override; ::ndk::ScopedAStatus TakesANullableIBinderList(const std::optional>& in_input) override; ::ndk::ScopedAStatus RepeatUtf8CppString(const std::string& in_token, std::string* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableUtf8CppString(const std::optional& in_token, std::optional* _aidl_return) override; ::ndk::ScopedAStatus ReverseUtf8CppString(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseNullableUtf8CppString(const std::optional>>& in_input, std::optional>>* out_repeated, std::optional>>* _aidl_return) override; ::ndk::ScopedAStatus ReverseUtf8CppStringList(const std::optional>>& in_input, std::optional>>* out_repeated, std::optional>>* _aidl_return) override; ::ndk::ScopedAStatus GetCallback(bool in_return_null, std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>* _aidl_return) override; ::ndk::ScopedAStatus FillOutStructuredParcelable(::aidl::android::aidl::tests::StructuredParcelable* in_parcel) override; ::ndk::ScopedAStatus RepeatExtendableParcelable(const ::aidl::android::aidl::tests::extension::ExtendableParcelable& in_ep, ::aidl::android::aidl::tests::extension::ExtendableParcelable* out_ep2) override; ::ndk::ScopedAStatus ReverseList(const ::aidl::android::aidl::tests::RecursiveList& in_list, ::aidl::android::aidl::tests::RecursiveList* _aidl_return) override; ::ndk::ScopedAStatus ReverseIBinderArray(const std::vector<::ndk::SpAIBinder>& in_input, std::vector<::ndk::SpAIBinder>* out_repeated, std::vector<::ndk::SpAIBinder>* _aidl_return) override; ::ndk::ScopedAStatus ReverseNullableIBinderArray(const std::optional>& in_input, std::optional>* out_repeated, std::optional>* _aidl_return) override; ::ndk::ScopedAStatus RepeatSimpleParcelable(const ::aidl::android::aidl::tests::SimpleParcelable& in_input, ::aidl::android::aidl::tests::SimpleParcelable* out_repeat, ::aidl::android::aidl::tests::SimpleParcelable* _aidl_return) override; ::ndk::ScopedAStatus ReverseSimpleParcelables(const std::vector<::aidl::android::aidl::tests::SimpleParcelable>& in_input, std::vector<::aidl::android::aidl::tests::SimpleParcelable>* out_repeated, std::vector<::aidl::android::aidl::tests::SimpleParcelable>* _aidl_return) override; ::ndk::ScopedAStatus GetOldNameInterface(std::shared_ptr<::aidl::android::aidl::tests::IOldName>* _aidl_return) override; ::ndk::ScopedAStatus GetNewNameInterface(std::shared_ptr<::aidl::android::aidl::tests::INewName>* _aidl_return) override; ::ndk::ScopedAStatus GetUnionTags(const std::vector<::aidl::android::aidl::tests::Union>& in_input, std::vector<::aidl::android::aidl::tests::Union::Tag>* _aidl_return) override; ::ndk::ScopedAStatus GetCppJavaTests(::ndk::SpAIBinder* _aidl_return) override; ::ndk::ScopedAStatus getBackendType(::aidl::android::aidl::tests::BackendType* _aidl_return) override; ::ndk::ScopedAStatus GetCircular(::aidl::android::aidl::tests::CircularParcelable* out_cp, std::shared_ptr<::aidl::android::aidl::tests::ICircular>* _aidl_return) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(ITestService::CompilerChecks::UsingHasDeprecated::Tag val) { switch(val) { case ITestService::CompilerChecks::UsingHasDeprecated::Tag::n: return "n"; case ITestService::CompilerChecks::UsingHasDeprecated::Tag::m: return "m"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::tests::ITestService::CompilerChecks::UsingHasDeprecated::Tag::n, aidl::android::aidl::tests::ITestService::CompilerChecks::UsingHasDeprecated::Tag::m, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000034 15172120304 033176 xustar000000000 0000000 28 mtime=1776853188.4720000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/IntEnum.h0100644 0000000 0000000 00000004376 15172120304 032070 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/IntEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl */ #pragma once #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { enum class IntEnum : int32_t { FOO = 1000, BAR = 2000, BAZ = 2001, QUX __attribute__((deprecated("do not use this"))) = 2002, }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" [[nodiscard]] static inline std::string toString(IntEnum val) { switch(val) { case IntEnum::FOO: return "FOO"; case IntEnum::BAR: return "BAR"; case IntEnum::BAZ: return "BAZ"; case IntEnum::QUX: return "QUX"; default: return std::to_string(static_cast(val)); } } #pragma clang diagnostic pop } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" #pragma clang diagnostic ignored "-Wdeprecated-declarations" template <> constexpr inline std::array enum_values = { aidl::android::aidl::tests::IntEnum::FOO, aidl::android::aidl::tests::IntEnum::BAR, aidl::android::aidl::tests::IntEnum::BAZ, aidl::android::aidl::tests::IntEnum::QUX, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000217 15172120304 033201 xustar000000000 0000000 115 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/ListOfInterfaces.h 28 mtime=1776853188.4720000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/ListOfInterfa0100644 0000000 0000000 00000037471 15172120304 032776 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ListOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ListOfInterfaces.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace aidl { namespace android { namespace aidl { namespace tests { class ListOfInterfaces { public: typedef std::false_type fixed_size; static const char* descriptor; class IEmptyInterfaceDelegator; class IEmptyInterface : public ::ndk::ICInterface { public: typedef IEmptyInterfaceDelegator DefaultDelegator; static const char* descriptor; IEmptyInterface(); virtual ~IEmptyInterface(); static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); private: static std::shared_ptr default_impl; }; class IEmptyInterfaceDefault : public IEmptyInterface { public: ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; class BpEmptyInterface : public ::ndk::BpCInterface { public: explicit BpEmptyInterface(const ::ndk::SpAIBinder& binder); virtual ~BpEmptyInterface(); }; class BnEmptyInterface : public ::ndk::BnCInterface { public: BnEmptyInterface(); virtual ~BnEmptyInterface(); protected: ::ndk::SpAIBinder createBinder() override; private: }; class IMyInterfaceDelegator; class IMyInterface : public ::ndk::ICInterface { public: typedef IMyInterfaceDelegator DefaultDelegator; static const char* descriptor; IMyInterface(); virtual ~IMyInterface(); static constexpr uint32_t TRANSACTION_methodWithInterfaces = FIRST_CALL_TRANSACTION + 0; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus methodWithInterfaces(const std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& in_iface, const std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& in_nullable_iface, const std::vector>& in_iface_list_in, std::vector>* out_iface_list_out, std::vector>* in_iface_list_inout, const std::optional>>& in_nullable_iface_list_in, std::optional>>* out_nullable_iface_list_out, std::optional>>* in_nullable_iface_list_inout, std::optional>>* _aidl_return) = 0; private: static std::shared_ptr default_impl; }; class IMyInterfaceDefault : public IMyInterface { public: ::ndk::ScopedAStatus methodWithInterfaces(const std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& in_iface, const std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& in_nullable_iface, const std::vector>& in_iface_list_in, std::vector>* out_iface_list_out, std::vector>* in_iface_list_inout, const std::optional>>& in_nullable_iface_list_in, std::optional>>* out_nullable_iface_list_out, std::optional>>* in_nullable_iface_list_inout, std::optional>>* _aidl_return) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; class BpMyInterface : public ::ndk::BpCInterface { public: explicit BpMyInterface(const ::ndk::SpAIBinder& binder); virtual ~BpMyInterface(); ::ndk::ScopedAStatus methodWithInterfaces(const std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& in_iface, const std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& in_nullable_iface, const std::vector>& in_iface_list_in, std::vector>* out_iface_list_out, std::vector>* in_iface_list_inout, const std::optional>>& in_nullable_iface_list_in, std::optional>>* out_nullable_iface_list_out, std::optional>>* in_nullable_iface_list_inout, std::optional>>* _aidl_return) override; }; class BnMyInterface : public ::ndk::BnCInterface { public: BnMyInterface(); virtual ~BnMyInterface(); protected: ::ndk::SpAIBinder createBinder() override; private: }; class MyParcelable { public: typedef std::false_type fixed_size; static const char* descriptor; std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface> iface; std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface> nullable_iface; std::vector> iface_list; std::optional>> nullable_iface_list; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const MyParcelable& _rhs) const { return std::tie(iface, nullable_iface, iface_list, nullable_iface_list) == std::tie(_rhs.iface, _rhs.nullable_iface, _rhs.iface_list, _rhs.nullable_iface_list); } inline bool operator<(const MyParcelable& _rhs) const { return std::tie(iface, nullable_iface, iface_list, nullable_iface_list) < std::tie(_rhs.iface, _rhs.nullable_iface, _rhs.iface_list, _rhs.nullable_iface_list); } inline bool operator!=(const MyParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyParcelable& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "MyParcelable{"; _aidl_os << "iface: " << ::android::internal::ToString(iface); _aidl_os << ", nullable_iface: " << ::android::internal::ToString(nullable_iface); _aidl_os << ", iface_list: " << ::android::internal::ToString(iface_list); _aidl_os << ", nullable_iface_list: " << ::android::internal::ToString(nullable_iface_list); _aidl_os << "}"; return _aidl_os.str(); } }; class MyUnion { public: typedef std::false_type fixed_size; static const char* descriptor; enum class Tag : int32_t { iface = 0, nullable_iface = 1, iface_list = 2, nullable_iface_list = 3, }; // Expose tag symbols for legacy code static const inline Tag iface = Tag::iface; static const inline Tag nullable_iface = Tag::nullable_iface; static const inline Tag iface_list = Tag::iface_list; static const inline Tag nullable_iface_list = Tag::nullable_iface_list; template static constexpr bool _not_self = !std::is_same_v>, MyUnion>; MyUnion() : _value(std::in_place_index(iface)>, std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface>()) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr MyUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit MyUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static MyUnion make(_Tp&&... _args) { return MyUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static MyUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return MyUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } binder_status_t readFromParcel(const AParcel* _parcel); binder_status_t writeToParcel(AParcel* _parcel) const; inline bool operator==(const MyUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const MyUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const MyUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyUnion& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream os; os << "MyUnion{"; switch (getTag()) { case iface: os << "iface: " << ::android::internal::ToString(get()); break; case nullable_iface: os << "nullable_iface: " << ::android::internal::ToString(get()); break; case iface_list: os << "iface_list: " << ::android::internal::ToString(get()); break; case nullable_iface_list: os << "nullable_iface_list: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant, std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface>, std::vector>, std::optional>>> _value; }; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const ListOfInterfaces&) const { return std::tie() == std::tie(); } inline bool operator<(const ListOfInterfaces&) const { return std::tie() < std::tie(); } inline bool operator!=(const ListOfInterfaces& _rhs) const { return !(*this == _rhs); } inline bool operator>(const ListOfInterfaces& _rhs) const { return _rhs < *this; } inline bool operator>=(const ListOfInterfaces& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const ListOfInterfaces& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "ListOfInterfaces{"; _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(ListOfInterfaces::MyUnion::Tag val) { switch(val) { case ListOfInterfaces::MyUnion::Tag::iface: return "iface"; case ListOfInterfaces::MyUnion::Tag::nullable_iface: return "nullable_iface"; case ListOfInterfaces::MyUnion::Tag::iface_list: return "iface_list"; case ListOfInterfaces::MyUnion::Tag::nullable_iface_list: return "nullable_iface_list"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::tests::ListOfInterfaces::MyUnion::Tag::iface, aidl::android::aidl::tests::ListOfInterfaces::MyUnion::Tag::nullable_iface, aidl::android::aidl::tests::ListOfInterfaces::MyUnion::Tag::iface_list, aidl::android::aidl::tests::ListOfInterfaces::MyUnion::Tag::nullable_iface_list, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000034 15172120304 033176 xustar000000000 0000000 28 mtime=1776853188.4730000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/LongEnum.h0100644 0000000 0000000 00000003740 15172120304 032227 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/LongEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl */ #pragma once #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { enum class LongEnum : int64_t { FOO = 100000000000L, BAR = 200000000000L, BAZ = 200000000001L, }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(LongEnum val) { switch(val) { case LongEnum::FOO: return "FOO"; case LongEnum::BAR: return "BAR"; case LongEnum::BAZ: return "BAZ"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::tests::LongEnum::FOO, aidl::android::aidl::tests::LongEnum::BAR, aidl::android::aidl::tests::LongEnum::BAZ, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000231 15172120304 033175 xustar000000000 0000000 125 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/OtherParcelableForToString.h 28 mtime=1776853188.4730000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/OtherParcelab0100644 0000000 0000000 00000004511 15172120304 032765 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/OtherParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl */ #pragma once #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { class OtherParcelableForToString { public: typedef std::false_type fixed_size; static const char* descriptor; std::string field; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const OtherParcelableForToString& _rhs) const { return std::tie(field) == std::tie(_rhs.field); } inline bool operator<(const OtherParcelableForToString& _rhs) const { return std::tie(field) < std::tie(_rhs.field); } inline bool operator!=(const OtherParcelableForToString& _rhs) const { return !(*this == _rhs); } inline bool operator>(const OtherParcelableForToString& _rhs) const { return _rhs < *this; } inline bool operator>=(const OtherParcelableForToString& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const OtherParcelableForToString& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "OtherParcelableForToString{"; _aidl_os << "field: " << ::android::internal::ToString(field); _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000224 15172120304 033177 xustar000000000 0000000 120 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/ParcelableForToString.h 28 mtime=1776853188.4730000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/ParcelableFor0100644 0000000 0000000 00000015564 15172120304 032765 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ParcelableForToString.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl::android::aidl::tests { template class GenericStructuredParcelable; class OtherParcelableForToString; class StructuredParcelable; } // namespace aidl::android::aidl::tests namespace aidl { namespace android { namespace aidl { namespace tests { class ParcelableForToString { public: typedef std::false_type fixed_size; static const char* descriptor; int32_t intValue = 0; std::vector intArray; int64_t longValue = 0L; std::vector longArray; double doubleValue = 0.000000; std::vector doubleArray; float floatValue = 0.000000f; std::vector floatArray; int8_t byteValue = 0; std::vector byteArray; bool booleanValue = false; std::vector booleanArray; std::string stringValue; std::vector stringArray; std::vector stringList; ::aidl::android::aidl::tests::OtherParcelableForToString parcelableValue; std::vector<::aidl::android::aidl::tests::OtherParcelableForToString> parcelableArray; ::aidl::android::aidl::tests::IntEnum enumValue = ::aidl::android::aidl::tests::IntEnum::FOO; std::vector<::aidl::android::aidl::tests::IntEnum> enumArray; std::vector nullArray; std::vector nullList; ::aidl::android::aidl::tests::GenericStructuredParcelable parcelableGeneric; ::aidl::android::aidl::tests::Union unionValue; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const ParcelableForToString& _rhs) const { return std::tie(intValue, intArray, longValue, longArray, doubleValue, doubleArray, floatValue, floatArray, byteValue, byteArray, booleanValue, booleanArray, stringValue, stringArray, stringList, parcelableValue, parcelableArray, enumValue, enumArray, nullArray, nullList, parcelableGeneric, unionValue) == std::tie(_rhs.intValue, _rhs.intArray, _rhs.longValue, _rhs.longArray, _rhs.doubleValue, _rhs.doubleArray, _rhs.floatValue, _rhs.floatArray, _rhs.byteValue, _rhs.byteArray, _rhs.booleanValue, _rhs.booleanArray, _rhs.stringValue, _rhs.stringArray, _rhs.stringList, _rhs.parcelableValue, _rhs.parcelableArray, _rhs.enumValue, _rhs.enumArray, _rhs.nullArray, _rhs.nullList, _rhs.parcelableGeneric, _rhs.unionValue); } inline bool operator<(const ParcelableForToString& _rhs) const { return std::tie(intValue, intArray, longValue, longArray, doubleValue, doubleArray, floatValue, floatArray, byteValue, byteArray, booleanValue, booleanArray, stringValue, stringArray, stringList, parcelableValue, parcelableArray, enumValue, enumArray, nullArray, nullList, parcelableGeneric, unionValue) < std::tie(_rhs.intValue, _rhs.intArray, _rhs.longValue, _rhs.longArray, _rhs.doubleValue, _rhs.doubleArray, _rhs.floatValue, _rhs.floatArray, _rhs.byteValue, _rhs.byteArray, _rhs.booleanValue, _rhs.booleanArray, _rhs.stringValue, _rhs.stringArray, _rhs.stringList, _rhs.parcelableValue, _rhs.parcelableArray, _rhs.enumValue, _rhs.enumArray, _rhs.nullArray, _rhs.nullList, _rhs.parcelableGeneric, _rhs.unionValue); } inline bool operator!=(const ParcelableForToString& _rhs) const { return !(*this == _rhs); } inline bool operator>(const ParcelableForToString& _rhs) const { return _rhs < *this; } inline bool operator>=(const ParcelableForToString& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const ParcelableForToString& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "ParcelableForToString{"; _aidl_os << "intValue: " << ::android::internal::ToString(intValue); _aidl_os << ", intArray: " << ::android::internal::ToString(intArray); _aidl_os << ", longValue: " << ::android::internal::ToString(longValue); _aidl_os << ", longArray: " << ::android::internal::ToString(longArray); _aidl_os << ", doubleValue: " << ::android::internal::ToString(doubleValue); _aidl_os << ", doubleArray: " << ::android::internal::ToString(doubleArray); _aidl_os << ", floatValue: " << ::android::internal::ToString(floatValue); _aidl_os << ", floatArray: " << ::android::internal::ToString(floatArray); _aidl_os << ", byteValue: " << ::android::internal::ToString(byteValue); _aidl_os << ", byteArray: " << ::android::internal::ToString(byteArray); _aidl_os << ", booleanValue: " << ::android::internal::ToString(booleanValue); _aidl_os << ", booleanArray: " << ::android::internal::ToString(booleanArray); _aidl_os << ", stringValue: " << ::android::internal::ToString(stringValue); _aidl_os << ", stringArray: " << ::android::internal::ToString(stringArray); _aidl_os << ", stringList: " << ::android::internal::ToString(stringList); _aidl_os << ", parcelableValue: " << ::android::internal::ToString(parcelableValue); _aidl_os << ", parcelableArray: " << ::android::internal::ToString(parcelableArray); _aidl_os << ", enumValue: " << ::android::internal::ToString(enumValue); _aidl_os << ", enumArray: " << ::android::internal::ToString(enumArray); _aidl_os << ", nullArray: " << ::android::internal::ToString(nullArray); _aidl_os << ", nullList: " << ::android::internal::ToString(nullList); _aidl_os << ", parcelableGeneric: " << ::android::internal::ToString(parcelableGeneric); _aidl_os << ", unionValue: " << ::android::internal::ToString(unionValue); _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000214 15172120304 033176 xustar000000000 0000000 112 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/RecursiveList.h 28 mtime=1776853188.4730000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/RecursiveList0100644 0000000 0000000 00000005013 15172120304 033053 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/RecursiveList.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl::android::aidl::tests { class RecursiveList; } // namespace aidl::android::aidl::tests namespace aidl { namespace android { namespace aidl { namespace tests { class RecursiveList { public: typedef std::false_type fixed_size; static const char* descriptor; int32_t value = 0; std::unique_ptr<::aidl::android::aidl::tests::RecursiveList> next; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const RecursiveList& _rhs) const { return std::tie(value, next) == std::tie(_rhs.value, _rhs.next); } inline bool operator<(const RecursiveList& _rhs) const { return std::tie(value, next) < std::tie(_rhs.value, _rhs.next); } inline bool operator!=(const RecursiveList& _rhs) const { return !(*this == _rhs); } inline bool operator>(const RecursiveList& _rhs) const { return _rhs < *this; } inline bool operator>=(const RecursiveList& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const RecursiveList& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "RecursiveList{"; _aidl_os << "value: " << ::android::internal::ToString(value); _aidl_os << ", next: " << ::android::internal::ToString(next); _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000223 15172120304 033176 xustar000000000 0000000 119 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/StructuredParcelable.h 28 mtime=1776853188.4730000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/StructuredPar0100644 0000000 0000000 00000037422 15172120304 033070 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/StructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { class StructuredParcelable { public: typedef std::false_type fixed_size; static const char* descriptor; class Empty { public: typedef std::false_type fixed_size; static const char* descriptor; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const Empty&) const { return std::tie() == std::tie(); } inline bool operator<(const Empty&) const { return std::tie() < std::tie(); } inline bool operator!=(const Empty& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Empty& _rhs) const { return _rhs < *this; } inline bool operator>=(const Empty& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Empty& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "Empty{"; _aidl_os << "}"; return _aidl_os.str(); } }; std::vector shouldContainThreeFs; int32_t f = 0; std::string shouldBeJerry; ::aidl::android::aidl::tests::ByteEnum shouldBeByteBar = ::aidl::android::aidl::tests::ByteEnum(0); ::aidl::android::aidl::tests::IntEnum shouldBeIntBar = ::aidl::android::aidl::tests::IntEnum(0); ::aidl::android::aidl::tests::LongEnum shouldBeLongBar = ::aidl::android::aidl::tests::LongEnum(0); std::vector<::aidl::android::aidl::tests::ByteEnum> shouldContainTwoByteFoos; std::vector<::aidl::android::aidl::tests::IntEnum> shouldContainTwoIntFoos; std::vector<::aidl::android::aidl::tests::LongEnum> shouldContainTwoLongFoos; std::string stringDefaultsToFoo = "foo"; int8_t byteDefaultsToFour = 4; int32_t intDefaultsToFive = 5; int64_t longDefaultsToNegativeSeven = -7L; bool booleanDefaultsToTrue = true; char16_t charDefaultsToC = 'C'; float floatDefaultsToPi = 3.140000f; double doubleWithDefault = -314000000000000000.000000; std::vector arrayDefaultsTo123 = {1, 2, 3}; std::vector arrayDefaultsToEmpty = {}; bool boolDefault = false; int8_t byteDefault = 0; int32_t intDefault = 0; int64_t longDefault = 0L; float floatDefault = 0.000000f; double doubleDefault = 0.000000; double checkDoubleFromFloat = 3.140000; std::vector checkStringArray1 = {"a", "b"}; std::vector checkStringArray2 = {"a", "b"}; int32_t int32_min = -2147483648; int32_t int32_max = 2147483647; int64_t int64_max = 9223372036854775807L; int32_t hexInt32_neg_1 = -1; ::ndk::SpAIBinder ibinder; ::aidl::android::aidl::tests::StructuredParcelable::Empty empty; std::vector int8_1 = {1, 1, 1, 1, 1}; std::vector int32_1 = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}; std::vector int64_1 = {1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L}; int32_t hexInt32_pos_1 = 1; int32_t hexInt64_pos_1 = 1; ::aidl::android::aidl::tests::ConstantExpressionEnum const_exprs_1 = ::aidl::android::aidl::tests::ConstantExpressionEnum(0); ::aidl::android::aidl::tests::ConstantExpressionEnum const_exprs_2 = ::aidl::android::aidl::tests::ConstantExpressionEnum(0); ::aidl::android::aidl::tests::ConstantExpressionEnum const_exprs_3 = ::aidl::android::aidl::tests::ConstantExpressionEnum(0); ::aidl::android::aidl::tests::ConstantExpressionEnum const_exprs_4 = ::aidl::android::aidl::tests::ConstantExpressionEnum(0); ::aidl::android::aidl::tests::ConstantExpressionEnum const_exprs_5 = ::aidl::android::aidl::tests::ConstantExpressionEnum(0); ::aidl::android::aidl::tests::ConstantExpressionEnum const_exprs_6 = ::aidl::android::aidl::tests::ConstantExpressionEnum(0); ::aidl::android::aidl::tests::ConstantExpressionEnum const_exprs_7 = ::aidl::android::aidl::tests::ConstantExpressionEnum(0); ::aidl::android::aidl::tests::ConstantExpressionEnum const_exprs_8 = ::aidl::android::aidl::tests::ConstantExpressionEnum(0); ::aidl::android::aidl::tests::ConstantExpressionEnum const_exprs_9 = ::aidl::android::aidl::tests::ConstantExpressionEnum(0); ::aidl::android::aidl::tests::ConstantExpressionEnum const_exprs_10 = ::aidl::android::aidl::tests::ConstantExpressionEnum(0); std::string addString1 = "hello world!"; std::string addString2 = "The quick brown fox jumps over the lazy dog."; int32_t shouldSetBit0AndBit2 = 0; std::optional<::aidl::android::aidl::tests::Union> u; std::optional<::aidl::android::aidl::tests::Union> shouldBeConstS1; ::aidl::android::aidl::tests::IntEnum defaultWithFoo = ::aidl::android::aidl::tests::IntEnum::FOO; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const StructuredParcelable& _rhs) const { return std::tie(shouldContainThreeFs, f, shouldBeJerry, shouldBeByteBar, shouldBeIntBar, shouldBeLongBar, shouldContainTwoByteFoos, shouldContainTwoIntFoos, shouldContainTwoLongFoos, stringDefaultsToFoo, byteDefaultsToFour, intDefaultsToFive, longDefaultsToNegativeSeven, booleanDefaultsToTrue, charDefaultsToC, floatDefaultsToPi, doubleWithDefault, arrayDefaultsTo123, arrayDefaultsToEmpty, boolDefault, byteDefault, intDefault, longDefault, floatDefault, doubleDefault, checkDoubleFromFloat, checkStringArray1, checkStringArray2, int32_min, int32_max, int64_max, hexInt32_neg_1, ibinder, empty, int8_1, int32_1, int64_1, hexInt32_pos_1, hexInt64_pos_1, const_exprs_1, const_exprs_2, const_exprs_3, const_exprs_4, const_exprs_5, const_exprs_6, const_exprs_7, const_exprs_8, const_exprs_9, const_exprs_10, addString1, addString2, shouldSetBit0AndBit2, u, shouldBeConstS1, defaultWithFoo) == std::tie(_rhs.shouldContainThreeFs, _rhs.f, _rhs.shouldBeJerry, _rhs.shouldBeByteBar, _rhs.shouldBeIntBar, _rhs.shouldBeLongBar, _rhs.shouldContainTwoByteFoos, _rhs.shouldContainTwoIntFoos, _rhs.shouldContainTwoLongFoos, _rhs.stringDefaultsToFoo, _rhs.byteDefaultsToFour, _rhs.intDefaultsToFive, _rhs.longDefaultsToNegativeSeven, _rhs.booleanDefaultsToTrue, _rhs.charDefaultsToC, _rhs.floatDefaultsToPi, _rhs.doubleWithDefault, _rhs.arrayDefaultsTo123, _rhs.arrayDefaultsToEmpty, _rhs.boolDefault, _rhs.byteDefault, _rhs.intDefault, _rhs.longDefault, _rhs.floatDefault, _rhs.doubleDefault, _rhs.checkDoubleFromFloat, _rhs.checkStringArray1, _rhs.checkStringArray2, _rhs.int32_min, _rhs.int32_max, _rhs.int64_max, _rhs.hexInt32_neg_1, _rhs.ibinder, _rhs.empty, _rhs.int8_1, _rhs.int32_1, _rhs.int64_1, _rhs.hexInt32_pos_1, _rhs.hexInt64_pos_1, _rhs.const_exprs_1, _rhs.const_exprs_2, _rhs.const_exprs_3, _rhs.const_exprs_4, _rhs.const_exprs_5, _rhs.const_exprs_6, _rhs.const_exprs_7, _rhs.const_exprs_8, _rhs.const_exprs_9, _rhs.const_exprs_10, _rhs.addString1, _rhs.addString2, _rhs.shouldSetBit0AndBit2, _rhs.u, _rhs.shouldBeConstS1, _rhs.defaultWithFoo); } inline bool operator<(const StructuredParcelable& _rhs) const { return std::tie(shouldContainThreeFs, f, shouldBeJerry, shouldBeByteBar, shouldBeIntBar, shouldBeLongBar, shouldContainTwoByteFoos, shouldContainTwoIntFoos, shouldContainTwoLongFoos, stringDefaultsToFoo, byteDefaultsToFour, intDefaultsToFive, longDefaultsToNegativeSeven, booleanDefaultsToTrue, charDefaultsToC, floatDefaultsToPi, doubleWithDefault, arrayDefaultsTo123, arrayDefaultsToEmpty, boolDefault, byteDefault, intDefault, longDefault, floatDefault, doubleDefault, checkDoubleFromFloat, checkStringArray1, checkStringArray2, int32_min, int32_max, int64_max, hexInt32_neg_1, ibinder, empty, int8_1, int32_1, int64_1, hexInt32_pos_1, hexInt64_pos_1, const_exprs_1, const_exprs_2, const_exprs_3, const_exprs_4, const_exprs_5, const_exprs_6, const_exprs_7, const_exprs_8, const_exprs_9, const_exprs_10, addString1, addString2, shouldSetBit0AndBit2, u, shouldBeConstS1, defaultWithFoo) < std::tie(_rhs.shouldContainThreeFs, _rhs.f, _rhs.shouldBeJerry, _rhs.shouldBeByteBar, _rhs.shouldBeIntBar, _rhs.shouldBeLongBar, _rhs.shouldContainTwoByteFoos, _rhs.shouldContainTwoIntFoos, _rhs.shouldContainTwoLongFoos, _rhs.stringDefaultsToFoo, _rhs.byteDefaultsToFour, _rhs.intDefaultsToFive, _rhs.longDefaultsToNegativeSeven, _rhs.booleanDefaultsToTrue, _rhs.charDefaultsToC, _rhs.floatDefaultsToPi, _rhs.doubleWithDefault, _rhs.arrayDefaultsTo123, _rhs.arrayDefaultsToEmpty, _rhs.boolDefault, _rhs.byteDefault, _rhs.intDefault, _rhs.longDefault, _rhs.floatDefault, _rhs.doubleDefault, _rhs.checkDoubleFromFloat, _rhs.checkStringArray1, _rhs.checkStringArray2, _rhs.int32_min, _rhs.int32_max, _rhs.int64_max, _rhs.hexInt32_neg_1, _rhs.ibinder, _rhs.empty, _rhs.int8_1, _rhs.int32_1, _rhs.int64_1, _rhs.hexInt32_pos_1, _rhs.hexInt64_pos_1, _rhs.const_exprs_1, _rhs.const_exprs_2, _rhs.const_exprs_3, _rhs.const_exprs_4, _rhs.const_exprs_5, _rhs.const_exprs_6, _rhs.const_exprs_7, _rhs.const_exprs_8, _rhs.const_exprs_9, _rhs.const_exprs_10, _rhs.addString1, _rhs.addString2, _rhs.shouldSetBit0AndBit2, _rhs.u, _rhs.shouldBeConstS1, _rhs.defaultWithFoo); } inline bool operator!=(const StructuredParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const StructuredParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const StructuredParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const StructuredParcelable& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; enum : int32_t { BIT0 = 1 }; enum : int32_t { BIT1 = 2 }; enum : int32_t { BIT2 = 4 }; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "StructuredParcelable{"; _aidl_os << "shouldContainThreeFs: " << ::android::internal::ToString(shouldContainThreeFs); _aidl_os << ", f: " << ::android::internal::ToString(f); _aidl_os << ", shouldBeJerry: " << ::android::internal::ToString(shouldBeJerry); _aidl_os << ", shouldBeByteBar: " << ::android::internal::ToString(shouldBeByteBar); _aidl_os << ", shouldBeIntBar: " << ::android::internal::ToString(shouldBeIntBar); _aidl_os << ", shouldBeLongBar: " << ::android::internal::ToString(shouldBeLongBar); _aidl_os << ", shouldContainTwoByteFoos: " << ::android::internal::ToString(shouldContainTwoByteFoos); _aidl_os << ", shouldContainTwoIntFoos: " << ::android::internal::ToString(shouldContainTwoIntFoos); _aidl_os << ", shouldContainTwoLongFoos: " << ::android::internal::ToString(shouldContainTwoLongFoos); _aidl_os << ", stringDefaultsToFoo: " << ::android::internal::ToString(stringDefaultsToFoo); _aidl_os << ", byteDefaultsToFour: " << ::android::internal::ToString(byteDefaultsToFour); _aidl_os << ", intDefaultsToFive: " << ::android::internal::ToString(intDefaultsToFive); _aidl_os << ", longDefaultsToNegativeSeven: " << ::android::internal::ToString(longDefaultsToNegativeSeven); _aidl_os << ", booleanDefaultsToTrue: " << ::android::internal::ToString(booleanDefaultsToTrue); _aidl_os << ", charDefaultsToC: " << ::android::internal::ToString(charDefaultsToC); _aidl_os << ", floatDefaultsToPi: " << ::android::internal::ToString(floatDefaultsToPi); _aidl_os << ", doubleWithDefault: " << ::android::internal::ToString(doubleWithDefault); _aidl_os << ", arrayDefaultsTo123: " << ::android::internal::ToString(arrayDefaultsTo123); _aidl_os << ", arrayDefaultsToEmpty: " << ::android::internal::ToString(arrayDefaultsToEmpty); _aidl_os << ", boolDefault: " << ::android::internal::ToString(boolDefault); _aidl_os << ", byteDefault: " << ::android::internal::ToString(byteDefault); _aidl_os << ", intDefault: " << ::android::internal::ToString(intDefault); _aidl_os << ", longDefault: " << ::android::internal::ToString(longDefault); _aidl_os << ", floatDefault: " << ::android::internal::ToString(floatDefault); _aidl_os << ", doubleDefault: " << ::android::internal::ToString(doubleDefault); _aidl_os << ", checkDoubleFromFloat: " << ::android::internal::ToString(checkDoubleFromFloat); _aidl_os << ", checkStringArray1: " << ::android::internal::ToString(checkStringArray1); _aidl_os << ", checkStringArray2: " << ::android::internal::ToString(checkStringArray2); _aidl_os << ", int32_min: " << ::android::internal::ToString(int32_min); _aidl_os << ", int32_max: " << ::android::internal::ToString(int32_max); _aidl_os << ", int64_max: " << ::android::internal::ToString(int64_max); _aidl_os << ", hexInt32_neg_1: " << ::android::internal::ToString(hexInt32_neg_1); _aidl_os << ", ibinder: " << ::android::internal::ToString(ibinder); _aidl_os << ", empty: " << ::android::internal::ToString(empty); _aidl_os << ", int8_1: " << ::android::internal::ToString(int8_1); _aidl_os << ", int32_1: " << ::android::internal::ToString(int32_1); _aidl_os << ", int64_1: " << ::android::internal::ToString(int64_1); _aidl_os << ", hexInt32_pos_1: " << ::android::internal::ToString(hexInt32_pos_1); _aidl_os << ", hexInt64_pos_1: " << ::android::internal::ToString(hexInt64_pos_1); _aidl_os << ", const_exprs_1: " << ::android::internal::ToString(const_exprs_1); _aidl_os << ", const_exprs_2: " << ::android::internal::ToString(const_exprs_2); _aidl_os << ", const_exprs_3: " << ::android::internal::ToString(const_exprs_3); _aidl_os << ", const_exprs_4: " << ::android::internal::ToString(const_exprs_4); _aidl_os << ", const_exprs_5: " << ::android::internal::ToString(const_exprs_5); _aidl_os << ", const_exprs_6: " << ::android::internal::ToString(const_exprs_6); _aidl_os << ", const_exprs_7: " << ::android::internal::ToString(const_exprs_7); _aidl_os << ", const_exprs_8: " << ::android::internal::ToString(const_exprs_8); _aidl_os << ", const_exprs_9: " << ::android::internal::ToString(const_exprs_9); _aidl_os << ", const_exprs_10: " << ::android::internal::ToString(const_exprs_10); _aidl_os << ", addString1: " << ::android::internal::ToString(addString1); _aidl_os << ", addString2: " << ::android::internal::ToString(addString2); _aidl_os << ", shouldSetBit0AndBit2: " << ::android::internal::ToString(shouldSetBit0AndBit2); _aidl_os << ", u: " << ::android::internal::ToString(u); _aidl_os << ", shouldBeConstS1: " << ::android::internal::ToString(shouldBeConstS1); _aidl_os << ", defaultWithFoo: " << ::android::internal::ToString(defaultWithFoo); _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000034 15172120304 033176 xustar000000000 0000000 28 mtime=1776853188.4730000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/Union.h0100644 0000000 0000000 00000014423 15172120304 031573 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/Union.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/Union.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace aidl { namespace android { namespace aidl { namespace tests { class Union { public: typedef std::false_type fixed_size; static const char* descriptor; enum class Tag : int32_t { ns = 0, n = 1, m = 2, s = 3, ibinder = 4, ss = 5, be = 6, }; // Expose tag symbols for legacy code static const inline Tag ns = Tag::ns; static const inline Tag n = Tag::n; static const inline Tag m = Tag::m; static const inline Tag s = Tag::s; static const inline Tag ibinder = Tag::ibinder; static const inline Tag ss = Tag::ss; static const inline Tag be = Tag::be; template static constexpr bool _not_self = !std::is_same_v>, Union>; Union() : _value(std::in_place_index(ns)>, std::vector({})) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr Union(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit Union(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static Union make(_Tp&&... _args) { return Union(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static Union make(std::initializer_list<_Tp> _il, _Up&&... _args) { return Union(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } binder_status_t readFromParcel(const AParcel* _parcel); binder_status_t writeToParcel(AParcel* _parcel) const; inline bool operator==(const Union& _rhs) const { return _value == _rhs._value; } inline bool operator<(const Union& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const Union& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Union& _rhs) const { return _rhs < *this; } inline bool operator>=(const Union& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Union& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; static const char* S1; inline std::string toString() const { std::ostringstream os; os << "Union{"; switch (getTag()) { case ns: os << "ns: " << ::android::internal::ToString(get()); break; case n: os << "n: " << ::android::internal::ToString(get()); break; case m: os << "m: " << ::android::internal::ToString(get()); break; case s: os << "s: " << ::android::internal::ToString(get()); break; case ibinder: os << "ibinder: " << ::android::internal::ToString(get()); break; case ss: os << "ss: " << ::android::internal::ToString(get()); break; case be: os << "be: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant, int32_t, int32_t, std::string, ::ndk::SpAIBinder, std::vector, ::aidl::android::aidl::tests::ByteEnum> _value; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(Union::Tag val) { switch(val) { case Union::Tag::ns: return "ns"; case Union::Tag::n: return "n"; case Union::Tag::m: return "m"; case Union::Tag::s: return "s"; case Union::Tag::ibinder: return "ibinder"; case Union::Tag::ss: return "ss"; case Union::Tag::be: return "be"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::tests::Union::Tag::ns, aidl::android::aidl::tests::Union::Tag::n, aidl::android::aidl::tests::Union::Tag::m, aidl::android::aidl::tests::Union::Tag::s, aidl::android::aidl::tests::Union::Tag::ibinder, aidl::android::aidl::tests::Union::Tag::ss, aidl::android::aidl::tests::Union::Tag::be, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000212 15172120304 033174 xustar000000000 0000000 110 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/UnionWithFd.h 28 mtime=1776853188.4740000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/UnionWithFd.h0100644 0000000 0000000 00000012271 15172120304 032700 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/UnionWithFd.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/UnionWithFd.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace aidl { namespace android { namespace aidl { namespace tests { class UnionWithFd { public: typedef std::false_type fixed_size; static const char* descriptor; enum class Tag : int32_t { num = 0, pfd = 1, }; // Expose tag symbols for legacy code static const inline Tag num = Tag::num; static const inline Tag pfd = Tag::pfd; template static constexpr bool _not_self = !std::is_same_v>, UnionWithFd>; UnionWithFd() : _value(std::in_place_index(num)>, int32_t(0)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr UnionWithFd(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit UnionWithFd(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static UnionWithFd make(_Tp&&... _args) { return UnionWithFd(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static UnionWithFd make(std::initializer_list<_Tp> _il, _Up&&... _args) { return UnionWithFd(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } binder_status_t readFromParcel(const AParcel* _parcel); binder_status_t writeToParcel(AParcel* _parcel) const; inline bool operator==(const UnionWithFd& _rhs) const { return _value == _rhs._value; } inline bool operator<(const UnionWithFd& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const UnionWithFd& _rhs) const { return !(*this == _rhs); } inline bool operator>(const UnionWithFd& _rhs) const { return _rhs < *this; } inline bool operator>=(const UnionWithFd& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const UnionWithFd& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream os; os << "UnionWithFd{"; switch (getTag()) { case num: os << "num: " << ::android::internal::ToString(get()); break; case pfd: os << "pfd: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant _value; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(UnionWithFd::Tag val) { switch(val) { case UnionWithFd::Tag::num: return "num"; case UnionWithFd::Tag::pfd: return "pfd"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::tests::UnionWithFd::Tag::num, aidl::android::aidl::tests::UnionWithFd::Tag::pfd, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000034 15172120304 033176 xustar000000000 0000000 28 mtime=1776853188.4740000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/0040755 0000000 0000000 00000000000 15172120304 032345 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000237 15172120304 033203 xustar000000000 0000000 131 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/BnExtendableParcelable.h 28 mtime=1776853188.4740000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/BnE0100644 0000000 0000000 00000001264 15172120304 032734 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/extension/ExtendableParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000220 15172120304 033173 xustar000000000 0000000 116 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/BnMyExt.h 28 mtime=1776853188.4740000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/BnM0100644 0000000 0000000 00000001226 15172120304 032742 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/extension/MyExt.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000221 15172120304 033174 xustar000000000 0000000 117 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/BnMyExt2.h 28 mtime=1776853188.4740000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/BnM0100644 0000000 0000000 00000001230 15172120304 032735 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/extension/MyExt2.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt2.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000224 15172120304 033177 xustar000000000 0000000 120 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/BnMyExtLike.h 28 mtime=1776853188.4740000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/BnM0100644 0000000 0000000 00000001236 15172120304 032743 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/extension/MyExtLike.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExtLike.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000237 15172120304 033203 xustar000000000 0000000 131 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/BpExtendableParcelable.h 28 mtime=1776853188.4740000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/BpE0100644 0000000 0000000 00000001264 15172120304 032736 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/extension/ExtendableParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000220 15172120304 033173 xustar000000000 0000000 116 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/BpMyExt.h 28 mtime=1776853188.4740000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/BpM0100644 0000000 0000000 00000001226 15172120304 032744 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/extension/MyExt.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000221 15172120304 033174 xustar000000000 0000000 117 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/BpMyExt2.h 28 mtime=1776853188.4740000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/BpM0100644 0000000 0000000 00000001230 15172120304 032737 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/extension/MyExt2.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt2.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000224 15172120304 033177 xustar000000000 0000000 120 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/BpMyExtLike.h 28 mtime=1776853188.4740000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/BpM0100644 0000000 0000000 00000001236 15172120304 032745 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/extension/MyExtLike.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExtLike.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000235 15172120304 033201 xustar000000000 0000000 129 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/ExtendableParcelable.h 28 mtime=1776853188.4740000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/Ext0100644 0000000 0000000 00000005463 15172120304 033035 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/extension/ExtendableParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl */ #pragma once #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { namespace extension { class ExtendableParcelable { public: typedef std::false_type fixed_size; static const char* descriptor; int32_t a = 0; std::string b; ::ndk::AParcelableHolder ext{::ndk::STABILITY_LOCAL}; int64_t c = 0L; ::ndk::AParcelableHolder ext2{::ndk::STABILITY_LOCAL}; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const ExtendableParcelable& _rhs) const { return std::tie(a, b, ext, c, ext2) == std::tie(_rhs.a, _rhs.b, _rhs.ext, _rhs.c, _rhs.ext2); } inline bool operator<(const ExtendableParcelable& _rhs) const { return std::tie(a, b, ext, c, ext2) < std::tie(_rhs.a, _rhs.b, _rhs.ext, _rhs.c, _rhs.ext2); } inline bool operator!=(const ExtendableParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const ExtendableParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const ExtendableParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const ExtendableParcelable& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "ExtendableParcelable{"; _aidl_os << "a: " << ::android::internal::ToString(a); _aidl_os << ", b: " << ::android::internal::ToString(b); _aidl_os << ", ext: " << ::android::internal::ToString(ext); _aidl_os << ", c: " << ::android::internal::ToString(c); _aidl_os << ", ext2: " << ::android::internal::ToString(ext2); _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace extension } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000216 15172120304 033200 xustar000000000 0000000 114 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/MyExt.h 28 mtime=1776853188.4750000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/MyE0100644 0000000 0000000 00000004403 15172120304 032760 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/extension/MyExt.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl */ #pragma once #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { namespace extension { class MyExt { public: typedef std::false_type fixed_size; static const char* descriptor; int32_t a = 0; std::string b; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const MyExt& _rhs) const { return std::tie(a, b) == std::tie(_rhs.a, _rhs.b); } inline bool operator<(const MyExt& _rhs) const { return std::tie(a, b) < std::tie(_rhs.a, _rhs.b); } inline bool operator!=(const MyExt& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyExt& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyExt& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyExt& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "MyExt{"; _aidl_os << "a: " << ::android::internal::ToString(a); _aidl_os << ", b: " << ::android::internal::ToString(b); _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace extension } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000217 15172120304 033201 xustar000000000 0000000 115 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/MyExt2.h 28 mtime=1776853188.4750000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/MyE0100644 0000000 0000000 00000005076 15172120304 032767 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/extension/MyExt2.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt2.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl::android::aidl::tests::extension { class MyExt; } // namespace aidl::android::aidl::tests::extension namespace aidl { namespace android { namespace aidl { namespace tests { namespace extension { class MyExt2 { public: typedef std::false_type fixed_size; static const char* descriptor; int32_t a = 0; ::aidl::android::aidl::tests::extension::MyExt b; std::string c; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const MyExt2& _rhs) const { return std::tie(a, b, c) == std::tie(_rhs.a, _rhs.b, _rhs.c); } inline bool operator<(const MyExt2& _rhs) const { return std::tie(a, b, c) < std::tie(_rhs.a, _rhs.b, _rhs.c); } inline bool operator!=(const MyExt2& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyExt2& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyExt2& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyExt2& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "MyExt2{"; _aidl_os << "a: " << ::android::internal::ToString(a); _aidl_os << ", b: " << ::android::internal::ToString(b); _aidl_os << ", c: " << ::android::internal::ToString(c); _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace extension } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000222 15172120304 033175 xustar000000000 0000000 118 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/MyExtLike.h 28 mtime=1776853188.4750000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/MyE0100644 0000000 0000000 00000004453 15172120304 032765 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/extension/MyExtLike.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExtLike.aidl */ #pragma once #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { namespace extension { class MyExtLike { public: typedef std::false_type fixed_size; static const char* descriptor; int32_t a = 0; std::string b; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const MyExtLike& _rhs) const { return std::tie(a, b) == std::tie(_rhs.a, _rhs.b); } inline bool operator<(const MyExtLike& _rhs) const { return std::tie(a, b) < std::tie(_rhs.a, _rhs.b); } inline bool operator!=(const MyExtLike& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyExtLike& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyExtLike& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyExtLike& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "MyExtLike{"; _aidl_os << "a: " << ::android::internal::ToString(a); _aidl_os << ", b: " << ::android::internal::ToString(b); _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace extension } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000034 15172120304 033176 xustar000000000 0000000 28 mtime=1776853188.4750000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested/0040755 0000000 0000000 00000000000 15172120304 031613 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000224 15172120304 033177 xustar000000000 0000000 120 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested/BnDeeplyNested.h 28 mtime=1776853188.4750000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested/BnDeep0100644 0000000 0000000 00000001236 15172120304 032672 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/nested/DeeplyNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/DeeplyNested.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000225 15172120304 033200 xustar000000000 0000000 121 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested/BnNestedService.h 28 mtime=1776853188.4750000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested/BnNest0100644 0000000 0000000 00000003721 15172120304 032727 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/nested/INestedService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/INestedService.aidl */ #pragma once #include "aidl/android/aidl/tests/nested/INestedService.h" #include #include #ifndef __BIONIC__ #ifndef __assert2 #define __assert2(a,b,c,d) ((void)0) #endif #endif namespace aidl { namespace android { namespace aidl { namespace tests { namespace nested { class BnNestedService : public ::ndk::BnCInterface { public: BnNestedService(); virtual ~BnNestedService(); protected: ::ndk::SpAIBinder createBinder() override; private: }; class INestedServiceDelegator : public BnNestedService { public: explicit INestedServiceDelegator(const std::shared_ptr &impl) : _impl(impl) { } ::ndk::ScopedAStatus flipStatus(const ::aidl::android::aidl::tests::nested::ParcelableWithNested& in_p, ::aidl::android::aidl::tests::nested::INestedService::Result* _aidl_return) override { return _impl->flipStatus(in_p, _aidl_return); } ::ndk::ScopedAStatus flipStatusWithCallback(::aidl::android::aidl::tests::nested::ParcelableWithNested::Status in_status, const std::shared_ptr<::aidl::android::aidl::tests::nested::INestedService::ICallback>& in_cb) override { return _impl->flipStatusWithCallback(in_status, in_cb); } protected: private: std::shared_ptr _impl; }; } // namespace nested } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000234 15172120304 033200 xustar000000000 0000000 128 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested/BnParcelableWithNested.h 28 mtime=1776853188.4750000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested/BnParc0100644 0000000 0000000 00000001256 15172120304 032704 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/nested/ParcelableWithNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000224 15172120304 033177 xustar000000000 0000000 120 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested/BpDeeplyNested.h 28 mtime=1776853188.4750000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested/BpDeep0100644 0000000 0000000 00000001236 15172120304 032674 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/nested/DeeplyNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/DeeplyNested.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000225 15172120304 033200 xustar000000000 0000000 121 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested/BpNestedService.h 28 mtime=1776853188.4750000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested/BpNest0100644 0000000 0000000 00000002756 15172120304 032740 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/nested/INestedService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/INestedService.aidl */ #pragma once #include "aidl/android/aidl/tests/nested/INestedService.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { namespace nested { class BpNestedService : public ::ndk::BpCInterface { public: explicit BpNestedService(const ::ndk::SpAIBinder& binder); virtual ~BpNestedService(); ::ndk::ScopedAStatus flipStatus(const ::aidl::android::aidl::tests::nested::ParcelableWithNested& in_p, ::aidl::android::aidl::tests::nested::INestedService::Result* _aidl_return) override; ::ndk::ScopedAStatus flipStatusWithCallback(::aidl::android::aidl::tests::nested::ParcelableWithNested::Status in_status, const std::shared_ptr<::aidl::android::aidl::tests::nested::INestedService::ICallback>& in_cb) override; }; } // namespace nested } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000234 15172120304 033200 xustar000000000 0000000 128 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested/BpParcelableWithNested.h 28 mtime=1776853188.4750000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested/BpParc0100644 0000000 0000000 00000001256 15172120304 032706 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/nested/ParcelableWithNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000222 15172120304 033175 xustar000000000 0000000 118 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested/DeeplyNested.h 28 mtime=1776853188.4750000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested/Deeply0100644 0000000 0000000 00000016637 15172120304 032772 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/nested/DeeplyNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/DeeplyNested.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { namespace nested { class DeeplyNested { public: typedef std::false_type fixed_size; static const char* descriptor; class B { public: typedef std::false_type fixed_size; static const char* descriptor; class C { public: typedef std::false_type fixed_size; static const char* descriptor; class D { public: typedef std::false_type fixed_size; static const char* descriptor; enum class E : int8_t { OK = 0, }; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const D&) const { return std::tie() == std::tie(); } inline bool operator<(const D&) const { return std::tie() < std::tie(); } inline bool operator!=(const D& _rhs) const { return !(*this == _rhs); } inline bool operator>(const D& _rhs) const { return _rhs < *this; } inline bool operator>=(const D& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const D& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "D{"; _aidl_os << "}"; return _aidl_os.str(); } }; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const C&) const { return std::tie() == std::tie(); } inline bool operator<(const C&) const { return std::tie() < std::tie(); } inline bool operator!=(const C& _rhs) const { return !(*this == _rhs); } inline bool operator>(const C& _rhs) const { return _rhs < *this; } inline bool operator>=(const C& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const C& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "C{"; _aidl_os << "}"; return _aidl_os.str(); } }; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const B&) const { return std::tie() == std::tie(); } inline bool operator<(const B&) const { return std::tie() < std::tie(); } inline bool operator!=(const B& _rhs) const { return !(*this == _rhs); } inline bool operator>(const B& _rhs) const { return _rhs < *this; } inline bool operator>=(const B& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const B& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "B{"; _aidl_os << "}"; return _aidl_os.str(); } }; class A { public: typedef std::false_type fixed_size; static const char* descriptor; ::aidl::android::aidl::tests::nested::DeeplyNested::B::C::D::E e = ::aidl::android::aidl::tests::nested::DeeplyNested::B::C::D::E::OK; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const A& _rhs) const { return std::tie(e) == std::tie(_rhs.e); } inline bool operator<(const A& _rhs) const { return std::tie(e) < std::tie(_rhs.e); } inline bool operator!=(const A& _rhs) const { return !(*this == _rhs); } inline bool operator>(const A& _rhs) const { return _rhs < *this; } inline bool operator>=(const A& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const A& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "A{"; _aidl_os << "e: " << ::android::internal::ToString(e); _aidl_os << "}"; return _aidl_os.str(); } }; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const DeeplyNested&) const { return std::tie() == std::tie(); } inline bool operator<(const DeeplyNested&) const { return std::tie() < std::tie(); } inline bool operator!=(const DeeplyNested& _rhs) const { return !(*this == _rhs); } inline bool operator>(const DeeplyNested& _rhs) const { return _rhs < *this; } inline bool operator>=(const DeeplyNested& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const DeeplyNested& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "DeeplyNested{"; _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace nested } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { namespace nested { [[nodiscard]] static inline std::string toString(DeeplyNested::B::C::D::E val) { switch(val) { case DeeplyNested::B::C::D::E::OK: return "OK"; default: return std::to_string(static_cast(val)); } } } // namespace nested } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::tests::nested::DeeplyNested::B::C::D::E::OK, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000224 15172120304 033177 xustar000000000 0000000 120 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested/INestedService.h 28 mtime=1776853188.4760000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested/INeste0100644 0000000 0000000 00000014163 15172120304 032727 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/nested/INestedService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/INestedService.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl::android::aidl::tests::nested { class ParcelableWithNested; } // namespace aidl::android::aidl::tests::nested namespace aidl { namespace android { namespace aidl { namespace tests { namespace nested { class INestedServiceDelegator; class INestedService : public ::ndk::ICInterface { public: typedef INestedServiceDelegator DefaultDelegator; static const char* descriptor; INestedService(); virtual ~INestedService(); class Result { public: typedef std::false_type fixed_size; static const char* descriptor; ::aidl::android::aidl::tests::nested::ParcelableWithNested::Status status = ::aidl::android::aidl::tests::nested::ParcelableWithNested::Status::OK; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const Result& _rhs) const { return std::tie(status) == std::tie(_rhs.status); } inline bool operator<(const Result& _rhs) const { return std::tie(status) < std::tie(_rhs.status); } inline bool operator!=(const Result& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Result& _rhs) const { return _rhs < *this; } inline bool operator>=(const Result& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Result& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "Result{"; _aidl_os << "status: " << ::android::internal::ToString(status); _aidl_os << "}"; return _aidl_os.str(); } }; class ICallbackDelegator; class ICallback : public ::ndk::ICInterface { public: typedef ICallbackDelegator DefaultDelegator; static const char* descriptor; ICallback(); virtual ~ICallback(); static constexpr uint32_t TRANSACTION_done = FIRST_CALL_TRANSACTION + 0; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus done(::aidl::android::aidl::tests::nested::ParcelableWithNested::Status in_status) = 0; private: static std::shared_ptr default_impl; }; class ICallbackDefault : public ICallback { public: ::ndk::ScopedAStatus done(::aidl::android::aidl::tests::nested::ParcelableWithNested::Status in_status) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; class BpCallback : public ::ndk::BpCInterface { public: explicit BpCallback(const ::ndk::SpAIBinder& binder); virtual ~BpCallback(); ::ndk::ScopedAStatus done(::aidl::android::aidl::tests::nested::ParcelableWithNested::Status in_status) override; }; class BnCallback : public ::ndk::BnCInterface { public: BnCallback(); virtual ~BnCallback(); protected: ::ndk::SpAIBinder createBinder() override; private: }; static constexpr uint32_t TRANSACTION_flipStatus = FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_flipStatusWithCallback = FIRST_CALL_TRANSACTION + 1; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus flipStatus(const ::aidl::android::aidl::tests::nested::ParcelableWithNested& in_p, ::aidl::android::aidl::tests::nested::INestedService::Result* _aidl_return) = 0; virtual ::ndk::ScopedAStatus flipStatusWithCallback(::aidl::android::aidl::tests::nested::ParcelableWithNested::Status in_status, const std::shared_ptr<::aidl::android::aidl::tests::nested::INestedService::ICallback>& in_cb) = 0; private: static std::shared_ptr default_impl; }; class INestedServiceDefault : public INestedService { public: ::ndk::ScopedAStatus flipStatus(const ::aidl::android::aidl::tests::nested::ParcelableWithNested& in_p, ::aidl::android::aidl::tests::nested::INestedService::Result* _aidl_return) override; ::ndk::ScopedAStatus flipStatusWithCallback(::aidl::android::aidl::tests::nested::ParcelableWithNested::Status in_status, const std::shared_ptr<::aidl::android::aidl::tests::nested::INestedService::ICallback>& in_cb) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; } // namespace nested } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000232 15172120304 033176 xustar000000000 0000000 126 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested/ParcelableWithNested.h 28 mtime=1776853188.4760000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested/Parcel0100644 0000000 0000000 00000007213 15172120304 032744 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/nested/ParcelableWithNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { namespace nested { class ParcelableWithNested { public: typedef std::false_type fixed_size; static const char* descriptor; enum class Status : int8_t { OK = 0, NOT_OK = 1, }; ::aidl::android::aidl::tests::nested::ParcelableWithNested::Status status = ::aidl::android::aidl::tests::nested::ParcelableWithNested::Status::OK; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const ParcelableWithNested& _rhs) const { return std::tie(status) == std::tie(_rhs.status); } inline bool operator<(const ParcelableWithNested& _rhs) const { return std::tie(status) < std::tie(_rhs.status); } inline bool operator!=(const ParcelableWithNested& _rhs) const { return !(*this == _rhs); } inline bool operator>(const ParcelableWithNested& _rhs) const { return _rhs < *this; } inline bool operator>=(const ParcelableWithNested& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const ParcelableWithNested& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "ParcelableWithNested{"; _aidl_os << "status: " << ::android::internal::ToString(status); _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace nested } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { namespace nested { [[nodiscard]] static inline std::string toString(ParcelableWithNested::Status val) { switch(val) { case ParcelableWithNested::Status::OK: return "OK"; case ParcelableWithNested::Status::NOT_OK: return "NOT_OK"; default: return std::to_string(static_cast(val)); } } } // namespace nested } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::tests::nested::ParcelableWithNested::Status::OK, aidl::android::aidl::tests::nested::ParcelableWithNested::Status::NOT_OK, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000034 15172120304 033176 xustar000000000 0000000 28 mtime=1776853188.4760000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/unions/0040755 0000000 0000000 00000000000 15172120304 031644 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000221 15172120304 033174 xustar000000000 0000000 117 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/unions/BnEnumUnion.h 28 mtime=1776853188.4760000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/unions/BnEnum0100644 0000000 0000000 00000001230 15172120304 032744 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/unions/EnumUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000224 15172120304 033177 xustar000000000 0000000 120 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/unions/BnUnionInUnion.h 28 mtime=1776853188.4760000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/unions/BnUnio0100644 0000000 0000000 00000001236 15172120304 032760 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/unions/UnionInUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/UnionInUnion.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000221 15172120304 033174 xustar000000000 0000000 117 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/unions/BpEnumUnion.h 28 mtime=1776853188.4760000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/unions/BpEnum0100644 0000000 0000000 00000001230 15172120304 032746 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/unions/EnumUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000224 15172120304 033177 xustar000000000 0000000 120 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/unions/BpUnionInUnion.h 28 mtime=1776853188.4760000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/unions/BpUnio0100644 0000000 0000000 00000001236 15172120304 032762 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/unions/UnionInUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/UnionInUnion.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000217 15172120304 033201 xustar000000000 0000000 115 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/unions/EnumUnion.h 28 mtime=1776853188.4760000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/unions/EnumUn0100644 0000000 0000000 00000014432 15172120304 032777 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/unions/EnumUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace aidl { namespace android { namespace aidl { namespace tests { namespace unions { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" class EnumUnion { public: typedef std::false_type fixed_size; static const char* descriptor; enum class Tag : int32_t { intEnum = 0, longEnum = 1, deprecatedField __attribute__((deprecated("do not use this"))) = 2, }; // Expose tag symbols for legacy code static const inline Tag intEnum = Tag::intEnum; static const inline Tag longEnum = Tag::longEnum; static const inline Tag __attribute__((deprecated("do not use this"))) deprecatedField = Tag::deprecatedField; template static constexpr bool _not_self = !std::is_same_v>, EnumUnion>; EnumUnion() : _value(std::in_place_index(intEnum)>, ::aidl::android::aidl::tests::IntEnum(::aidl::android::aidl::tests::IntEnum::FOO)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr EnumUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit EnumUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static EnumUnion make(_Tp&&... _args) { return EnumUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static EnumUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return EnumUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } binder_status_t readFromParcel(const AParcel* _parcel); binder_status_t writeToParcel(AParcel* _parcel) const; inline bool operator==(const EnumUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const EnumUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const EnumUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const EnumUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const EnumUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const EnumUnion& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream os; os << "EnumUnion{"; switch (getTag()) { case intEnum: os << "intEnum: " << ::android::internal::ToString(get()); break; case longEnum: os << "longEnum: " << ::android::internal::ToString(get()); break; case deprecatedField: os << "deprecatedField: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant<::aidl::android::aidl::tests::IntEnum, ::aidl::android::aidl::tests::LongEnum, int32_t> _value; }; #pragma clang diagnostic pop } // namespace unions } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { namespace unions { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" [[nodiscard]] static inline std::string toString(EnumUnion::Tag val) { switch(val) { case EnumUnion::Tag::intEnum: return "intEnum"; case EnumUnion::Tag::longEnum: return "longEnum"; case EnumUnion::Tag::deprecatedField: return "deprecatedField"; default: return std::to_string(static_cast(val)); } } #pragma clang diagnostic pop } // namespace unions } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" #pragma clang diagnostic ignored "-Wdeprecated-declarations" template <> constexpr inline std::array enum_values = { aidl::android::aidl::tests::unions::EnumUnion::Tag::intEnum, aidl::android::aidl::tests::unions::EnumUnion::Tag::longEnum, aidl::android::aidl::tests::unions::EnumUnion::Tag::deprecatedField, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_include_aidl_android_aidl_tes0100644 0000000 0000000 00000000222 15172120304 033175 xustar000000000 0000000 118 path=tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/unions/UnionInUnion.h 28 mtime=1776853188.4760000 tests/golden_output/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/unions/UnionI0100644 0000000 0000000 00000012764 15172120304 032777 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/unions/UnionInUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/UnionInUnion.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace aidl { namespace android { namespace aidl { namespace tests { namespace unions { class UnionInUnion { public: typedef std::false_type fixed_size; static const char* descriptor; enum class Tag : int32_t { first = 0, second = 1, }; // Expose tag symbols for legacy code static const inline Tag first = Tag::first; static const inline Tag second = Tag::second; template static constexpr bool _not_self = !std::is_same_v>, UnionInUnion>; UnionInUnion() : _value(std::in_place_index(first)>, ::aidl::android::aidl::tests::unions::EnumUnion()) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr UnionInUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit UnionInUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static UnionInUnion make(_Tp&&... _args) { return UnionInUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static UnionInUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return UnionInUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } binder_status_t readFromParcel(const AParcel* _parcel); binder_status_t writeToParcel(AParcel* _parcel) const; inline bool operator==(const UnionInUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const UnionInUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const UnionInUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const UnionInUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const UnionInUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const UnionInUnion& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream os; os << "UnionInUnion{"; switch (getTag()) { case first: os << "first: " << ::android::internal::ToString(get()); break; case second: os << "second: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant<::aidl::android::aidl::tests::unions::EnumUnion, int32_t> _value; }; } // namespace unions } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { namespace unions { [[nodiscard]] static inline std::string toString(UnionInUnion::Tag val) { switch(val) { case UnionInUnion::Tag::first: return "first"; case UnionInUnion::Tag::second: return "second"; default: return std::to_string(static_cast(val)); } } } // namespace unions } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::tests::unions::UnionInUnion::Tag::first, aidl::android::aidl::tests::unions::UnionInUnion::Tag::second, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_aidl-test-interface-ndk-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 027221 xustar000000000 0000000 28 mtime=1776853188.4760000 tests/golden_output/aidl-test-interface-ndk-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 024213 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-permission-java-source_0100644 0000000 0000000 00000000034 15172120304 026777 xustar000000000 0000000 28 mtime=1776853188.4760000 tests/golden_output/aidl-test-interface-permission-java-source/0040755 0000000 0000000 00000000000 15172120304 024064 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-permission-java-source_gen_0100644 0000000 0000000 00000000034 15172120304 027630 xustar000000000 0000000 28 mtime=1776853188.4760000 tests/golden_output/aidl-test-interface-permission-java-source/gen/0040755 0000000 0000000 00000000000 15172120304 024635 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-permission-java-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 031330 xustar000000000 0000000 28 mtime=1776853188.4760000 tests/golden_output/aidl-test-interface-permission-java-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 026255 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-permission-java-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 032321 xustar000000000 0000000 28 mtime=1776853188.4760000 tests/golden_output/aidl-test-interface-permission-java-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 027166 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-permission-java-source_gen_android_aidl_test0100644 0000000 0000000 00000000034 15172120304 033221 xustar000000000 0000000 28 mtime=1776853188.4760000 tests/golden_output/aidl-test-interface-permission-java-source/gen/android/aidl/tests/0040755 0000000 0000000 00000000000 15172120304 030330 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-permission-java-source_gen_android_aidl_test0100644 0000000 0000000 00000000034 15172120304 033221 xustar000000000 0000000 28 mtime=1776853188.4760000 tests/golden_output/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/0040755 0000000 0000000 00000000000 15172120304 032520 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-permission-java-source_gen_android_aidl_test0100644 0000000 0000000 00000000231 15172120304 033220 xustar000000000 0000000 125 path=tests/golden_output/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/INoPermission.java 28 mtime=1776853188.4760000 tests/golden_output/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/INo0100644 0000000 0000000 00000010662 15172120304 033132 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/INoPermission.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-permission-java-source/gen -Iframeworks/base/core/java -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/permission/INoPermission.aidl */ package android.aidl.tests.permission; public interface INoPermission extends android.os.IInterface { /** Default implementation for INoPermission. */ public static class Default implements android.aidl.tests.permission.INoPermission { @Override public void foo() throws android.os.RemoteException { } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.permission.INoPermission { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.permission.INoPermission interface, * generating a proxy if needed. */ public static android.aidl.tests.permission.INoPermission asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.permission.INoPermission))) { return ((android.aidl.tests.permission.INoPermission)iin); } return new android.aidl.tests.permission.INoPermission.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_foo: { return "foo"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_foo: { this.foo(); reply.writeNoException(); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.permission.INoPermission { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public void foo() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_foo, _data, _reply, 0); _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } } static final int TRANSACTION_foo = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.permission.INoPermission"; @android.annotation.RequiresNoPermission public void foo() throws android.os.RemoteException; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-permission-java-source_gen_android_aidl_test0100644 0000000 0000000 00000000233 15172120304 033222 xustar000000000 0000000 127 path=tests/golden_output/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/INoPermission.java.d 28 mtime=1776853188.4790000 tests/golden_output/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/INo0100644 0000000 0000000 00000000332 15172120304 033123 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/INoPermission.java : \ system/tools/aidl/tests/android/aidl/tests/permission/INoPermission.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-permission-java-source_gen_android_aidl_test0100644 0000000 0000000 00000000226 15172120304 033224 xustar000000000 0000000 122 path=tests/golden_output/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/IProtected.java 28 mtime=1776853188.4790000 tests/golden_output/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/IPr0100644 0000000 0000000 00000033010 15172120304 033127 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/IProtected.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-permission-java-source/gen -Iframeworks/base/core/java -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/permission/IProtected.aidl */ package android.aidl.tests.permission; public interface IProtected extends android.os.IInterface { /** Default implementation for IProtected. */ public static class Default implements android.aidl.tests.permission.IProtected { @Override public void PermissionProtected() throws android.os.RemoteException { } @Override public void MultiplePermissionsAll() throws android.os.RemoteException { } @Override public void MultiplePermissionsAny() throws android.os.RemoteException { } @Override public void NonManifestPermission() throws android.os.RemoteException { } // Used by the integration tests to dynamically set permissions that are considered granted. @Override public void Grant(java.lang.String permission) throws android.os.RemoteException { } @Override public void Revoke(java.lang.String permission) throws android.os.RemoteException { } @Override public void RevokeAll() throws android.os.RemoteException { } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.permission.IProtected { private final android.os.PermissionEnforcer mEnforcer; /** Construct the stub using the Enforcer provided. */ public Stub(android.os.PermissionEnforcer enforcer) { this.attachInterface(this, DESCRIPTOR); if (enforcer == null) { throw new IllegalArgumentException("enforcer cannot be null"); } mEnforcer = enforcer; } @Deprecated /** Default constructor. */ public Stub() { this(android.os.PermissionEnforcer.fromContext( android.app.ActivityThread.currentActivityThread().getSystemContext())); } /** * Cast an IBinder object into an android.aidl.tests.permission.IProtected interface, * generating a proxy if needed. */ public static android.aidl.tests.permission.IProtected asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.permission.IProtected))) { return ((android.aidl.tests.permission.IProtected)iin); } return new android.aidl.tests.permission.IProtected.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_PermissionProtected: { return "PermissionProtected"; } case TRANSACTION_MultiplePermissionsAll: { return "MultiplePermissionsAll"; } case TRANSACTION_MultiplePermissionsAny: { return "MultiplePermissionsAny"; } case TRANSACTION_NonManifestPermission: { return "NonManifestPermission"; } case TRANSACTION_Grant: { return "Grant"; } case TRANSACTION_Revoke: { return "Revoke"; } case TRANSACTION_RevokeAll: { return "RevokeAll"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_PermissionProtected: { this.PermissionProtected(); reply.writeNoException(); break; } case TRANSACTION_MultiplePermissionsAll: { this.MultiplePermissionsAll(); reply.writeNoException(); break; } case TRANSACTION_MultiplePermissionsAny: { this.MultiplePermissionsAny(); reply.writeNoException(); break; } case TRANSACTION_NonManifestPermission: { this.NonManifestPermission(); reply.writeNoException(); break; } case TRANSACTION_Grant: { java.lang.String _arg0; _arg0 = data.readString(); data.enforceNoDataAvail(); this.Grant(_arg0); reply.writeNoException(); break; } case TRANSACTION_Revoke: { java.lang.String _arg0; _arg0 = data.readString(); data.enforceNoDataAvail(); this.Revoke(_arg0); reply.writeNoException(); break; } case TRANSACTION_RevokeAll: { this.RevokeAll(); reply.writeNoException(); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.permission.IProtected { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public void PermissionProtected() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_PermissionProtected, _data, _reply, 0); _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } @Override public void MultiplePermissionsAll() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_MultiplePermissionsAll, _data, _reply, 0); _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } @Override public void MultiplePermissionsAny() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_MultiplePermissionsAny, _data, _reply, 0); _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } @Override public void NonManifestPermission() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_NonManifestPermission, _data, _reply, 0); _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } // Used by the integration tests to dynamically set permissions that are considered granted. @Override public void Grant(java.lang.String permission) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeString(permission); boolean _status = mRemote.transact(Stub.TRANSACTION_Grant, _data, _reply, 0); _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } @Override public void Revoke(java.lang.String permission) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeString(permission); boolean _status = mRemote.transact(Stub.TRANSACTION_Revoke, _data, _reply, 0); _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } @Override public void RevokeAll() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_RevokeAll, _data, _reply, 0); _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } } static final int TRANSACTION_PermissionProtected = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); /** Helper method to enforce permissions for PermissionProtected */ protected void PermissionProtected_enforcePermission() throws SecurityException { mEnforcer.enforcePermission(android.Manifest.permission.READ_PHONE_STATE, getCallingPid(), getCallingUid()); } static final int TRANSACTION_MultiplePermissionsAll = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1); static final String[] PERMISSIONS_MultiplePermissionsAll = {android.Manifest.permission.INTERNET, android.Manifest.permission.VIBRATE}; /** Helper method to enforce permissions for MultiplePermissionsAll */ protected void MultiplePermissionsAll_enforcePermission() throws SecurityException { mEnforcer.enforcePermissionAllOf(PERMISSIONS_MultiplePermissionsAll, getCallingPid(), getCallingUid()); } static final int TRANSACTION_MultiplePermissionsAny = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2); static final String[] PERMISSIONS_MultiplePermissionsAny = {android.Manifest.permission.INTERNET, android.Manifest.permission.VIBRATE}; /** Helper method to enforce permissions for MultiplePermissionsAny */ protected void MultiplePermissionsAny_enforcePermission() throws SecurityException { mEnforcer.enforcePermissionAnyOf(PERMISSIONS_MultiplePermissionsAny, getCallingPid(), getCallingUid()); } static final int TRANSACTION_NonManifestPermission = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3); /** Helper method to enforce permissions for NonManifestPermission */ protected void NonManifestPermission_enforcePermission() throws SecurityException { mEnforcer.enforcePermission(android.net.NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK, getCallingPid(), getCallingUid()); } static final int TRANSACTION_Grant = (android.os.IBinder.FIRST_CALL_TRANSACTION + 4); static final int TRANSACTION_Revoke = (android.os.IBinder.FIRST_CALL_TRANSACTION + 5); static final int TRANSACTION_RevokeAll = (android.os.IBinder.FIRST_CALL_TRANSACTION + 6); /** @hide */ public int getMaxTransactionId() { return 6; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.permission.IProtected"; @android.annotation.EnforcePermission(android.Manifest.permission.READ_PHONE_STATE) public void PermissionProtected() throws android.os.RemoteException; @android.annotation.EnforcePermission(allOf = {android.Manifest.permission.INTERNET, android.Manifest.permission.VIBRATE}) public void MultiplePermissionsAll() throws android.os.RemoteException; @android.annotation.EnforcePermission(anyOf = {android.Manifest.permission.INTERNET, android.Manifest.permission.VIBRATE}) public void MultiplePermissionsAny() throws android.os.RemoteException; @android.annotation.EnforcePermission(android.net.NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK) public void NonManifestPermission() throws android.os.RemoteException; // Used by the integration tests to dynamically set permissions that are considered granted. @android.annotation.RequiresNoPermission public void Grant(java.lang.String permission) throws android.os.RemoteException; @android.annotation.RequiresNoPermission public void Revoke(java.lang.String permission) throws android.os.RemoteException; @android.annotation.RequiresNoPermission public void RevokeAll() throws android.os.RemoteException; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-permission-java-source_gen_android_aidl_test0100644 0000000 0000000 00000000230 15172120304 033217 xustar000000000 0000000 124 path=tests/golden_output/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/IProtected.java.d 28 mtime=1776853188.4790000 tests/golden_output/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/IPr0100644 0000000 0000000 00000000324 15172120304 033131 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/IProtected.java : \ system/tools/aidl/tests/android/aidl/tests/permission/IProtected.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-permission-java-source_gen_android_aidl_test0100644 0000000 0000000 00000000237 15172120304 033226 xustar000000000 0000000 131 path=tests/golden_output/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/IProtectedInterface.java 28 mtime=1776853188.4790000 tests/golden_output/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/IPr0100644 0000000 0000000 00000014777 15172120304 033152 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/IProtectedInterface.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-permission-java-source/gen -Iframeworks/base/core/java -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/permission/IProtectedInterface.aidl */ package android.aidl.tests.permission; public interface IProtectedInterface extends android.os.IInterface { /** Default implementation for IProtectedInterface. */ public static class Default implements android.aidl.tests.permission.IProtectedInterface { @Override public void Method1() throws android.os.RemoteException { } @Override public void Method2() throws android.os.RemoteException { } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.permission.IProtectedInterface { private final android.os.PermissionEnforcer mEnforcer; /** Construct the stub using the Enforcer provided. */ public Stub(android.os.PermissionEnforcer enforcer) { this.attachInterface(this, DESCRIPTOR); if (enforcer == null) { throw new IllegalArgumentException("enforcer cannot be null"); } mEnforcer = enforcer; } @Deprecated /** Default constructor. */ public Stub() { this(android.os.PermissionEnforcer.fromContext( android.app.ActivityThread.currentActivityThread().getSystemContext())); } /** * Cast an IBinder object into an android.aidl.tests.permission.IProtectedInterface interface, * generating a proxy if needed. */ public static android.aidl.tests.permission.IProtectedInterface asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.permission.IProtectedInterface))) { return ((android.aidl.tests.permission.IProtectedInterface)iin); } return new android.aidl.tests.permission.IProtectedInterface.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_Method1: { return "Method1"; } case TRANSACTION_Method2: { return "Method2"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_Method1: { this.Method1(); reply.writeNoException(); break; } case TRANSACTION_Method2: { this.Method2(); reply.writeNoException(); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.permission.IProtectedInterface { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public void Method1() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_Method1, _data, _reply, 0); _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } @Override public void Method2() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_Method2, _data, _reply, 0); _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } } static final int TRANSACTION_Method1 = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); /** Helper method to enforce permissions for Method1 */ protected void Method1_enforcePermission() throws SecurityException { mEnforcer.enforcePermission(android.Manifest.permission.ACCESS_FINE_LOCATION, getCallingPid(), getCallingUid()); } static final int TRANSACTION_Method2 = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1); /** Helper method to enforce permissions for Method2 */ protected void Method2_enforcePermission() throws SecurityException { mEnforcer.enforcePermission(android.Manifest.permission.ACCESS_FINE_LOCATION, getCallingPid(), getCallingUid()); } /** @hide */ public int getMaxTransactionId() { return 1; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.permission.IProtectedInterface"; @android.annotation.EnforcePermission(android.Manifest.permission.ACCESS_FINE_LOCATION) public void Method1() throws android.os.RemoteException; @android.annotation.EnforcePermission(android.Manifest.permission.ACCESS_FINE_LOCATION) public void Method2() throws android.os.RemoteException; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-permission-java-source_gen_android_aidl_test0100644 0000000 0000000 00000000241 15172120304 033221 xustar000000000 0000000 133 path=tests/golden_output/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/IProtectedInterface.java.d 28 mtime=1776853188.4790000 tests/golden_output/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/IPr0100644 0000000 0000000 00000000346 15172120304 033135 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/IProtectedInterface.java : \ system/tools/aidl/tests/android/aidl/tests/permission/IProtectedInterface.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-permission-java-source_gen_android_aidl_test0100644 0000000 0000000 00000000220 15172120304 033216 xustar000000000 0000000 116 path=tests/golden_output/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/platform/ 28 mtime=1776853188.4790000 tests/golden_output/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/pla0040755 0000000 0000000 00000000000 15172120304 033215 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-permission-java-source_gen_android_aidl_test0100644 0000000 0000000 00000000237 15172120304 033226 xustar000000000 0000000 131 path=tests/golden_output/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/platform/IProtected.java 28 mtime=1776853188.4790000 tests/golden_output/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/pla0100644 0000000 0000000 00000013752 15172120304 033224 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/platform/IProtected.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-permission-java-source/gen -Iframeworks/base/core/java -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/permission/platform/IProtected.aidl */ package android.aidl.tests.permission.platform; public interface IProtected extends android.os.IInterface { /** Default implementation for IProtected. */ public static class Default implements android.aidl.tests.permission.platform.IProtected { @Override public void ProtectedWithSourceAttribution(android.content.AttributionSource source) throws android.os.RemoteException { } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.permission.platform.IProtected { private final android.os.PermissionEnforcer mEnforcer; /** Construct the stub using the Enforcer provided. */ public Stub(android.os.PermissionEnforcer enforcer) { this.attachInterface(this, DESCRIPTOR); if (enforcer == null) { throw new IllegalArgumentException("enforcer cannot be null"); } mEnforcer = enforcer; } @Deprecated /** Default constructor. */ public Stub() { this(android.os.PermissionEnforcer.fromContext( android.app.ActivityThread.currentActivityThread().getSystemContext())); } /** * Cast an IBinder object into an android.aidl.tests.permission.platform.IProtected interface, * generating a proxy if needed. */ public static android.aidl.tests.permission.platform.IProtected asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.permission.platform.IProtected))) { return ((android.aidl.tests.permission.platform.IProtected)iin); } return new android.aidl.tests.permission.platform.IProtected.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_ProtectedWithSourceAttribution: { return "ProtectedWithSourceAttribution"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_ProtectedWithSourceAttribution: { android.content.AttributionSource _arg0; _arg0 = data.readTypedObject(android.content.AttributionSource.CREATOR); data.enforceNoDataAvail(); this.ProtectedWithSourceAttribution(_arg0); reply.writeNoException(); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.permission.platform.IProtected { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public void ProtectedWithSourceAttribution(android.content.AttributionSource source) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(source, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_ProtectedWithSourceAttribution, _data, _reply, 0); _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } } static final int TRANSACTION_ProtectedWithSourceAttribution = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); static final String[] PERMISSIONS_ProtectedWithSourceAttribution = {android.Manifest.permission.INTERNET, android.Manifest.permission.VIBRATE}; /** Helper method to enforce permissions for ProtectedWithSourceAttribution */ protected void ProtectedWithSourceAttribution_enforcePermission() throws SecurityException { mEnforcer.enforcePermissionAllOf(PERMISSIONS_ProtectedWithSourceAttribution, getCallingPid(), getCallingUid()); } /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.permission.platform.IProtected"; @android.annotation.EnforcePermission(allOf = {android.Manifest.permission.INTERNET, android.Manifest.permission.VIBRATE}) public void ProtectedWithSourceAttribution(android.content.AttributionSource source) throws android.os.RemoteException; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-permission-java-source_gen_android_aidl_test0100644 0000000 0000000 00000000241 15172120304 033221 xustar000000000 0000000 133 path=tests/golden_output/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/platform/IProtected.java.d 28 mtime=1776853188.4790000 tests/golden_output/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/pla0100644 0000000 0000000 00000000453 15172120304 033216 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/platform/IProtected.java : \ system/tools/aidl/tests/android/aidl/tests/permission/platform/IProtected.aidl \ frameworks/base/core/java/android/content/AttributionSource.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-permission-java-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 031554 xustar000000000 0000000 28 mtime=1776853188.4800000 tests/golden_output/aidl-test-interface-permission-java-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 026546 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-platform-java-source_0100644 0000000 0000000 00000000034 15172120304 026433 xustar000000000 0000000 28 mtime=1776853188.4800000 tests/golden_output/aidl-test-interface-platform-java-source/0040755 0000000 0000000 00000000000 15172120304 023520 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-platform-java-source_gen_0100644 0000000 0000000 00000000034 15172120304 027264 xustar000000000 0000000 28 mtime=1776853188.4800000 tests/golden_output/aidl-test-interface-platform-java-source/gen/0040755 0000000 0000000 00000000000 15172120304 024271 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-platform-java-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 031210 xustar000000000 0000000 28 mtime=1776853188.4800000 tests/golden_output/aidl-test-interface-platform-java-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 026202 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_0100644 0000000 0000000 00000000034 15172120304 024665 xustar000000000 0000000 28 mtime=1776853188.4800000 tests/golden_output/aidl-test-interface-rust-source/0040755 0000000 0000000 00000000000 15172120304 021752 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_0100644 0000000 0000000 00000000034 15172120304 025516 xustar000000000 0000000 28 mtime=1776853188.4800000 tests/golden_output/aidl-test-interface-rust-source/gen/0040755 0000000 0000000 00000000000 15172120304 022523 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 027216 xustar000000000 0000000 28 mtime=1776853188.4800000 tests/golden_output/aidl-test-interface-rust-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 024143 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 030207 xustar000000000 0000000 28 mtime=1776853188.4800000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 025054 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_0100644 0000000 0000000 00000000034 15172120304 031431 xustar000000000 0000000 28 mtime=1776853188.4800000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/0040755 0000000 0000000 00000000000 15172120304 026216 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_ArrayOfIn0100644 0000000 0000000 00000000034 15172120304 033204 xustar000000000 0000000 28 mtime=1776853188.4820000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/ArrayOfInterfaces.rs0100644 0000000 0000000 00000101403 15172120304 032127 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/ArrayOfInterfaces.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ArrayOfInterfaces.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub struct r#ArrayOfInterfaces { } impl Default for r#ArrayOfInterfaces { fn default() -> Self { Self { } } } impl binder::Parcelable for r#ArrayOfInterfaces { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#ArrayOfInterfaces); binder::impl_deserialize_for_parcelable!(r#ArrayOfInterfaces); impl binder::binder_impl::ParcelableMetadata for r#ArrayOfInterfaces { fn get_descriptor() -> &'static str { "android.aidl.tests.ArrayOfInterfaces" } } pub mod r#IEmptyInterface { #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { IEmptyInterface["android.aidl.tests.ArrayOfInterfaces.IEmptyInterface"] { native: BnEmptyInterface(on_transact), proxy: BpEmptyInterface { }, async: IEmptyInterfaceAsync, } } pub trait IEmptyInterface: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ArrayOfInterfaces.IEmptyInterface" } fn getDefaultImpl() -> IEmptyInterfaceDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: IEmptyInterfaceDefaultRef) -> IEmptyInterfaceDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait IEmptyInterfaceAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ArrayOfInterfaces.IEmptyInterface" } } #[::async_trait::async_trait] pub trait IEmptyInterfaceAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ArrayOfInterfaces.IEmptyInterface" } } impl BnEmptyInterface { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: IEmptyInterfaceAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl IEmptyInterface for Wrapper where T: IEmptyInterfaceAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait IEmptyInterfaceDefault: Send + Sync { } pub mod transactions { } pub type IEmptyInterfaceDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); impl BpEmptyInterface { } impl IEmptyInterface for BpEmptyInterface { } impl IEmptyInterfaceAsync

for BpEmptyInterface { } impl IEmptyInterface for binder::binder_impl::Binder { } fn on_transact(_aidl_service: &dyn IEmptyInterface, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } } pub mod r#IMyInterface { #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { IMyInterface["android.aidl.tests.ArrayOfInterfaces.IMyInterface"] { native: BnMyInterface(on_transact), proxy: BpMyInterface { }, async: IMyInterfaceAsync, } } pub trait IMyInterface: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ArrayOfInterfaces.IMyInterface" } fn r#methodWithInterfaces(&self, _arg_iface: &binder::Strong, _arg_nullable_iface: Option<&binder::Strong>, _arg_iface_array_in: &[binder::Strong], _arg_iface_array_out: &mut Vec>>, _arg_iface_array_inout: &mut Vec>, _arg_nullable_iface_array_in: Option<&[Option>]>, _arg_nullable_iface_array_out: &mut Option>>>, _arg_nullable_iface_array_inout: &mut Option>>>) -> binder::Result>>>>; fn getDefaultImpl() -> IMyInterfaceDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: IMyInterfaceDefaultRef) -> IMyInterfaceDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait IMyInterfaceAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ArrayOfInterfaces.IMyInterface" } fn r#methodWithInterfaces<'a>(&'a self, _arg_iface: &'a binder::Strong, _arg_nullable_iface: Option<&'a binder::Strong>, _arg_iface_array_in: &'a [binder::Strong], _arg_iface_array_out: &'a mut Vec>>, _arg_iface_array_inout: &'a mut Vec>, _arg_nullable_iface_array_in: Option<&'a [Option>]>, _arg_nullable_iface_array_out: &'a mut Option>>>, _arg_nullable_iface_array_inout: &'a mut Option>>>) -> binder::BoxFuture<'a, binder::Result>>>>>; } #[::async_trait::async_trait] pub trait IMyInterfaceAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ArrayOfInterfaces.IMyInterface" } async fn r#methodWithInterfaces(&self, _arg_iface: &binder::Strong, _arg_nullable_iface: Option<&binder::Strong>, _arg_iface_array_in: &[binder::Strong], _arg_iface_array_out: &mut Vec>>, _arg_iface_array_inout: &mut Vec>, _arg_nullable_iface_array_in: Option<&[Option>]>, _arg_nullable_iface_array_out: &mut Option>>>, _arg_nullable_iface_array_inout: &mut Option>>>) -> binder::Result>>>>; } impl BnMyInterface { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: IMyInterfaceAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl IMyInterface for Wrapper where T: IMyInterfaceAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#methodWithInterfaces(&self, _arg_iface: &binder::Strong, _arg_nullable_iface: Option<&binder::Strong>, _arg_iface_array_in: &[binder::Strong], _arg_iface_array_out: &mut Vec>>, _arg_iface_array_inout: &mut Vec>, _arg_nullable_iface_array_in: Option<&[Option>]>, _arg_nullable_iface_array_out: &mut Option>>>, _arg_nullable_iface_array_inout: &mut Option>>>) -> binder::Result>>>> { self._rt.block_on(self._inner.r#methodWithInterfaces(_arg_iface, _arg_nullable_iface, _arg_iface_array_in, _arg_iface_array_out, _arg_iface_array_inout, _arg_nullable_iface_array_in, _arg_nullable_iface_array_out, _arg_nullable_iface_array_inout)) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait IMyInterfaceDefault: Send + Sync { fn r#methodWithInterfaces(&self, _arg_iface: &binder::Strong, _arg_nullable_iface: Option<&binder::Strong>, _arg_iface_array_in: &[binder::Strong], _arg_iface_array_out: &mut Vec>>, _arg_iface_array_inout: &mut Vec>, _arg_nullable_iface_array_in: Option<&[Option>]>, _arg_nullable_iface_array_out: &mut Option>>>, _arg_nullable_iface_array_inout: &mut Option>>>) -> binder::Result>>>> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#methodWithInterfaces: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; } pub type IMyInterfaceDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); impl BpMyInterface { fn build_parcel_methodWithInterfaces(&self, _arg_iface: &binder::Strong, _arg_nullable_iface: Option<&binder::Strong>, _arg_iface_array_in: &[binder::Strong], _arg_iface_array_out: &mut Vec>>, _arg_iface_array_inout: &mut Vec>, _arg_nullable_iface_array_in: Option<&[Option>]>, _arg_nullable_iface_array_out: &mut Option>>>, _arg_nullable_iface_array_inout: &mut Option>>>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_iface)?; aidl_data.write(&_arg_nullable_iface)?; aidl_data.write(_arg_iface_array_in)?; aidl_data.write_slice_size(Some(_arg_iface_array_out))?; aidl_data.write(_arg_iface_array_inout)?; aidl_data.write(&_arg_nullable_iface_array_in)?; aidl_data.write_slice_size(_arg_nullable_iface_array_out.as_deref())?; aidl_data.write(_arg_nullable_iface_array_inout)?; Ok(aidl_data) } fn read_response_methodWithInterfaces(&self, _arg_iface: &binder::Strong, _arg_nullable_iface: Option<&binder::Strong>, _arg_iface_array_in: &[binder::Strong], _arg_iface_array_out: &mut Vec>>, _arg_iface_array_inout: &mut Vec>, _arg_nullable_iface_array_in: Option<&[Option>]>, _arg_nullable_iface_array_out: &mut Option>>>, _arg_nullable_iface_array_inout: &mut Option>>>, _aidl_reply: std::result::Result) -> binder::Result>>>> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#methodWithInterfaces(_arg_iface, _arg_nullable_iface, _arg_iface_array_in, _arg_iface_array_out, _arg_iface_array_inout, _arg_nullable_iface_array_in, _arg_nullable_iface_array_out, _arg_nullable_iface_array_inout); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option>>> = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_iface_array_out)?; _aidl_reply.read_onto(_arg_iface_array_inout)?; _aidl_reply.read_onto(_arg_nullable_iface_array_out)?; _aidl_reply.read_onto(_arg_nullable_iface_array_inout)?; Ok(_aidl_return) } } impl IMyInterface for BpMyInterface { fn r#methodWithInterfaces(&self, _arg_iface: &binder::Strong, _arg_nullable_iface: Option<&binder::Strong>, _arg_iface_array_in: &[binder::Strong], _arg_iface_array_out: &mut Vec>>, _arg_iface_array_inout: &mut Vec>, _arg_nullable_iface_array_in: Option<&[Option>]>, _arg_nullable_iface_array_out: &mut Option>>>, _arg_nullable_iface_array_inout: &mut Option>>>) -> binder::Result>>>> { let _aidl_data = self.build_parcel_methodWithInterfaces(_arg_iface, _arg_nullable_iface, _arg_iface_array_in, _arg_iface_array_out, _arg_iface_array_inout, _arg_nullable_iface_array_in, _arg_nullable_iface_array_out, _arg_nullable_iface_array_inout)?; let _aidl_reply = self.binder.submit_transact(transactions::r#methodWithInterfaces, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_methodWithInterfaces(_arg_iface, _arg_nullable_iface, _arg_iface_array_in, _arg_iface_array_out, _arg_iface_array_inout, _arg_nullable_iface_array_in, _arg_nullable_iface_array_out, _arg_nullable_iface_array_inout, _aidl_reply) } } impl IMyInterfaceAsync

for BpMyInterface { fn r#methodWithInterfaces<'a>(&'a self, _arg_iface: &'a binder::Strong, _arg_nullable_iface: Option<&'a binder::Strong>, _arg_iface_array_in: &'a [binder::Strong], _arg_iface_array_out: &'a mut Vec>>, _arg_iface_array_inout: &'a mut Vec>, _arg_nullable_iface_array_in: Option<&'a [Option>]>, _arg_nullable_iface_array_out: &'a mut Option>>>, _arg_nullable_iface_array_inout: &'a mut Option>>>) -> binder::BoxFuture<'a, binder::Result>>>>> { let _aidl_data = match self.build_parcel_methodWithInterfaces(_arg_iface, _arg_nullable_iface, _arg_iface_array_in, _arg_iface_array_out, _arg_iface_array_inout, _arg_nullable_iface_array_in, _arg_nullable_iface_array_out, _arg_nullable_iface_array_inout) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#methodWithInterfaces, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_methodWithInterfaces(_arg_iface, _arg_nullable_iface, _arg_iface_array_in, _arg_iface_array_out, _arg_iface_array_inout, _arg_nullable_iface_array_in, _arg_nullable_iface_array_out, _arg_nullable_iface_array_inout, _aidl_reply) } ) } } impl IMyInterface for binder::binder_impl::Binder { fn r#methodWithInterfaces(&self, _arg_iface: &binder::Strong, _arg_nullable_iface: Option<&binder::Strong>, _arg_iface_array_in: &[binder::Strong], _arg_iface_array_out: &mut Vec>>, _arg_iface_array_inout: &mut Vec>, _arg_nullable_iface_array_in: Option<&[Option>]>, _arg_nullable_iface_array_out: &mut Option>>>, _arg_nullable_iface_array_inout: &mut Option>>>) -> binder::Result>>>> { self.0.r#methodWithInterfaces(_arg_iface, _arg_nullable_iface, _arg_iface_array_in, _arg_iface_array_out, _arg_iface_array_inout, _arg_nullable_iface_array_in, _arg_nullable_iface_array_out, _arg_nullable_iface_array_inout) } } fn on_transact(_aidl_service: &dyn IMyInterface, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#methodWithInterfaces => { let _arg_iface: binder::Strong = _aidl_data.read()?; let _arg_nullable_iface: Option> = _aidl_data.read()?; let _arg_iface_array_in: Vec> = _aidl_data.read()?; let mut _arg_iface_array_out: Vec>> = Default::default(); _aidl_data.resize_out_vec(&mut _arg_iface_array_out)?; let mut _arg_iface_array_inout: Vec> = _aidl_data.read()?; let _arg_nullable_iface_array_in: Option>>> = _aidl_data.read()?; let mut _arg_nullable_iface_array_out: Option>>> = Default::default(); _aidl_data.resize_nullable_out_vec(&mut _arg_nullable_iface_array_out)?; let mut _arg_nullable_iface_array_inout: Option>>> = _aidl_data.read()?; let _aidl_return = _aidl_service.r#methodWithInterfaces(&_arg_iface, _arg_nullable_iface.as_ref(), &_arg_iface_array_in, &mut _arg_iface_array_out, &mut _arg_iface_array_inout, _arg_nullable_iface_array_in.as_deref(), &mut _arg_nullable_iface_array_out, &mut _arg_nullable_iface_array_inout); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_iface_array_out)?; _aidl_reply.write(&_arg_iface_array_inout)?; _aidl_reply.write(&_arg_nullable_iface_array_out)?; _aidl_reply.write(&_arg_nullable_iface_array_inout)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } } pub mod r#MyParcelable { #[derive(Debug)] pub struct r#MyParcelable { pub r#iface: Option>, pub r#nullable_iface: Option>, pub r#iface_array: Vec>, pub r#nullable_iface_array: Option>>>, } impl Default for r#MyParcelable { fn default() -> Self { Self { r#iface: Default::default(), r#nullable_iface: Default::default(), r#iface_array: Default::default(), r#nullable_iface_array: Default::default(), } } } impl binder::Parcelable for r#MyParcelable { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { let __field_ref = self.r#iface.as_ref().ok_or(binder::StatusCode::UNEXPECTED_NULL)?; subparcel.write(__field_ref)?; subparcel.write(&self.r#nullable_iface)?; subparcel.write(&self.r#iface_array)?; subparcel.write(&self.r#nullable_iface_array)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#iface = Some(subparcel.read()?); } if subparcel.has_more_data() { self.r#nullable_iface = subparcel.read()?; } if subparcel.has_more_data() { self.r#iface_array = subparcel.read()?; } if subparcel.has_more_data() { self.r#nullable_iface_array = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#MyParcelable); binder::impl_deserialize_for_parcelable!(r#MyParcelable); impl binder::binder_impl::ParcelableMetadata for r#MyParcelable { fn get_descriptor() -> &'static str { "android.aidl.tests.ArrayOfInterfaces.MyParcelable" } } } pub mod r#MyUnion { #[derive(Debug)] pub enum r#MyUnion { Iface(Option>), Nullable_iface(Option>), Iface_array(Vec>), Nullable_iface_array(Option>>>), } impl Default for r#MyUnion { fn default() -> Self { Self::Iface(Default::default()) } } impl binder::Parcelable for r#MyUnion { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { match self { Self::Iface(v) => { parcel.write(&0i32)?; let __field_ref = v.as_ref().ok_or(binder::StatusCode::UNEXPECTED_NULL)?; parcel.write(__field_ref) } Self::Nullable_iface(v) => { parcel.write(&1i32)?; parcel.write(v) } Self::Iface_array(v) => { parcel.write(&2i32)?; parcel.write(v) } Self::Nullable_iface_array(v) => { parcel.write(&3i32)?; parcel.write(v) } } } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { let tag: i32 = parcel.read()?; match tag { 0 => { let value: Option> = Some(parcel.read()?); *self = Self::Iface(value); Ok(()) } 1 => { let value: Option> = parcel.read()?; *self = Self::Nullable_iface(value); Ok(()) } 2 => { let value: Vec> = parcel.read()?; *self = Self::Iface_array(value); Ok(()) } 3 => { let value: Option>>> = parcel.read()?; *self = Self::Nullable_iface_array(value); Ok(()) } _ => { Err(binder::StatusCode::BAD_VALUE) } } } } binder::impl_serialize_for_parcelable!(r#MyUnion); binder::impl_deserialize_for_parcelable!(r#MyUnion); impl binder::binder_impl::ParcelableMetadata for r#MyUnion { fn get_descriptor() -> &'static str { "android.aidl.tests.ArrayOfInterfaces.MyUnion" } } pub mod r#Tag { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#Tag : [i32; 4] { r#iface = 0, r#nullable_iface = 1, r#iface_array = 2, r#nullable_iface_array = 3, } } } } pub(crate) mod mangled { pub use super::r#ArrayOfInterfaces as _7_android_4_aidl_5_tests_17_ArrayOfInterfaces; pub use super::r#IEmptyInterface::r#IEmptyInterface as _7_android_4_aidl_5_tests_17_ArrayOfInterfaces_15_IEmptyInterface; pub use super::r#IMyInterface::r#IMyInterface as _7_android_4_aidl_5_tests_17_ArrayOfInterfaces_12_IMyInterface; pub use super::r#MyParcelable::r#MyParcelable as _7_android_4_aidl_5_tests_17_ArrayOfInterfaces_12_MyParcelable; pub use super::r#MyUnion::r#MyUnion as _7_android_4_aidl_5_tests_17_ArrayOfInterfaces_7_MyUnion; pub use super::r#MyUnion::r#Tag::r#Tag as _7_android_4_aidl_5_tests_17_ArrayOfInterfaces_7_MyUnion_3_Tag; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_ArrayOfIn0100644 0000000 0000000 00000000034 15172120304 033204 xustar000000000 0000000 28 mtime=1776853188.4830000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/ArrayOfInterfaces.rs.d0100644 0000000 0000000 00000000277 15172120304 032360 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/ArrayOfInterfaces.rs : \ system/tools/aidl/tests/android/aidl/tests/ArrayOfInterfaces.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_BackendTy0100644 0000000 0000000 00000000034 15172120304 033216 xustar000000000 0000000 28 mtime=1776853188.4830000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/BackendType.rs0100644 0000000 0000000 00000001475 15172120304 030761 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/BackendType.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/BackendType.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#BackendType : [i8; 4] { r#CPP = 0, r#JAVA = 1, r#NDK = 2, r#RUST = 3, } } pub(crate) mod mangled { pub use super::r#BackendType as _7_android_4_aidl_5_tests_11_BackendType; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_BackendTy0100644 0000000 0000000 00000000034 15172120304 033216 xustar000000000 0000000 28 mtime=1776853188.4830000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/BackendType.rs.d0100644 0000000 0000000 00000000263 15172120304 031175 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/BackendType.rs : \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_ByteEnum.0100644 0000000 0000000 00000000034 15172120304 033160 xustar000000000 0000000 28 mtime=1776853188.4830000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/ByteEnum.rs0100644 0000000 0000000 00000001434 15172120304 030313 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/ByteEnum.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#ByteEnum : [i8; 3] { r#FOO = 1, r#BAR = 2, r#BAZ = 3, } } pub(crate) mod mangled { pub use super::r#ByteEnum as _7_android_4_aidl_5_tests_8_ByteEnum; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_ByteEnum.0100644 0000000 0000000 00000000034 15172120304 033160 xustar000000000 0000000 28 mtime=1776853188.4830000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/ByteEnum.rs.d0100644 0000000 0000000 00000000255 15172120304 030535 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/ByteEnum.rs : \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_CircularP0100644 0000000 0000000 00000000034 15172120304 033236 xustar000000000 0000000 28 mtime=1776853188.4830000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/CircularParcelable.rs0100644 0000000 0000000 00000003422 15172120304 032301 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/CircularParcelable.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub struct r#CircularParcelable { pub r#testService: Option>, } impl Default for r#CircularParcelable { fn default() -> Self { Self { r#testService: Default::default(), } } } impl binder::Parcelable for r#CircularParcelable { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#testService)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#testService = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#CircularParcelable); binder::impl_deserialize_for_parcelable!(r#CircularParcelable); impl binder::binder_impl::ParcelableMetadata for r#CircularParcelable { fn get_descriptor() -> &'static str { "android.aidl.tests.CircularParcelable" } } pub(crate) mod mangled { pub use super::r#CircularParcelable as _7_android_4_aidl_5_tests_18_CircularParcelable; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_CircularP0100644 0000000 0000000 00000000034 15172120304 033236 xustar000000000 0000000 28 mtime=1776853188.4830000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/CircularParcelable.rs.d0100644 0000000 0000000 00000002233 15172120304 032522 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/CircularParcelable.rs : \ system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ITestService.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl \ system/tools/aidl/tests/android/aidl/tests/SimpleParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl \ system/tools/aidl/tests/android/aidl/tests/ICircular.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_ConstantE0100644 0000000 0000000 00000000212 15172120304 033246 xustar000000000 0000000 110 path=tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/ConstantExpressionEnum.rs 28 mtime=1776853188.4830000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/ConstantExpressionEnum.rs0100644 0000000 0000000 00000002024 15172120304 033255 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/ConstantExpressionEnum.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#ConstantExpressionEnum : [i32; 10] { r#decInt32_1 = 1, r#decInt32_2 = 1, r#decInt64_1 = 1, r#decInt64_2 = 1, r#decInt64_3 = 1, r#decInt64_4 = 1, r#hexInt32_1 = 1, r#hexInt32_2 = 1, r#hexInt32_3 = 1, r#hexInt64_1 = 1, } } pub(crate) mod mangled { pub use super::r#ConstantExpressionEnum as _7_android_4_aidl_5_tests_22_ConstantExpressionEnum; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_ConstantE0100644 0000000 0000000 00000000214 15172120304 033250 xustar000000000 0000000 112 path=tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/ConstantExpressionEnum.rs.d 28 mtime=1776853188.4830000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/ConstantExpressionEnum.rs0100644 0000000 0000000 00000000311 15172120304 033252 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/ConstantExpressionEnum.rs : \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_Deprecate0100644 0000000 0000000 00000000034 15172120304 033246 xustar000000000 0000000 28 mtime=1776853188.4830000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/DeprecatedEnum.rs0100644 0000000 0000000 00000001517 15172120304 031452 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/DeprecatedEnum.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedEnum.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { #[deprecated = "test"] r#DeprecatedEnum : [i32; 3] { r#A = 0, r#B = 1, r#C = 2, } } pub(crate) mod mangled { pub use super::r#DeprecatedEnum as _7_android_4_aidl_5_tests_14_DeprecatedEnum; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_Deprecate0100644 0000000 0000000 00000000034 15172120304 033246 xustar000000000 0000000 28 mtime=1776853188.4830000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/DeprecatedEnum.rs.d0100644 0000000 0000000 00000000271 15172120304 031670 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/DeprecatedEnum.rs : \ system/tools/aidl/tests/android/aidl/tests/DeprecatedEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_Deprecate0100644 0000000 0000000 00000000034 15172120304 033246 xustar000000000 0000000 28 mtime=1776853188.4830000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/DeprecatedParcelable.rs0100644 0000000 0000000 00000003040 15172120304 032571 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/DeprecatedParcelable.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedParcelable.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] #[deprecated = "test"] pub struct r#DeprecatedParcelable { } impl Default for r#DeprecatedParcelable { fn default() -> Self { Self { } } } impl binder::Parcelable for r#DeprecatedParcelable { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#DeprecatedParcelable); binder::impl_deserialize_for_parcelable!(r#DeprecatedParcelable); impl binder::binder_impl::ParcelableMetadata for r#DeprecatedParcelable { fn get_descriptor() -> &'static str { "android.aidl.tests.DeprecatedParcelable" } } pub(crate) mod mangled { pub use super::r#DeprecatedParcelable as _7_android_4_aidl_5_tests_20_DeprecatedParcelable; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_Deprecate0100644 0000000 0000000 00000000212 15172120304 033244 xustar000000000 0000000 110 path=tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/DeprecatedParcelable.rs.d 28 mtime=1776853188.4830000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/DeprecatedParcelable.rs.d0100644 0000000 0000000 00000000305 15172120304 033014 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/DeprecatedParcelable.rs : \ system/tools/aidl/tests/android/aidl/tests/DeprecatedParcelable.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_FixedSize0100644 0000000 0000000 00000000034 15172120304 033244 xustar000000000 0000000 28 mtime=1776853188.4830000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/FixedSize.rs0100644 0000000 0000000 00000017547 15172120304 030471 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/FixedSize.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/FixedSize.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub struct r#FixedSize { } impl Default for r#FixedSize { fn default() -> Self { Self { } } } impl binder::Parcelable for r#FixedSize { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#FixedSize); binder::impl_deserialize_for_parcelable!(r#FixedSize); impl binder::binder_impl::ParcelableMetadata for r#FixedSize { fn get_descriptor() -> &'static str { "android.aidl.tests.FixedSize" } } pub mod r#FixedParcelable { #[derive(Debug)] pub struct r#FixedParcelable { pub r#booleanValue: bool, pub r#byteValue: i8, pub r#charValue: u16, pub r#intValue: i32, pub r#longValue: i64, pub r#floatValue: f32, pub r#doubleValue: f64, pub r#enumValue: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum, pub r#parcelableValue: crate::mangled::_7_android_4_aidl_5_tests_9_FixedSize_10_FixedUnion, } impl Default for r#FixedParcelable { fn default() -> Self { Self { r#booleanValue: false, r#byteValue: 0, r#charValue: '\0' as u16, r#intValue: 0, r#longValue: 0, r#floatValue: 0.000000f32, r#doubleValue: 0.000000f64, r#enumValue: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum::FOO, r#parcelableValue: Default::default(), } } } impl binder::Parcelable for r#FixedParcelable { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#booleanValue)?; subparcel.write(&self.r#byteValue)?; subparcel.write(&self.r#charValue)?; subparcel.write(&self.r#intValue)?; subparcel.write(&self.r#longValue)?; subparcel.write(&self.r#floatValue)?; subparcel.write(&self.r#doubleValue)?; subparcel.write(&self.r#enumValue)?; subparcel.write(&self.r#parcelableValue)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#booleanValue = subparcel.read()?; } if subparcel.has_more_data() { self.r#byteValue = subparcel.read()?; } if subparcel.has_more_data() { self.r#charValue = subparcel.read()?; } if subparcel.has_more_data() { self.r#intValue = subparcel.read()?; } if subparcel.has_more_data() { self.r#longValue = subparcel.read()?; } if subparcel.has_more_data() { self.r#floatValue = subparcel.read()?; } if subparcel.has_more_data() { self.r#doubleValue = subparcel.read()?; } if subparcel.has_more_data() { self.r#enumValue = subparcel.read()?; } if subparcel.has_more_data() { self.r#parcelableValue = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#FixedParcelable); binder::impl_deserialize_for_parcelable!(r#FixedParcelable); impl binder::binder_impl::ParcelableMetadata for r#FixedParcelable { fn get_descriptor() -> &'static str { "android.aidl.tests.FixedSize.FixedParcelable" } } } pub mod r#FixedUnion { #[derive(Debug)] pub enum r#FixedUnion { BooleanValue(bool), ByteValue(i8), CharValue(u16), IntValue(i32), LongValue(i64), FloatValue(f32), DoubleValue(f64), EnumValue(crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum), } impl Default for r#FixedUnion { fn default() -> Self { Self::BooleanValue(false) } } impl binder::Parcelable for r#FixedUnion { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { match self { Self::BooleanValue(v) => { parcel.write(&0i32)?; parcel.write(v) } Self::ByteValue(v) => { parcel.write(&1i32)?; parcel.write(v) } Self::CharValue(v) => { parcel.write(&2i32)?; parcel.write(v) } Self::IntValue(v) => { parcel.write(&3i32)?; parcel.write(v) } Self::LongValue(v) => { parcel.write(&4i32)?; parcel.write(v) } Self::FloatValue(v) => { parcel.write(&5i32)?; parcel.write(v) } Self::DoubleValue(v) => { parcel.write(&6i32)?; parcel.write(v) } Self::EnumValue(v) => { parcel.write(&7i32)?; parcel.write(v) } } } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { let tag: i32 = parcel.read()?; match tag { 0 => { let value: bool = parcel.read()?; *self = Self::BooleanValue(value); Ok(()) } 1 => { let value: i8 = parcel.read()?; *self = Self::ByteValue(value); Ok(()) } 2 => { let value: u16 = parcel.read()?; *self = Self::CharValue(value); Ok(()) } 3 => { let value: i32 = parcel.read()?; *self = Self::IntValue(value); Ok(()) } 4 => { let value: i64 = parcel.read()?; *self = Self::LongValue(value); Ok(()) } 5 => { let value: f32 = parcel.read()?; *self = Self::FloatValue(value); Ok(()) } 6 => { let value: f64 = parcel.read()?; *self = Self::DoubleValue(value); Ok(()) } 7 => { let value: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum = parcel.read()?; *self = Self::EnumValue(value); Ok(()) } _ => { Err(binder::StatusCode::BAD_VALUE) } } } } binder::impl_serialize_for_parcelable!(r#FixedUnion); binder::impl_deserialize_for_parcelable!(r#FixedUnion); impl binder::binder_impl::ParcelableMetadata for r#FixedUnion { fn get_descriptor() -> &'static str { "android.aidl.tests.FixedSize.FixedUnion" } } pub mod r#Tag { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#Tag : [i8; 8] { r#booleanValue = 0, r#byteValue = 1, r#charValue = 2, r#intValue = 3, r#longValue = 4, r#floatValue = 5, r#doubleValue = 6, r#enumValue = 7, } } } } pub(crate) mod mangled { pub use super::r#FixedSize as _7_android_4_aidl_5_tests_9_FixedSize; pub use super::r#FixedParcelable::r#FixedParcelable as _7_android_4_aidl_5_tests_9_FixedSize_15_FixedParcelable; pub use super::r#FixedUnion::r#FixedUnion as _7_android_4_aidl_5_tests_9_FixedSize_10_FixedUnion; pub use super::r#FixedUnion::r#Tag::r#Tag as _7_android_4_aidl_5_tests_9_FixedSize_10_FixedUnion_3_Tag; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_FixedSize0100644 0000000 0000000 00000000034 15172120304 033244 xustar000000000 0000000 28 mtime=1776853188.4840000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/FixedSize.rs.d0100644 0000000 0000000 00000000354 15172120304 030677 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/FixedSize.rs : \ system/tools/aidl/tests/android/aidl/tests/FixedSize.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_GenericSt0100644 0000000 0000000 00000000217 15172120304 033240 xustar000000000 0000000 115 path=tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/GenericStructuredParcelable.rs 28 mtime=1776853188.4840000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/GenericStructuredParcelab0100644 0000000 0000000 00000004366 15172120304 033242 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/GenericStructuredParcelable.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug, Clone, Copy, Eq, PartialEq)] pub struct r#GenericStructuredParcelable { pub r#a: i32, pub r#b: i32, _phantom_B: std::marker::PhantomData, _phantom_T: std::marker::PhantomData, _phantom_U: std::marker::PhantomData, } impl Default for r#GenericStructuredParcelable { fn default() -> Self { Self { r#a: 0, r#b: 0, r#_phantom_B: Default::default(), r#_phantom_T: Default::default(), r#_phantom_U: Default::default(), } } } impl binder::Parcelable for r#GenericStructuredParcelable { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#a)?; subparcel.write(&self.r#b)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#a = subparcel.read()?; } if subparcel.has_more_data() { self.r#b = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#GenericStructuredParcelable); binder::impl_deserialize_for_parcelable!(r#GenericStructuredParcelable); impl binder::binder_impl::ParcelableMetadata for r#GenericStructuredParcelable { fn get_descriptor() -> &'static str { "android.aidl.tests.GenericStructuredParcelable" } } pub(crate) mod mangled { pub use super::r#GenericStructuredParcelable as _7_android_4_aidl_5_tests_27_GenericStructuredParcelable; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_GenericSt0100644 0000000 0000000 00000000221 15172120304 033233 xustar000000000 0000000 117 path=tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/GenericStructuredParcelable.rs.d 28 mtime=1776853188.4840000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/GenericStructuredParcelab0100644 0000000 0000000 00000000323 15172120304 033227 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/GenericStructuredParcelable.rs : \ system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_ICircular0100644 0000000 0000000 00000000034 15172120304 033227 xustar000000000 0000000 28 mtime=1776853188.4840000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/ICircular.rs0100644 0000000 0000000 00000015452 15172120304 030445 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/ICircular.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ICircular.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { ICircular["android.aidl.tests.ICircular"] { native: BnCircular(on_transact), proxy: BpCircular { }, async: ICircularAsync, } } pub trait ICircular: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ICircular" } fn r#GetTestService(&self) -> binder::Result>>; fn getDefaultImpl() -> ICircularDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: ICircularDefaultRef) -> ICircularDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait ICircularAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ICircular" } fn r#GetTestService<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result>>>; } #[::async_trait::async_trait] pub trait ICircularAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ICircular" } async fn r#GetTestService(&self) -> binder::Result>>; } impl BnCircular { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: ICircularAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl ICircular for Wrapper where T: ICircularAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#GetTestService(&self) -> binder::Result>> { self._rt.block_on(self._inner.r#GetTestService()) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait ICircularDefault: Send + Sync { fn r#GetTestService(&self) -> binder::Result>> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#GetTestService: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; } pub type ICircularDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); impl BpCircular { fn build_parcel_GetTestService(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_GetTestService(&self, _aidl_reply: std::result::Result) -> binder::Result>> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#GetTestService(); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option> = _aidl_reply.read()?; Ok(_aidl_return) } } impl ICircular for BpCircular { fn r#GetTestService(&self) -> binder::Result>> { let _aidl_data = self.build_parcel_GetTestService()?; let _aidl_reply = self.binder.submit_transact(transactions::r#GetTestService, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_GetTestService(_aidl_reply) } } impl ICircularAsync

for BpCircular { fn r#GetTestService<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result>>> { let _aidl_data = match self.build_parcel_GetTestService() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#GetTestService, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_GetTestService(_aidl_reply) } ) } } impl ICircular for binder::binder_impl::Binder { fn r#GetTestService(&self) -> binder::Result>> { self.0.r#GetTestService() } } fn on_transact(_aidl_service: &dyn ICircular, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#GetTestService => { let _aidl_return = _aidl_service.r#GetTestService(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } pub(crate) mod mangled { pub use super::r#ICircular as _7_android_4_aidl_5_tests_9_ICircular; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_ICircular0100644 0000000 0000000 00000000034 15172120304 033227 xustar000000000 0000000 28 mtime=1776853188.4850000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/ICircular.rs.d0100644 0000000 0000000 00000002222 15172120304 030656 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/ICircular.rs : \ system/tools/aidl/tests/android/aidl/tests/ICircular.aidl \ system/tools/aidl/tests/android/aidl/tests/ITestService.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl \ system/tools/aidl/tests/android/aidl/tests/SimpleParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl \ system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_IDeprecat0100644 0000000 0000000 00000000034 15172120304 033212 xustar000000000 0000000 28 mtime=1776853188.4850000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/IDeprecated.rs0100644 0000000 0000000 00000007105 15172120304 030735 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/IDeprecated.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IDeprecated.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { IDeprecated["android.aidl.tests.IDeprecated"] { native: BnDeprecated(on_transact), proxy: BpDeprecated { }, async: IDeprecatedAsync, } } #[deprecated = "test"] pub trait IDeprecated: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.IDeprecated" } fn getDefaultImpl() -> IDeprecatedDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: IDeprecatedDefaultRef) -> IDeprecatedDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } #[deprecated = "test"] pub trait IDeprecatedAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.IDeprecated" } } #[deprecated = "test"] #[::async_trait::async_trait] pub trait IDeprecatedAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.IDeprecated" } } impl BnDeprecated { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: IDeprecatedAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl IDeprecated for Wrapper where T: IDeprecatedAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait IDeprecatedDefault: Send + Sync { } pub mod transactions { } pub type IDeprecatedDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); impl BpDeprecated { } impl IDeprecated for BpDeprecated { } impl IDeprecatedAsync

for BpDeprecated { } impl IDeprecated for binder::binder_impl::Binder { } fn on_transact(_aidl_service: &dyn IDeprecated, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } pub(crate) mod mangled { pub use super::r#IDeprecated as _7_android_4_aidl_5_tests_11_IDeprecated; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_IDeprecat0100644 0000000 0000000 00000000034 15172120304 033212 xustar000000000 0000000 28 mtime=1776853188.4850000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/IDeprecated.rs.d0100644 0000000 0000000 00000000263 15172120304 031155 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/IDeprecated.rs : \ system/tools/aidl/tests/android/aidl/tests/IDeprecated.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_INamedCal0100644 0000000 0000000 00000000034 15172120304 033127 xustar000000000 0000000 28 mtime=1776853188.4850000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/INamedCallback.rs0100644 0000000 0000000 00000014057 15172120304 031342 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/INamedCallback.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { INamedCallback["android.aidl.tests.INamedCallback"] { native: BnNamedCallback(on_transact), proxy: BpNamedCallback { }, async: INamedCallbackAsync, } } pub trait INamedCallback: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.INamedCallback" } fn r#GetName(&self) -> binder::Result; fn getDefaultImpl() -> INamedCallbackDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: INamedCallbackDefaultRef) -> INamedCallbackDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait INamedCallbackAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.INamedCallback" } fn r#GetName<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result>; } #[::async_trait::async_trait] pub trait INamedCallbackAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.INamedCallback" } async fn r#GetName(&self) -> binder::Result; } impl BnNamedCallback { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: INamedCallbackAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl INamedCallback for Wrapper where T: INamedCallbackAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#GetName(&self) -> binder::Result { self._rt.block_on(self._inner.r#GetName()) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait INamedCallbackDefault: Send + Sync { fn r#GetName(&self) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#GetName: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; } pub type INamedCallbackDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); impl BpNamedCallback { fn build_parcel_GetName(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_GetName(&self, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#GetName(); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: String = _aidl_reply.read()?; Ok(_aidl_return) } } impl INamedCallback for BpNamedCallback { fn r#GetName(&self) -> binder::Result { let _aidl_data = self.build_parcel_GetName()?; let _aidl_reply = self.binder.submit_transact(transactions::r#GetName, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_GetName(_aidl_reply) } } impl INamedCallbackAsync

for BpNamedCallback { fn r#GetName<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_GetName() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#GetName, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_GetName(_aidl_reply) } ) } } impl INamedCallback for binder::binder_impl::Binder { fn r#GetName(&self) -> binder::Result { self.0.r#GetName() } } fn on_transact(_aidl_service: &dyn INamedCallback, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#GetName => { let _aidl_return = _aidl_service.r#GetName(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } pub(crate) mod mangled { pub use super::r#INamedCallback as _7_android_4_aidl_5_tests_14_INamedCallback; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_INamedCal0100644 0000000 0000000 00000000034 15172120304 033127 xustar000000000 0000000 28 mtime=1776853188.4850000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/INamedCallback.rs.d0100644 0000000 0000000 00000000271 15172120304 031555 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/INamedCallback.rs : \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_INewName.0100644 0000000 0000000 00000000034 15172120304 033073 xustar000000000 0000000 28 mtime=1776853188.4850000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/INewName.rs0100644 0000000 0000000 00000013554 15172120304 030234 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/INewName.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INewName.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { INewName["android.aidl.tests.IOldName"] { native: BnNewName(on_transact), proxy: BpNewName { }, async: INewNameAsync, } } pub trait INewName: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.IOldName" } fn r#RealName(&self) -> binder::Result; fn getDefaultImpl() -> INewNameDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: INewNameDefaultRef) -> INewNameDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait INewNameAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.IOldName" } fn r#RealName<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result>; } #[::async_trait::async_trait] pub trait INewNameAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.IOldName" } async fn r#RealName(&self) -> binder::Result; } impl BnNewName { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: INewNameAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl INewName for Wrapper where T: INewNameAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#RealName(&self) -> binder::Result { self._rt.block_on(self._inner.r#RealName()) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait INewNameDefault: Send + Sync { fn r#RealName(&self) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#RealName: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; } pub type INewNameDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); impl BpNewName { fn build_parcel_RealName(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_RealName(&self, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RealName(); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: String = _aidl_reply.read()?; Ok(_aidl_return) } } impl INewName for BpNewName { fn r#RealName(&self) -> binder::Result { let _aidl_data = self.build_parcel_RealName()?; let _aidl_reply = self.binder.submit_transact(transactions::r#RealName, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RealName(_aidl_reply) } } impl INewNameAsync

for BpNewName { fn r#RealName<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_RealName() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RealName, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RealName(_aidl_reply) } ) } } impl INewName for binder::binder_impl::Binder { fn r#RealName(&self) -> binder::Result { self.0.r#RealName() } } fn on_transact(_aidl_service: &dyn INewName, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#RealName => { let _aidl_return = _aidl_service.r#RealName(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } pub(crate) mod mangled { pub use super::r#INewName as _7_android_4_aidl_5_tests_8_INewName; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_INewName.0100644 0000000 0000000 00000000034 15172120304 033073 xustar000000000 0000000 28 mtime=1776853188.4850000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/INewName.rs.d0100644 0000000 0000000 00000000255 15172120304 030450 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/INewName.rs : \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_IOldName.0100644 0000000 0000000 00000000034 15172120304 033060 xustar000000000 0000000 28 mtime=1776853188.4850000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/IOldName.rs0100644 0000000 0000000 00000013554 15172120304 030221 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/IOldName.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IOldName.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { IOldName["android.aidl.tests.IOldName"] { native: BnOldName(on_transact), proxy: BpOldName { }, async: IOldNameAsync, } } pub trait IOldName: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.IOldName" } fn r#RealName(&self) -> binder::Result; fn getDefaultImpl() -> IOldNameDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: IOldNameDefaultRef) -> IOldNameDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait IOldNameAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.IOldName" } fn r#RealName<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result>; } #[::async_trait::async_trait] pub trait IOldNameAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.IOldName" } async fn r#RealName(&self) -> binder::Result; } impl BnOldName { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: IOldNameAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl IOldName for Wrapper where T: IOldNameAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#RealName(&self) -> binder::Result { self._rt.block_on(self._inner.r#RealName()) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait IOldNameDefault: Send + Sync { fn r#RealName(&self) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#RealName: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; } pub type IOldNameDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); impl BpOldName { fn build_parcel_RealName(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_RealName(&self, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RealName(); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: String = _aidl_reply.read()?; Ok(_aidl_return) } } impl IOldName for BpOldName { fn r#RealName(&self) -> binder::Result { let _aidl_data = self.build_parcel_RealName()?; let _aidl_reply = self.binder.submit_transact(transactions::r#RealName, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RealName(_aidl_reply) } } impl IOldNameAsync

for BpOldName { fn r#RealName<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_RealName() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RealName, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RealName(_aidl_reply) } ) } } impl IOldName for binder::binder_impl::Binder { fn r#RealName(&self) -> binder::Result { self.0.r#RealName() } } fn on_transact(_aidl_service: &dyn IOldName, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#RealName => { let _aidl_return = _aidl_service.r#RealName(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } pub(crate) mod mangled { pub use super::r#IOldName as _7_android_4_aidl_5_tests_8_IOldName; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_IOldName.0100644 0000000 0000000 00000000034 15172120304 033060 xustar000000000 0000000 28 mtime=1776853188.4850000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/IOldName.rs.d0100644 0000000 0000000 00000000255 15172120304 030435 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/IOldName.rs : \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_ITestServ0100644 0000000 0000000 00000000034 15172120304 033242 xustar000000000 0000000 28 mtime=1776853188.4860000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/ITestService.rs0100644 0000000 0000000 00001147065 15172120304 031150 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/ITestService.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ITestService.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { ITestService["android.aidl.tests.ITestService"] { native: BnTestService(on_transact), proxy: BpTestService { }, async: ITestServiceAsync, } } pub trait ITestService: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ITestService" } fn r#UnimplementedMethod(&self, _arg_arg: i32) -> binder::Result; #[deprecated = "to make sure we have something in system/tools/aidl which does a compile check of deprecated and make sure this is reflected in goldens"] fn r#Deprecated(&self) -> binder::Result<()>; fn r#TestOneway(&self) -> binder::Result<()>; fn r#RepeatBoolean(&self, _arg_token: bool) -> binder::Result; fn r#RepeatByte(&self, _arg_token: i8) -> binder::Result; fn r#RepeatChar(&self, _arg_token: u16) -> binder::Result; fn r#RepeatInt(&self, _arg_token: i32) -> binder::Result; fn r#RepeatLong(&self, _arg_token: i64) -> binder::Result; fn r#RepeatFloat(&self, _arg_token: f32) -> binder::Result; fn r#RepeatDouble(&self, _arg_token: f64) -> binder::Result; fn r#RepeatString(&self, _arg_token: &str) -> binder::Result; fn r#RepeatByteEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum) -> binder::Result; fn r#RepeatIntEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum) -> binder::Result; fn r#RepeatLongEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum) -> binder::Result; fn r#ReverseBoolean(&self, _arg_input: &[bool], _arg_repeated: &mut Vec) -> binder::Result>; fn r#ReverseByte(&self, _arg_input: &[u8], _arg_repeated: &mut Vec) -> binder::Result>; fn r#ReverseChar(&self, _arg_input: &[u16], _arg_repeated: &mut Vec) -> binder::Result>; fn r#ReverseInt(&self, _arg_input: &[i32], _arg_repeated: &mut Vec) -> binder::Result>; fn r#ReverseLong(&self, _arg_input: &[i64], _arg_repeated: &mut Vec) -> binder::Result>; fn r#ReverseFloat(&self, _arg_input: &[f32], _arg_repeated: &mut Vec) -> binder::Result>; fn r#ReverseDouble(&self, _arg_input: &[f64], _arg_repeated: &mut Vec) -> binder::Result>; fn r#ReverseString(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result>; fn r#ReverseByteEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum], _arg_repeated: &mut Vec) -> binder::Result>; fn r#ReverseIntEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum], _arg_repeated: &mut Vec) -> binder::Result>; fn r#ReverseLongEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum], _arg_repeated: &mut Vec) -> binder::Result>; fn r#GetOtherTestService(&self, _arg_name: &str) -> binder::Result>; fn r#SetOtherTestService(&self, _arg_name: &str, _arg_service: &binder::Strong) -> binder::Result; fn r#VerifyName(&self, _arg_service: &binder::Strong, _arg_name: &str) -> binder::Result; fn r#GetInterfaceArray(&self, _arg_names: &[String]) -> binder::Result>>; fn r#VerifyNamesWithInterfaceArray(&self, _arg_services: &[binder::Strong], _arg_names: &[String]) -> binder::Result; fn r#GetNullableInterfaceArray(&self, _arg_names: Option<&[Option]>) -> binder::Result>>>>; fn r#VerifyNamesWithNullableInterfaceArray(&self, _arg_services: Option<&[Option>]>, _arg_names: Option<&[Option]>) -> binder::Result; fn r#GetInterfaceList(&self, _arg_names: Option<&[Option]>) -> binder::Result>>>>; fn r#VerifyNamesWithInterfaceList(&self, _arg_services: Option<&[Option>]>, _arg_names: Option<&[Option]>) -> binder::Result; fn r#ReverseStringList(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result>; fn r#RepeatParcelFileDescriptor(&self, _arg_read: &binder::ParcelFileDescriptor) -> binder::Result; fn r#ReverseParcelFileDescriptorArray(&self, _arg_input: &[binder::ParcelFileDescriptor], _arg_repeated: &mut Vec>) -> binder::Result>; fn r#ThrowServiceException(&self, _arg_code: i32) -> binder::Result<()>; fn r#RepeatNullableIntArray(&self, _arg_input: Option<&[i32]>) -> binder::Result>>; fn r#RepeatNullableByteEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum]>) -> binder::Result>>; fn r#RepeatNullableIntEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum]>) -> binder::Result>>; fn r#RepeatNullableLongEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum]>) -> binder::Result>>; fn r#RepeatNullableString(&self, _arg_input: Option<&str>) -> binder::Result>; fn r#RepeatNullableStringList(&self, _arg_input: Option<&[Option]>) -> binder::Result>>>; fn r#RepeatNullableParcelable(&self, _arg_input: Option<&crate::mangled::_7_android_4_aidl_5_tests_12_ITestService_5_Empty>) -> binder::Result>; fn r#RepeatNullableParcelableArray(&self, _arg_input: Option<&[Option]>) -> binder::Result>>>; fn r#RepeatNullableParcelableList(&self, _arg_input: Option<&[Option]>) -> binder::Result>>>; fn r#TakesAnIBinder(&self, _arg_input: &binder::SpIBinder) -> binder::Result<()>; fn r#TakesANullableIBinder(&self, _arg_input: Option<&binder::SpIBinder>) -> binder::Result<()>; fn r#TakesAnIBinderList(&self, _arg_input: &[binder::SpIBinder]) -> binder::Result<()>; fn r#TakesANullableIBinderList(&self, _arg_input: Option<&[Option]>) -> binder::Result<()>; fn r#RepeatUtf8CppString(&self, _arg_token: &str) -> binder::Result; fn r#RepeatNullableUtf8CppString(&self, _arg_token: Option<&str>) -> binder::Result>; fn r#ReverseUtf8CppString(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result>; fn r#ReverseNullableUtf8CppString(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>>; fn r#ReverseUtf8CppStringList(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>>; fn r#GetCallback(&self, _arg_return_null: bool) -> binder::Result>>; fn r#FillOutStructuredParcelable(&self, _arg_parcel: &mut crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable) -> binder::Result<()>; fn r#RepeatExtendableParcelable(&self, _arg_ep: &crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable, _arg_ep2: &mut crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable) -> binder::Result<()>; fn r#ReverseList(&self, _arg_list: &crate::mangled::_7_android_4_aidl_5_tests_13_RecursiveList) -> binder::Result; fn r#ReverseIBinderArray(&self, _arg_input: &[binder::SpIBinder], _arg_repeated: &mut Vec>) -> binder::Result>; fn r#ReverseNullableIBinderArray(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>>; fn r#RepeatSimpleParcelable(&self, _arg_input: &simple_parcelable::SimpleParcelable, _arg_repeat: &mut simple_parcelable::SimpleParcelable) -> binder::Result; fn r#ReverseSimpleParcelables(&self, _arg_input: &[simple_parcelable::SimpleParcelable], _arg_repeated: &mut Vec) -> binder::Result>; fn r#GetOldNameInterface(&self) -> binder::Result>; fn r#GetNewNameInterface(&self) -> binder::Result>; fn r#GetUnionTags(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_5_Union]) -> binder::Result>; fn r#GetCppJavaTests(&self) -> binder::Result>; fn r#getBackendType(&self) -> binder::Result; fn r#GetCircular(&self, _arg_cp: &mut crate::mangled::_7_android_4_aidl_5_tests_18_CircularParcelable) -> binder::Result>; fn getDefaultImpl() -> ITestServiceDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: ITestServiceDefaultRef) -> ITestServiceDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait ITestServiceAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ITestService" } fn r#UnimplementedMethod<'a>(&'a self, _arg_arg: i32) -> binder::BoxFuture<'a, binder::Result>; #[deprecated = "to make sure we have something in system/tools/aidl which does a compile check of deprecated and make sure this is reflected in goldens"] fn r#Deprecated<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result<()>>; fn r#TestOneway(&self) -> std::future::Ready>; fn r#RepeatBoolean<'a>(&'a self, _arg_token: bool) -> binder::BoxFuture<'a, binder::Result>; fn r#RepeatByte<'a>(&'a self, _arg_token: i8) -> binder::BoxFuture<'a, binder::Result>; fn r#RepeatChar<'a>(&'a self, _arg_token: u16) -> binder::BoxFuture<'a, binder::Result>; fn r#RepeatInt<'a>(&'a self, _arg_token: i32) -> binder::BoxFuture<'a, binder::Result>; fn r#RepeatLong<'a>(&'a self, _arg_token: i64) -> binder::BoxFuture<'a, binder::Result>; fn r#RepeatFloat<'a>(&'a self, _arg_token: f32) -> binder::BoxFuture<'a, binder::Result>; fn r#RepeatDouble<'a>(&'a self, _arg_token: f64) -> binder::BoxFuture<'a, binder::Result>; fn r#RepeatString<'a>(&'a self, _arg_token: &'a str) -> binder::BoxFuture<'a, binder::Result>; fn r#RepeatByteEnum<'a>(&'a self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum) -> binder::BoxFuture<'a, binder::Result>; fn r#RepeatIntEnum<'a>(&'a self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum) -> binder::BoxFuture<'a, binder::Result>; fn r#RepeatLongEnum<'a>(&'a self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum) -> binder::BoxFuture<'a, binder::Result>; fn r#ReverseBoolean<'a>(&'a self, _arg_input: &'a [bool], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>>; fn r#ReverseByte<'a>(&'a self, _arg_input: &'a [u8], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>>; fn r#ReverseChar<'a>(&'a self, _arg_input: &'a [u16], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>>; fn r#ReverseInt<'a>(&'a self, _arg_input: &'a [i32], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>>; fn r#ReverseLong<'a>(&'a self, _arg_input: &'a [i64], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>>; fn r#ReverseFloat<'a>(&'a self, _arg_input: &'a [f32], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>>; fn r#ReverseDouble<'a>(&'a self, _arg_input: &'a [f64], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>>; fn r#ReverseString<'a>(&'a self, _arg_input: &'a [String], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>>; fn r#ReverseByteEnum<'a>(&'a self, _arg_input: &'a [crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>>; fn r#ReverseIntEnum<'a>(&'a self, _arg_input: &'a [crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>>; fn r#ReverseLongEnum<'a>(&'a self, _arg_input: &'a [crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>>; fn r#GetOtherTestService<'a>(&'a self, _arg_name: &'a str) -> binder::BoxFuture<'a, binder::Result>>; fn r#SetOtherTestService<'a>(&'a self, _arg_name: &'a str, _arg_service: &'a binder::Strong) -> binder::BoxFuture<'a, binder::Result>; fn r#VerifyName<'a>(&'a self, _arg_service: &'a binder::Strong, _arg_name: &'a str) -> binder::BoxFuture<'a, binder::Result>; fn r#GetInterfaceArray<'a>(&'a self, _arg_names: &'a [String]) -> binder::BoxFuture<'a, binder::Result>>>; fn r#VerifyNamesWithInterfaceArray<'a>(&'a self, _arg_services: &'a [binder::Strong], _arg_names: &'a [String]) -> binder::BoxFuture<'a, binder::Result>; fn r#GetNullableInterfaceArray<'a>(&'a self, _arg_names: Option<&'a [Option]>) -> binder::BoxFuture<'a, binder::Result>>>>>; fn r#VerifyNamesWithNullableInterfaceArray<'a>(&'a self, _arg_services: Option<&'a [Option>]>, _arg_names: Option<&'a [Option]>) -> binder::BoxFuture<'a, binder::Result>; fn r#GetInterfaceList<'a>(&'a self, _arg_names: Option<&'a [Option]>) -> binder::BoxFuture<'a, binder::Result>>>>>; fn r#VerifyNamesWithInterfaceList<'a>(&'a self, _arg_services: Option<&'a [Option>]>, _arg_names: Option<&'a [Option]>) -> binder::BoxFuture<'a, binder::Result>; fn r#ReverseStringList<'a>(&'a self, _arg_input: &'a [String], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>>; fn r#RepeatParcelFileDescriptor<'a>(&'a self, _arg_read: &'a binder::ParcelFileDescriptor) -> binder::BoxFuture<'a, binder::Result>; fn r#ReverseParcelFileDescriptorArray<'a>(&'a self, _arg_input: &'a [binder::ParcelFileDescriptor], _arg_repeated: &'a mut Vec>) -> binder::BoxFuture<'a, binder::Result>>; fn r#ThrowServiceException<'a>(&'a self, _arg_code: i32) -> binder::BoxFuture<'a, binder::Result<()>>; fn r#RepeatNullableIntArray<'a>(&'a self, _arg_input: Option<&'a [i32]>) -> binder::BoxFuture<'a, binder::Result>>>; fn r#RepeatNullableByteEnumArray<'a>(&'a self, _arg_input: Option<&'a [crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum]>) -> binder::BoxFuture<'a, binder::Result>>>; fn r#RepeatNullableIntEnumArray<'a>(&'a self, _arg_input: Option<&'a [crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum]>) -> binder::BoxFuture<'a, binder::Result>>>; fn r#RepeatNullableLongEnumArray<'a>(&'a self, _arg_input: Option<&'a [crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum]>) -> binder::BoxFuture<'a, binder::Result>>>; fn r#RepeatNullableString<'a>(&'a self, _arg_input: Option<&'a str>) -> binder::BoxFuture<'a, binder::Result>>; fn r#RepeatNullableStringList<'a>(&'a self, _arg_input: Option<&'a [Option]>) -> binder::BoxFuture<'a, binder::Result>>>>; fn r#RepeatNullableParcelable<'a>(&'a self, _arg_input: Option<&'a crate::mangled::_7_android_4_aidl_5_tests_12_ITestService_5_Empty>) -> binder::BoxFuture<'a, binder::Result>>; fn r#RepeatNullableParcelableArray<'a>(&'a self, _arg_input: Option<&'a [Option]>) -> binder::BoxFuture<'a, binder::Result>>>>; fn r#RepeatNullableParcelableList<'a>(&'a self, _arg_input: Option<&'a [Option]>) -> binder::BoxFuture<'a, binder::Result>>>>; fn r#TakesAnIBinder<'a>(&'a self, _arg_input: &'a binder::SpIBinder) -> binder::BoxFuture<'a, binder::Result<()>>; fn r#TakesANullableIBinder<'a>(&'a self, _arg_input: Option<&'a binder::SpIBinder>) -> binder::BoxFuture<'a, binder::Result<()>>; fn r#TakesAnIBinderList<'a>(&'a self, _arg_input: &'a [binder::SpIBinder]) -> binder::BoxFuture<'a, binder::Result<()>>; fn r#TakesANullableIBinderList<'a>(&'a self, _arg_input: Option<&'a [Option]>) -> binder::BoxFuture<'a, binder::Result<()>>; fn r#RepeatUtf8CppString<'a>(&'a self, _arg_token: &'a str) -> binder::BoxFuture<'a, binder::Result>; fn r#RepeatNullableUtf8CppString<'a>(&'a self, _arg_token: Option<&'a str>) -> binder::BoxFuture<'a, binder::Result>>; fn r#ReverseUtf8CppString<'a>(&'a self, _arg_input: &'a [String], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>>; fn r#ReverseNullableUtf8CppString<'a>(&'a self, _arg_input: Option<&'a [Option]>, _arg_repeated: &'a mut Option>>) -> binder::BoxFuture<'a, binder::Result>>>>; fn r#ReverseUtf8CppStringList<'a>(&'a self, _arg_input: Option<&'a [Option]>, _arg_repeated: &'a mut Option>>) -> binder::BoxFuture<'a, binder::Result>>>>; fn r#GetCallback<'a>(&'a self, _arg_return_null: bool) -> binder::BoxFuture<'a, binder::Result>>>; fn r#FillOutStructuredParcelable<'a>(&'a self, _arg_parcel: &'a mut crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable) -> binder::BoxFuture<'a, binder::Result<()>>; fn r#RepeatExtendableParcelable<'a>(&'a self, _arg_ep: &'a crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable, _arg_ep2: &'a mut crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable) -> binder::BoxFuture<'a, binder::Result<()>>; fn r#ReverseList<'a>(&'a self, _arg_list: &'a crate::mangled::_7_android_4_aidl_5_tests_13_RecursiveList) -> binder::BoxFuture<'a, binder::Result>; fn r#ReverseIBinderArray<'a>(&'a self, _arg_input: &'a [binder::SpIBinder], _arg_repeated: &'a mut Vec>) -> binder::BoxFuture<'a, binder::Result>>; fn r#ReverseNullableIBinderArray<'a>(&'a self, _arg_input: Option<&'a [Option]>, _arg_repeated: &'a mut Option>>) -> binder::BoxFuture<'a, binder::Result>>>>; fn r#RepeatSimpleParcelable<'a>(&'a self, _arg_input: &'a simple_parcelable::SimpleParcelable, _arg_repeat: &'a mut simple_parcelable::SimpleParcelable) -> binder::BoxFuture<'a, binder::Result>; fn r#ReverseSimpleParcelables<'a>(&'a self, _arg_input: &'a [simple_parcelable::SimpleParcelable], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>>; fn r#GetOldNameInterface<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result>>; fn r#GetNewNameInterface<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result>>; fn r#GetUnionTags<'a>(&'a self, _arg_input: &'a [crate::mangled::_7_android_4_aidl_5_tests_5_Union]) -> binder::BoxFuture<'a, binder::Result>>; fn r#GetCppJavaTests<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result>>; fn r#getBackendType<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result>; fn r#GetCircular<'a>(&'a self, _arg_cp: &'a mut crate::mangled::_7_android_4_aidl_5_tests_18_CircularParcelable) -> binder::BoxFuture<'a, binder::Result>>; } #[::async_trait::async_trait] pub trait ITestServiceAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ITestService" } async fn r#UnimplementedMethod(&self, _arg_arg: i32) -> binder::Result; #[deprecated = "to make sure we have something in system/tools/aidl which does a compile check of deprecated and make sure this is reflected in goldens"] async fn r#Deprecated(&self) -> binder::Result<()>; async fn r#TestOneway(&self) -> binder::Result<()>; async fn r#RepeatBoolean(&self, _arg_token: bool) -> binder::Result; async fn r#RepeatByte(&self, _arg_token: i8) -> binder::Result; async fn r#RepeatChar(&self, _arg_token: u16) -> binder::Result; async fn r#RepeatInt(&self, _arg_token: i32) -> binder::Result; async fn r#RepeatLong(&self, _arg_token: i64) -> binder::Result; async fn r#RepeatFloat(&self, _arg_token: f32) -> binder::Result; async fn r#RepeatDouble(&self, _arg_token: f64) -> binder::Result; async fn r#RepeatString(&self, _arg_token: &str) -> binder::Result; async fn r#RepeatByteEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum) -> binder::Result; async fn r#RepeatIntEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum) -> binder::Result; async fn r#RepeatLongEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum) -> binder::Result; async fn r#ReverseBoolean(&self, _arg_input: &[bool], _arg_repeated: &mut Vec) -> binder::Result>; async fn r#ReverseByte(&self, _arg_input: &[u8], _arg_repeated: &mut Vec) -> binder::Result>; async fn r#ReverseChar(&self, _arg_input: &[u16], _arg_repeated: &mut Vec) -> binder::Result>; async fn r#ReverseInt(&self, _arg_input: &[i32], _arg_repeated: &mut Vec) -> binder::Result>; async fn r#ReverseLong(&self, _arg_input: &[i64], _arg_repeated: &mut Vec) -> binder::Result>; async fn r#ReverseFloat(&self, _arg_input: &[f32], _arg_repeated: &mut Vec) -> binder::Result>; async fn r#ReverseDouble(&self, _arg_input: &[f64], _arg_repeated: &mut Vec) -> binder::Result>; async fn r#ReverseString(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result>; async fn r#ReverseByteEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum], _arg_repeated: &mut Vec) -> binder::Result>; async fn r#ReverseIntEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum], _arg_repeated: &mut Vec) -> binder::Result>; async fn r#ReverseLongEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum], _arg_repeated: &mut Vec) -> binder::Result>; async fn r#GetOtherTestService(&self, _arg_name: &str) -> binder::Result>; async fn r#SetOtherTestService(&self, _arg_name: &str, _arg_service: &binder::Strong) -> binder::Result; async fn r#VerifyName(&self, _arg_service: &binder::Strong, _arg_name: &str) -> binder::Result; async fn r#GetInterfaceArray(&self, _arg_names: &[String]) -> binder::Result>>; async fn r#VerifyNamesWithInterfaceArray(&self, _arg_services: &[binder::Strong], _arg_names: &[String]) -> binder::Result; async fn r#GetNullableInterfaceArray(&self, _arg_names: Option<&[Option]>) -> binder::Result>>>>; async fn r#VerifyNamesWithNullableInterfaceArray(&self, _arg_services: Option<&[Option>]>, _arg_names: Option<&[Option]>) -> binder::Result; async fn r#GetInterfaceList(&self, _arg_names: Option<&[Option]>) -> binder::Result>>>>; async fn r#VerifyNamesWithInterfaceList(&self, _arg_services: Option<&[Option>]>, _arg_names: Option<&[Option]>) -> binder::Result; async fn r#ReverseStringList(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result>; async fn r#RepeatParcelFileDescriptor(&self, _arg_read: &binder::ParcelFileDescriptor) -> binder::Result; async fn r#ReverseParcelFileDescriptorArray(&self, _arg_input: &[binder::ParcelFileDescriptor], _arg_repeated: &mut Vec>) -> binder::Result>; async fn r#ThrowServiceException(&self, _arg_code: i32) -> binder::Result<()>; async fn r#RepeatNullableIntArray(&self, _arg_input: Option<&[i32]>) -> binder::Result>>; async fn r#RepeatNullableByteEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum]>) -> binder::Result>>; async fn r#RepeatNullableIntEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum]>) -> binder::Result>>; async fn r#RepeatNullableLongEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum]>) -> binder::Result>>; async fn r#RepeatNullableString(&self, _arg_input: Option<&str>) -> binder::Result>; async fn r#RepeatNullableStringList(&self, _arg_input: Option<&[Option]>) -> binder::Result>>>; async fn r#RepeatNullableParcelable(&self, _arg_input: Option<&crate::mangled::_7_android_4_aidl_5_tests_12_ITestService_5_Empty>) -> binder::Result>; async fn r#RepeatNullableParcelableArray(&self, _arg_input: Option<&[Option]>) -> binder::Result>>>; async fn r#RepeatNullableParcelableList(&self, _arg_input: Option<&[Option]>) -> binder::Result>>>; async fn r#TakesAnIBinder(&self, _arg_input: &binder::SpIBinder) -> binder::Result<()>; async fn r#TakesANullableIBinder(&self, _arg_input: Option<&binder::SpIBinder>) -> binder::Result<()>; async fn r#TakesAnIBinderList(&self, _arg_input: &[binder::SpIBinder]) -> binder::Result<()>; async fn r#TakesANullableIBinderList(&self, _arg_input: Option<&[Option]>) -> binder::Result<()>; async fn r#RepeatUtf8CppString(&self, _arg_token: &str) -> binder::Result; async fn r#RepeatNullableUtf8CppString(&self, _arg_token: Option<&str>) -> binder::Result>; async fn r#ReverseUtf8CppString(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result>; async fn r#ReverseNullableUtf8CppString(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>>; async fn r#ReverseUtf8CppStringList(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>>; async fn r#GetCallback(&self, _arg_return_null: bool) -> binder::Result>>; async fn r#FillOutStructuredParcelable(&self, _arg_parcel: &mut crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable) -> binder::Result<()>; async fn r#RepeatExtendableParcelable(&self, _arg_ep: &crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable, _arg_ep2: &mut crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable) -> binder::Result<()>; async fn r#ReverseList(&self, _arg_list: &crate::mangled::_7_android_4_aidl_5_tests_13_RecursiveList) -> binder::Result; async fn r#ReverseIBinderArray(&self, _arg_input: &[binder::SpIBinder], _arg_repeated: &mut Vec>) -> binder::Result>; async fn r#ReverseNullableIBinderArray(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>>; async fn r#RepeatSimpleParcelable(&self, _arg_input: &simple_parcelable::SimpleParcelable, _arg_repeat: &mut simple_parcelable::SimpleParcelable) -> binder::Result; async fn r#ReverseSimpleParcelables(&self, _arg_input: &[simple_parcelable::SimpleParcelable], _arg_repeated: &mut Vec) -> binder::Result>; async fn r#GetOldNameInterface(&self) -> binder::Result>; async fn r#GetNewNameInterface(&self) -> binder::Result>; async fn r#GetUnionTags(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_5_Union]) -> binder::Result>; async fn r#GetCppJavaTests(&self) -> binder::Result>; async fn r#getBackendType(&self) -> binder::Result; async fn r#GetCircular(&self, _arg_cp: &mut crate::mangled::_7_android_4_aidl_5_tests_18_CircularParcelable) -> binder::Result>; } impl BnTestService { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: ITestServiceAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl ITestService for Wrapper where T: ITestServiceAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#UnimplementedMethod(&self, _arg_arg: i32) -> binder::Result { self._rt.block_on(self._inner.r#UnimplementedMethod(_arg_arg)) } fn r#Deprecated(&self) -> binder::Result<()> { self._rt.block_on(self._inner.r#Deprecated()) } fn r#TestOneway(&self) -> binder::Result<()> { self._rt.block_on(self._inner.r#TestOneway()) } fn r#RepeatBoolean(&self, _arg_token: bool) -> binder::Result { self._rt.block_on(self._inner.r#RepeatBoolean(_arg_token)) } fn r#RepeatByte(&self, _arg_token: i8) -> binder::Result { self._rt.block_on(self._inner.r#RepeatByte(_arg_token)) } fn r#RepeatChar(&self, _arg_token: u16) -> binder::Result { self._rt.block_on(self._inner.r#RepeatChar(_arg_token)) } fn r#RepeatInt(&self, _arg_token: i32) -> binder::Result { self._rt.block_on(self._inner.r#RepeatInt(_arg_token)) } fn r#RepeatLong(&self, _arg_token: i64) -> binder::Result { self._rt.block_on(self._inner.r#RepeatLong(_arg_token)) } fn r#RepeatFloat(&self, _arg_token: f32) -> binder::Result { self._rt.block_on(self._inner.r#RepeatFloat(_arg_token)) } fn r#RepeatDouble(&self, _arg_token: f64) -> binder::Result { self._rt.block_on(self._inner.r#RepeatDouble(_arg_token)) } fn r#RepeatString(&self, _arg_token: &str) -> binder::Result { self._rt.block_on(self._inner.r#RepeatString(_arg_token)) } fn r#RepeatByteEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum) -> binder::Result { self._rt.block_on(self._inner.r#RepeatByteEnum(_arg_token)) } fn r#RepeatIntEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum) -> binder::Result { self._rt.block_on(self._inner.r#RepeatIntEnum(_arg_token)) } fn r#RepeatLongEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum) -> binder::Result { self._rt.block_on(self._inner.r#RepeatLongEnum(_arg_token)) } fn r#ReverseBoolean(&self, _arg_input: &[bool], _arg_repeated: &mut Vec) -> binder::Result> { self._rt.block_on(self._inner.r#ReverseBoolean(_arg_input, _arg_repeated)) } fn r#ReverseByte(&self, _arg_input: &[u8], _arg_repeated: &mut Vec) -> binder::Result> { self._rt.block_on(self._inner.r#ReverseByte(_arg_input, _arg_repeated)) } fn r#ReverseChar(&self, _arg_input: &[u16], _arg_repeated: &mut Vec) -> binder::Result> { self._rt.block_on(self._inner.r#ReverseChar(_arg_input, _arg_repeated)) } fn r#ReverseInt(&self, _arg_input: &[i32], _arg_repeated: &mut Vec) -> binder::Result> { self._rt.block_on(self._inner.r#ReverseInt(_arg_input, _arg_repeated)) } fn r#ReverseLong(&self, _arg_input: &[i64], _arg_repeated: &mut Vec) -> binder::Result> { self._rt.block_on(self._inner.r#ReverseLong(_arg_input, _arg_repeated)) } fn r#ReverseFloat(&self, _arg_input: &[f32], _arg_repeated: &mut Vec) -> binder::Result> { self._rt.block_on(self._inner.r#ReverseFloat(_arg_input, _arg_repeated)) } fn r#ReverseDouble(&self, _arg_input: &[f64], _arg_repeated: &mut Vec) -> binder::Result> { self._rt.block_on(self._inner.r#ReverseDouble(_arg_input, _arg_repeated)) } fn r#ReverseString(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result> { self._rt.block_on(self._inner.r#ReverseString(_arg_input, _arg_repeated)) } fn r#ReverseByteEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum], _arg_repeated: &mut Vec) -> binder::Result> { self._rt.block_on(self._inner.r#ReverseByteEnum(_arg_input, _arg_repeated)) } fn r#ReverseIntEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum], _arg_repeated: &mut Vec) -> binder::Result> { self._rt.block_on(self._inner.r#ReverseIntEnum(_arg_input, _arg_repeated)) } fn r#ReverseLongEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum], _arg_repeated: &mut Vec) -> binder::Result> { self._rt.block_on(self._inner.r#ReverseLongEnum(_arg_input, _arg_repeated)) } fn r#GetOtherTestService(&self, _arg_name: &str) -> binder::Result> { self._rt.block_on(self._inner.r#GetOtherTestService(_arg_name)) } fn r#SetOtherTestService(&self, _arg_name: &str, _arg_service: &binder::Strong) -> binder::Result { self._rt.block_on(self._inner.r#SetOtherTestService(_arg_name, _arg_service)) } fn r#VerifyName(&self, _arg_service: &binder::Strong, _arg_name: &str) -> binder::Result { self._rt.block_on(self._inner.r#VerifyName(_arg_service, _arg_name)) } fn r#GetInterfaceArray(&self, _arg_names: &[String]) -> binder::Result>> { self._rt.block_on(self._inner.r#GetInterfaceArray(_arg_names)) } fn r#VerifyNamesWithInterfaceArray(&self, _arg_services: &[binder::Strong], _arg_names: &[String]) -> binder::Result { self._rt.block_on(self._inner.r#VerifyNamesWithInterfaceArray(_arg_services, _arg_names)) } fn r#GetNullableInterfaceArray(&self, _arg_names: Option<&[Option]>) -> binder::Result>>>> { self._rt.block_on(self._inner.r#GetNullableInterfaceArray(_arg_names)) } fn r#VerifyNamesWithNullableInterfaceArray(&self, _arg_services: Option<&[Option>]>, _arg_names: Option<&[Option]>) -> binder::Result { self._rt.block_on(self._inner.r#VerifyNamesWithNullableInterfaceArray(_arg_services, _arg_names)) } fn r#GetInterfaceList(&self, _arg_names: Option<&[Option]>) -> binder::Result>>>> { self._rt.block_on(self._inner.r#GetInterfaceList(_arg_names)) } fn r#VerifyNamesWithInterfaceList(&self, _arg_services: Option<&[Option>]>, _arg_names: Option<&[Option]>) -> binder::Result { self._rt.block_on(self._inner.r#VerifyNamesWithInterfaceList(_arg_services, _arg_names)) } fn r#ReverseStringList(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result> { self._rt.block_on(self._inner.r#ReverseStringList(_arg_input, _arg_repeated)) } fn r#RepeatParcelFileDescriptor(&self, _arg_read: &binder::ParcelFileDescriptor) -> binder::Result { self._rt.block_on(self._inner.r#RepeatParcelFileDescriptor(_arg_read)) } fn r#ReverseParcelFileDescriptorArray(&self, _arg_input: &[binder::ParcelFileDescriptor], _arg_repeated: &mut Vec>) -> binder::Result> { self._rt.block_on(self._inner.r#ReverseParcelFileDescriptorArray(_arg_input, _arg_repeated)) } fn r#ThrowServiceException(&self, _arg_code: i32) -> binder::Result<()> { self._rt.block_on(self._inner.r#ThrowServiceException(_arg_code)) } fn r#RepeatNullableIntArray(&self, _arg_input: Option<&[i32]>) -> binder::Result>> { self._rt.block_on(self._inner.r#RepeatNullableIntArray(_arg_input)) } fn r#RepeatNullableByteEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum]>) -> binder::Result>> { self._rt.block_on(self._inner.r#RepeatNullableByteEnumArray(_arg_input)) } fn r#RepeatNullableIntEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum]>) -> binder::Result>> { self._rt.block_on(self._inner.r#RepeatNullableIntEnumArray(_arg_input)) } fn r#RepeatNullableLongEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum]>) -> binder::Result>> { self._rt.block_on(self._inner.r#RepeatNullableLongEnumArray(_arg_input)) } fn r#RepeatNullableString(&self, _arg_input: Option<&str>) -> binder::Result> { self._rt.block_on(self._inner.r#RepeatNullableString(_arg_input)) } fn r#RepeatNullableStringList(&self, _arg_input: Option<&[Option]>) -> binder::Result>>> { self._rt.block_on(self._inner.r#RepeatNullableStringList(_arg_input)) } fn r#RepeatNullableParcelable(&self, _arg_input: Option<&crate::mangled::_7_android_4_aidl_5_tests_12_ITestService_5_Empty>) -> binder::Result> { self._rt.block_on(self._inner.r#RepeatNullableParcelable(_arg_input)) } fn r#RepeatNullableParcelableArray(&self, _arg_input: Option<&[Option]>) -> binder::Result>>> { self._rt.block_on(self._inner.r#RepeatNullableParcelableArray(_arg_input)) } fn r#RepeatNullableParcelableList(&self, _arg_input: Option<&[Option]>) -> binder::Result>>> { self._rt.block_on(self._inner.r#RepeatNullableParcelableList(_arg_input)) } fn r#TakesAnIBinder(&self, _arg_input: &binder::SpIBinder) -> binder::Result<()> { self._rt.block_on(self._inner.r#TakesAnIBinder(_arg_input)) } fn r#TakesANullableIBinder(&self, _arg_input: Option<&binder::SpIBinder>) -> binder::Result<()> { self._rt.block_on(self._inner.r#TakesANullableIBinder(_arg_input)) } fn r#TakesAnIBinderList(&self, _arg_input: &[binder::SpIBinder]) -> binder::Result<()> { self._rt.block_on(self._inner.r#TakesAnIBinderList(_arg_input)) } fn r#TakesANullableIBinderList(&self, _arg_input: Option<&[Option]>) -> binder::Result<()> { self._rt.block_on(self._inner.r#TakesANullableIBinderList(_arg_input)) } fn r#RepeatUtf8CppString(&self, _arg_token: &str) -> binder::Result { self._rt.block_on(self._inner.r#RepeatUtf8CppString(_arg_token)) } fn r#RepeatNullableUtf8CppString(&self, _arg_token: Option<&str>) -> binder::Result> { self._rt.block_on(self._inner.r#RepeatNullableUtf8CppString(_arg_token)) } fn r#ReverseUtf8CppString(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result> { self._rt.block_on(self._inner.r#ReverseUtf8CppString(_arg_input, _arg_repeated)) } fn r#ReverseNullableUtf8CppString(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>> { self._rt.block_on(self._inner.r#ReverseNullableUtf8CppString(_arg_input, _arg_repeated)) } fn r#ReverseUtf8CppStringList(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>> { self._rt.block_on(self._inner.r#ReverseUtf8CppStringList(_arg_input, _arg_repeated)) } fn r#GetCallback(&self, _arg_return_null: bool) -> binder::Result>> { self._rt.block_on(self._inner.r#GetCallback(_arg_return_null)) } fn r#FillOutStructuredParcelable(&self, _arg_parcel: &mut crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable) -> binder::Result<()> { self._rt.block_on(self._inner.r#FillOutStructuredParcelable(_arg_parcel)) } fn r#RepeatExtendableParcelable(&self, _arg_ep: &crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable, _arg_ep2: &mut crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable) -> binder::Result<()> { self._rt.block_on(self._inner.r#RepeatExtendableParcelable(_arg_ep, _arg_ep2)) } fn r#ReverseList(&self, _arg_list: &crate::mangled::_7_android_4_aidl_5_tests_13_RecursiveList) -> binder::Result { self._rt.block_on(self._inner.r#ReverseList(_arg_list)) } fn r#ReverseIBinderArray(&self, _arg_input: &[binder::SpIBinder], _arg_repeated: &mut Vec>) -> binder::Result> { self._rt.block_on(self._inner.r#ReverseIBinderArray(_arg_input, _arg_repeated)) } fn r#ReverseNullableIBinderArray(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>> { self._rt.block_on(self._inner.r#ReverseNullableIBinderArray(_arg_input, _arg_repeated)) } fn r#RepeatSimpleParcelable(&self, _arg_input: &simple_parcelable::SimpleParcelable, _arg_repeat: &mut simple_parcelable::SimpleParcelable) -> binder::Result { self._rt.block_on(self._inner.r#RepeatSimpleParcelable(_arg_input, _arg_repeat)) } fn r#ReverseSimpleParcelables(&self, _arg_input: &[simple_parcelable::SimpleParcelable], _arg_repeated: &mut Vec) -> binder::Result> { self._rt.block_on(self._inner.r#ReverseSimpleParcelables(_arg_input, _arg_repeated)) } fn r#GetOldNameInterface(&self) -> binder::Result> { self._rt.block_on(self._inner.r#GetOldNameInterface()) } fn r#GetNewNameInterface(&self) -> binder::Result> { self._rt.block_on(self._inner.r#GetNewNameInterface()) } fn r#GetUnionTags(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_5_Union]) -> binder::Result> { self._rt.block_on(self._inner.r#GetUnionTags(_arg_input)) } fn r#GetCppJavaTests(&self) -> binder::Result> { self._rt.block_on(self._inner.r#GetCppJavaTests()) } fn r#getBackendType(&self) -> binder::Result { self._rt.block_on(self._inner.r#getBackendType()) } fn r#GetCircular(&self, _arg_cp: &mut crate::mangled::_7_android_4_aidl_5_tests_18_CircularParcelable) -> binder::Result> { self._rt.block_on(self._inner.r#GetCircular(_arg_cp)) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait ITestServiceDefault: Send + Sync { fn r#UnimplementedMethod(&self, _arg_arg: i32) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#Deprecated(&self) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#TestOneway(&self) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatBoolean(&self, _arg_token: bool) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatByte(&self, _arg_token: i8) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatChar(&self, _arg_token: u16) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatInt(&self, _arg_token: i32) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatLong(&self, _arg_token: i64) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatFloat(&self, _arg_token: f32) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatDouble(&self, _arg_token: f64) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatString(&self, _arg_token: &str) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatByteEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatIntEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatLongEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseBoolean(&self, _arg_input: &[bool], _arg_repeated: &mut Vec) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseByte(&self, _arg_input: &[u8], _arg_repeated: &mut Vec) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseChar(&self, _arg_input: &[u16], _arg_repeated: &mut Vec) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseInt(&self, _arg_input: &[i32], _arg_repeated: &mut Vec) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseLong(&self, _arg_input: &[i64], _arg_repeated: &mut Vec) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseFloat(&self, _arg_input: &[f32], _arg_repeated: &mut Vec) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseDouble(&self, _arg_input: &[f64], _arg_repeated: &mut Vec) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseString(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseByteEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum], _arg_repeated: &mut Vec) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseIntEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum], _arg_repeated: &mut Vec) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseLongEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum], _arg_repeated: &mut Vec) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#GetOtherTestService(&self, _arg_name: &str) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#SetOtherTestService(&self, _arg_name: &str, _arg_service: &binder::Strong) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#VerifyName(&self, _arg_service: &binder::Strong, _arg_name: &str) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#GetInterfaceArray(&self, _arg_names: &[String]) -> binder::Result>> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#VerifyNamesWithInterfaceArray(&self, _arg_services: &[binder::Strong], _arg_names: &[String]) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#GetNullableInterfaceArray(&self, _arg_names: Option<&[Option]>) -> binder::Result>>>> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#VerifyNamesWithNullableInterfaceArray(&self, _arg_services: Option<&[Option>]>, _arg_names: Option<&[Option]>) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#GetInterfaceList(&self, _arg_names: Option<&[Option]>) -> binder::Result>>>> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#VerifyNamesWithInterfaceList(&self, _arg_services: Option<&[Option>]>, _arg_names: Option<&[Option]>) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseStringList(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatParcelFileDescriptor(&self, _arg_read: &binder::ParcelFileDescriptor) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseParcelFileDescriptorArray(&self, _arg_input: &[binder::ParcelFileDescriptor], _arg_repeated: &mut Vec>) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ThrowServiceException(&self, _arg_code: i32) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatNullableIntArray(&self, _arg_input: Option<&[i32]>) -> binder::Result>> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatNullableByteEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum]>) -> binder::Result>> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatNullableIntEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum]>) -> binder::Result>> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatNullableLongEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum]>) -> binder::Result>> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatNullableString(&self, _arg_input: Option<&str>) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatNullableStringList(&self, _arg_input: Option<&[Option]>) -> binder::Result>>> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatNullableParcelable(&self, _arg_input: Option<&crate::mangled::_7_android_4_aidl_5_tests_12_ITestService_5_Empty>) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatNullableParcelableArray(&self, _arg_input: Option<&[Option]>) -> binder::Result>>> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatNullableParcelableList(&self, _arg_input: Option<&[Option]>) -> binder::Result>>> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#TakesAnIBinder(&self, _arg_input: &binder::SpIBinder) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#TakesANullableIBinder(&self, _arg_input: Option<&binder::SpIBinder>) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#TakesAnIBinderList(&self, _arg_input: &[binder::SpIBinder]) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#TakesANullableIBinderList(&self, _arg_input: Option<&[Option]>) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatUtf8CppString(&self, _arg_token: &str) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatNullableUtf8CppString(&self, _arg_token: Option<&str>) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseUtf8CppString(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseNullableUtf8CppString(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseUtf8CppStringList(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#GetCallback(&self, _arg_return_null: bool) -> binder::Result>> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#FillOutStructuredParcelable(&self, _arg_parcel: &mut crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatExtendableParcelable(&self, _arg_ep: &crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable, _arg_ep2: &mut crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseList(&self, _arg_list: &crate::mangled::_7_android_4_aidl_5_tests_13_RecursiveList) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseIBinderArray(&self, _arg_input: &[binder::SpIBinder], _arg_repeated: &mut Vec>) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseNullableIBinderArray(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatSimpleParcelable(&self, _arg_input: &simple_parcelable::SimpleParcelable, _arg_repeat: &mut simple_parcelable::SimpleParcelable) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseSimpleParcelables(&self, _arg_input: &[simple_parcelable::SimpleParcelable], _arg_repeated: &mut Vec) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#GetOldNameInterface(&self) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#GetNewNameInterface(&self) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#GetUnionTags(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_5_Union]) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#GetCppJavaTests(&self) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#getBackendType(&self) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#GetCircular(&self, _arg_cp: &mut crate::mangled::_7_android_4_aidl_5_tests_18_CircularParcelable) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#UnimplementedMethod: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; pub const r#Deprecated: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 1; pub const r#TestOneway: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 2; pub const r#RepeatBoolean: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 3; pub const r#RepeatByte: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 4; pub const r#RepeatChar: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 5; pub const r#RepeatInt: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 6; pub const r#RepeatLong: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 7; pub const r#RepeatFloat: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 8; pub const r#RepeatDouble: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 9; pub const r#RepeatString: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 10; pub const r#RepeatByteEnum: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 11; pub const r#RepeatIntEnum: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 12; pub const r#RepeatLongEnum: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 13; pub const r#ReverseBoolean: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 14; pub const r#ReverseByte: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 15; pub const r#ReverseChar: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 16; pub const r#ReverseInt: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 17; pub const r#ReverseLong: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 18; pub const r#ReverseFloat: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 19; pub const r#ReverseDouble: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 20; pub const r#ReverseString: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 21; pub const r#ReverseByteEnum: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 22; pub const r#ReverseIntEnum: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 23; pub const r#ReverseLongEnum: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 24; pub const r#GetOtherTestService: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 25; pub const r#SetOtherTestService: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 26; pub const r#VerifyName: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 27; pub const r#GetInterfaceArray: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 28; pub const r#VerifyNamesWithInterfaceArray: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 29; pub const r#GetNullableInterfaceArray: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 30; pub const r#VerifyNamesWithNullableInterfaceArray: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 31; pub const r#GetInterfaceList: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 32; pub const r#VerifyNamesWithInterfaceList: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 33; pub const r#ReverseStringList: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 34; pub const r#RepeatParcelFileDescriptor: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 35; pub const r#ReverseParcelFileDescriptorArray: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 36; pub const r#ThrowServiceException: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 37; pub const r#RepeatNullableIntArray: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 38; pub const r#RepeatNullableByteEnumArray: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 39; pub const r#RepeatNullableIntEnumArray: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 40; pub const r#RepeatNullableLongEnumArray: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 41; pub const r#RepeatNullableString: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 42; pub const r#RepeatNullableStringList: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 43; pub const r#RepeatNullableParcelable: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 44; pub const r#RepeatNullableParcelableArray: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 45; pub const r#RepeatNullableParcelableList: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 46; pub const r#TakesAnIBinder: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 47; pub const r#TakesANullableIBinder: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 48; pub const r#TakesAnIBinderList: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 49; pub const r#TakesANullableIBinderList: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 50; pub const r#RepeatUtf8CppString: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 51; pub const r#RepeatNullableUtf8CppString: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 52; pub const r#ReverseUtf8CppString: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 53; pub const r#ReverseNullableUtf8CppString: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 54; pub const r#ReverseUtf8CppStringList: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 55; pub const r#GetCallback: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 56; pub const r#FillOutStructuredParcelable: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 57; pub const r#RepeatExtendableParcelable: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 58; pub const r#ReverseList: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 59; pub const r#ReverseIBinderArray: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 60; pub const r#ReverseNullableIBinderArray: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 61; pub const r#RepeatSimpleParcelable: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 62; pub const r#ReverseSimpleParcelables: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 63; pub const r#GetOldNameInterface: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 64; pub const r#GetNewNameInterface: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 65; pub const r#GetUnionTags: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 66; pub const r#GetCppJavaTests: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 67; pub const r#getBackendType: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 68; pub const r#GetCircular: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 69; } pub type ITestServiceDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); pub const r#CONSTANT: i32 = 42; pub const r#CONSTANT2: i32 = -42; pub const r#CONSTANT3: i32 = 42; pub const r#CONSTANT4: i32 = 4; pub const r#CONSTANT5: i32 = -4; pub const r#CONSTANT6: i32 = 0; pub const r#CONSTANT7: i32 = 0; pub const r#CONSTANT8: i32 = 0; pub const r#CONSTANT9: i32 = 86; pub const r#CONSTANT10: i32 = 165; pub const r#CONSTANT11: i32 = 250; pub const r#CONSTANT12: i32 = -1; pub const r#BYTE_CONSTANT: i8 = 17; pub const r#LONG_CONSTANT: i64 = 1099511627776; pub const r#STRING_CONSTANT: &str = "foo"; pub const r#STRING_CONSTANT2: &str = "bar"; pub const r#FLOAT_CONSTANT: f32 = 1.000000f32; pub const r#FLOAT_CONSTANT2: f32 = -1.000000f32; pub const r#FLOAT_CONSTANT3: f32 = 1.000000f32; pub const r#FLOAT_CONSTANT4: f32 = 2.200000f32; pub const r#FLOAT_CONSTANT5: f32 = -2.200000f32; pub const r#FLOAT_CONSTANT6: f32 = -0.000000f32; pub const r#FLOAT_CONSTANT7: f32 = 0.000000f32; pub const r#DOUBLE_CONSTANT: f64 = 1.000000f64; pub const r#DOUBLE_CONSTANT2: f64 = -1.000000f64; pub const r#DOUBLE_CONSTANT3: f64 = 1.000000f64; pub const r#DOUBLE_CONSTANT4: f64 = 2.200000f64; pub const r#DOUBLE_CONSTANT5: f64 = -2.200000f64; pub const r#DOUBLE_CONSTANT6: f64 = -0.000000f64; pub const r#DOUBLE_CONSTANT7: f64 = 0.000000f64; pub const r#DOUBLE_CONSTANT8: f64 = 1.100000f64; pub const r#DOUBLE_CONSTANT9: f64 = -1.100000f64; pub const r#STRING_CONSTANT_UTF8: &str = "baz"; pub const r#A1: i32 = 1; pub const r#A2: i32 = 1; pub const r#A3: i32 = 1; pub const r#A4: i32 = 1; pub const r#A5: i32 = 1; pub const r#A6: i32 = 1; pub const r#A7: i32 = 1; pub const r#A8: i32 = 1; pub const r#A9: i32 = 1; pub const r#A10: i32 = 1; pub const r#A11: i32 = 1; pub const r#A12: i32 = 1; pub const r#A13: i32 = 1; pub const r#A14: i32 = 1; pub const r#A15: i32 = 1; pub const r#A16: i32 = 1; pub const r#A17: i32 = 1; pub const r#A18: i32 = 1; pub const r#A19: i32 = 1; pub const r#A20: i32 = 1; pub const r#A21: i32 = 1; pub const r#A22: i32 = 1; pub const r#A23: i32 = 1; pub const r#A24: i32 = 1; pub const r#A25: i32 = 1; pub const r#A26: i32 = 1; pub const r#A27: i32 = 1; pub const r#A28: i32 = 1; pub const r#A29: i32 = 1; pub const r#A30: i32 = 1; pub const r#A31: i32 = 1; pub const r#A32: i32 = 1; pub const r#A33: i32 = 1; pub const r#A34: i32 = 1; pub const r#A35: i32 = 1; pub const r#A36: i32 = 1; pub const r#A37: i32 = 1; pub const r#A38: i32 = 1; pub const r#A39: i32 = 1; pub const r#A40: i32 = 1; pub const r#A41: i32 = 1; pub const r#A42: i32 = 1; pub const r#A43: i32 = 1; pub const r#A44: i32 = 1; pub const r#A45: i32 = 1; pub const r#A46: i32 = 1; pub const r#A47: i32 = 1; pub const r#A48: i32 = 1; pub const r#A49: i32 = 1; pub const r#A50: i32 = 1; pub const r#A51: i32 = 1; pub const r#A52: i32 = 1; pub const r#A53: i32 = 1; pub const r#A54: i32 = 1; pub const r#A55: i32 = 1; pub const r#A56: i32 = 1; pub const r#A57: i32 = 1; impl BpTestService { fn build_parcel_UnimplementedMethod(&self, _arg_arg: i32) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_arg)?; Ok(aidl_data) } fn read_response_UnimplementedMethod(&self, _arg_arg: i32, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#UnimplementedMethod(_arg_arg); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: i32 = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_Deprecated(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); Ok(aidl_data) } fn read_response_Deprecated(&self, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#Deprecated(); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } Ok(()) } fn build_parcel_TestOneway(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); Ok(aidl_data) } fn read_response_TestOneway(&self, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#TestOneway(); } } let _aidl_reply = _aidl_reply?; Ok(()) } fn build_parcel_RepeatBoolean(&self, _arg_token: bool) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_token)?; Ok(aidl_data) } fn read_response_RepeatBoolean(&self, _arg_token: bool, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatBoolean(_arg_token); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: bool = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatByte(&self, _arg_token: i8) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_token)?; Ok(aidl_data) } fn read_response_RepeatByte(&self, _arg_token: i8, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatByte(_arg_token); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: i8 = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatChar(&self, _arg_token: u16) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_token)?; Ok(aidl_data) } fn read_response_RepeatChar(&self, _arg_token: u16, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatChar(_arg_token); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: u16 = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatInt(&self, _arg_token: i32) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_token)?; Ok(aidl_data) } fn read_response_RepeatInt(&self, _arg_token: i32, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatInt(_arg_token); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: i32 = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatLong(&self, _arg_token: i64) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_token)?; Ok(aidl_data) } fn read_response_RepeatLong(&self, _arg_token: i64, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatLong(_arg_token); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: i64 = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatFloat(&self, _arg_token: f32) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_token)?; Ok(aidl_data) } fn read_response_RepeatFloat(&self, _arg_token: f32, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatFloat(_arg_token); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: f32 = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatDouble(&self, _arg_token: f64) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_token)?; Ok(aidl_data) } fn read_response_RepeatDouble(&self, _arg_token: f64, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatDouble(_arg_token); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: f64 = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatString(&self, _arg_token: &str) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_token)?; Ok(aidl_data) } fn read_response_RepeatString(&self, _arg_token: &str, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatString(_arg_token); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: String = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatByteEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_token)?; Ok(aidl_data) } fn read_response_RepeatByteEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatByteEnum(_arg_token); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatIntEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_token)?; Ok(aidl_data) } fn read_response_RepeatIntEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatIntEnum(_arg_token); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatLongEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_token)?; Ok(aidl_data) } fn read_response_RepeatLongEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatLongEnum(_arg_token); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_ReverseBoolean(&self, _arg_input: &[bool], _arg_repeated: &mut Vec) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; aidl_data.write_slice_size(Some(_arg_repeated))?; Ok(aidl_data) } fn read_response_ReverseBoolean(&self, _arg_input: &[bool], _arg_repeated: &mut Vec, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseBoolean(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_ReverseByte(&self, _arg_input: &[u8], _arg_repeated: &mut Vec) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; aidl_data.write_slice_size(Some(_arg_repeated))?; Ok(aidl_data) } fn read_response_ReverseByte(&self, _arg_input: &[u8], _arg_repeated: &mut Vec, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseByte(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_ReverseChar(&self, _arg_input: &[u16], _arg_repeated: &mut Vec) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; aidl_data.write_slice_size(Some(_arg_repeated))?; Ok(aidl_data) } fn read_response_ReverseChar(&self, _arg_input: &[u16], _arg_repeated: &mut Vec, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseChar(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_ReverseInt(&self, _arg_input: &[i32], _arg_repeated: &mut Vec) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; aidl_data.write_slice_size(Some(_arg_repeated))?; Ok(aidl_data) } fn read_response_ReverseInt(&self, _arg_input: &[i32], _arg_repeated: &mut Vec, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseInt(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_ReverseLong(&self, _arg_input: &[i64], _arg_repeated: &mut Vec) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; aidl_data.write_slice_size(Some(_arg_repeated))?; Ok(aidl_data) } fn read_response_ReverseLong(&self, _arg_input: &[i64], _arg_repeated: &mut Vec, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseLong(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_ReverseFloat(&self, _arg_input: &[f32], _arg_repeated: &mut Vec) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; aidl_data.write_slice_size(Some(_arg_repeated))?; Ok(aidl_data) } fn read_response_ReverseFloat(&self, _arg_input: &[f32], _arg_repeated: &mut Vec, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseFloat(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_ReverseDouble(&self, _arg_input: &[f64], _arg_repeated: &mut Vec) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; aidl_data.write_slice_size(Some(_arg_repeated))?; Ok(aidl_data) } fn read_response_ReverseDouble(&self, _arg_input: &[f64], _arg_repeated: &mut Vec, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseDouble(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_ReverseString(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; aidl_data.write_slice_size(Some(_arg_repeated))?; Ok(aidl_data) } fn read_response_ReverseString(&self, _arg_input: &[String], _arg_repeated: &mut Vec, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseString(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_ReverseByteEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum], _arg_repeated: &mut Vec) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; aidl_data.write_slice_size(Some(_arg_repeated))?; Ok(aidl_data) } fn read_response_ReverseByteEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum], _arg_repeated: &mut Vec, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseByteEnum(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_ReverseIntEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum], _arg_repeated: &mut Vec) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; aidl_data.write_slice_size(Some(_arg_repeated))?; Ok(aidl_data) } fn read_response_ReverseIntEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum], _arg_repeated: &mut Vec, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseIntEnum(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_ReverseLongEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum], _arg_repeated: &mut Vec) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; aidl_data.write_slice_size(Some(_arg_repeated))?; Ok(aidl_data) } fn read_response_ReverseLongEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum], _arg_repeated: &mut Vec, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseLongEnum(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_GetOtherTestService(&self, _arg_name: &str) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_name)?; Ok(aidl_data) } fn read_response_GetOtherTestService(&self, _arg_name: &str, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#GetOtherTestService(_arg_name); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: binder::Strong = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_SetOtherTestService(&self, _arg_name: &str, _arg_service: &binder::Strong) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_name)?; aidl_data.write(_arg_service)?; Ok(aidl_data) } fn read_response_SetOtherTestService(&self, _arg_name: &str, _arg_service: &binder::Strong, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#SetOtherTestService(_arg_name, _arg_service); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: bool = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_VerifyName(&self, _arg_service: &binder::Strong, _arg_name: &str) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_service)?; aidl_data.write(_arg_name)?; Ok(aidl_data) } fn read_response_VerifyName(&self, _arg_service: &binder::Strong, _arg_name: &str, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#VerifyName(_arg_service, _arg_name); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: bool = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_GetInterfaceArray(&self, _arg_names: &[String]) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_names)?; Ok(aidl_data) } fn read_response_GetInterfaceArray(&self, _arg_names: &[String], _aidl_reply: std::result::Result) -> binder::Result>> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#GetInterfaceArray(_arg_names); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec> = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_VerifyNamesWithInterfaceArray(&self, _arg_services: &[binder::Strong], _arg_names: &[String]) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_services)?; aidl_data.write(_arg_names)?; Ok(aidl_data) } fn read_response_VerifyNamesWithInterfaceArray(&self, _arg_services: &[binder::Strong], _arg_names: &[String], _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#VerifyNamesWithInterfaceArray(_arg_services, _arg_names); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: bool = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_GetNullableInterfaceArray(&self, _arg_names: Option<&[Option]>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_names)?; Ok(aidl_data) } fn read_response_GetNullableInterfaceArray(&self, _arg_names: Option<&[Option]>, _aidl_reply: std::result::Result) -> binder::Result>>>> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#GetNullableInterfaceArray(_arg_names); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option>>> = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_VerifyNamesWithNullableInterfaceArray(&self, _arg_services: Option<&[Option>]>, _arg_names: Option<&[Option]>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_services)?; aidl_data.write(&_arg_names)?; Ok(aidl_data) } fn read_response_VerifyNamesWithNullableInterfaceArray(&self, _arg_services: Option<&[Option>]>, _arg_names: Option<&[Option]>, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#VerifyNamesWithNullableInterfaceArray(_arg_services, _arg_names); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: bool = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_GetInterfaceList(&self, _arg_names: Option<&[Option]>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_names)?; Ok(aidl_data) } fn read_response_GetInterfaceList(&self, _arg_names: Option<&[Option]>, _aidl_reply: std::result::Result) -> binder::Result>>>> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#GetInterfaceList(_arg_names); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option>>> = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_VerifyNamesWithInterfaceList(&self, _arg_services: Option<&[Option>]>, _arg_names: Option<&[Option]>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_services)?; aidl_data.write(&_arg_names)?; Ok(aidl_data) } fn read_response_VerifyNamesWithInterfaceList(&self, _arg_services: Option<&[Option>]>, _arg_names: Option<&[Option]>, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#VerifyNamesWithInterfaceList(_arg_services, _arg_names); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: bool = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_ReverseStringList(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_ReverseStringList(&self, _arg_input: &[String], _arg_repeated: &mut Vec, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseStringList(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_RepeatParcelFileDescriptor(&self, _arg_read: &binder::ParcelFileDescriptor) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_read)?; Ok(aidl_data) } fn read_response_RepeatParcelFileDescriptor(&self, _arg_read: &binder::ParcelFileDescriptor, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatParcelFileDescriptor(_arg_read); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: binder::ParcelFileDescriptor = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_ReverseParcelFileDescriptorArray(&self, _arg_input: &[binder::ParcelFileDescriptor], _arg_repeated: &mut Vec>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; aidl_data.write_slice_size(Some(_arg_repeated))?; Ok(aidl_data) } fn read_response_ReverseParcelFileDescriptorArray(&self, _arg_input: &[binder::ParcelFileDescriptor], _arg_repeated: &mut Vec>, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseParcelFileDescriptorArray(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_ThrowServiceException(&self, _arg_code: i32) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_code)?; Ok(aidl_data) } fn read_response_ThrowServiceException(&self, _arg_code: i32, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ThrowServiceException(_arg_code); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } Ok(()) } fn build_parcel_RepeatNullableIntArray(&self, _arg_input: Option<&[i32]>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_input)?; Ok(aidl_data) } fn read_response_RepeatNullableIntArray(&self, _arg_input: Option<&[i32]>, _aidl_reply: std::result::Result) -> binder::Result>> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatNullableIntArray(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option> = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatNullableByteEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum]>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_input)?; Ok(aidl_data) } fn read_response_RepeatNullableByteEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum]>, _aidl_reply: std::result::Result) -> binder::Result>> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatNullableByteEnumArray(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option> = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatNullableIntEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum]>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_input)?; Ok(aidl_data) } fn read_response_RepeatNullableIntEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum]>, _aidl_reply: std::result::Result) -> binder::Result>> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatNullableIntEnumArray(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option> = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatNullableLongEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum]>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_input)?; Ok(aidl_data) } fn read_response_RepeatNullableLongEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum]>, _aidl_reply: std::result::Result) -> binder::Result>> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatNullableLongEnumArray(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option> = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatNullableString(&self, _arg_input: Option<&str>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_input)?; Ok(aidl_data) } fn read_response_RepeatNullableString(&self, _arg_input: Option<&str>, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatNullableString(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatNullableStringList(&self, _arg_input: Option<&[Option]>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_input)?; Ok(aidl_data) } fn read_response_RepeatNullableStringList(&self, _arg_input: Option<&[Option]>, _aidl_reply: std::result::Result) -> binder::Result>>> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatNullableStringList(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option>> = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatNullableParcelable(&self, _arg_input: Option<&crate::mangled::_7_android_4_aidl_5_tests_12_ITestService_5_Empty>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_input)?; Ok(aidl_data) } fn read_response_RepeatNullableParcelable(&self, _arg_input: Option<&crate::mangled::_7_android_4_aidl_5_tests_12_ITestService_5_Empty>, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatNullableParcelable(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatNullableParcelableArray(&self, _arg_input: Option<&[Option]>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_input)?; Ok(aidl_data) } fn read_response_RepeatNullableParcelableArray(&self, _arg_input: Option<&[Option]>, _aidl_reply: std::result::Result) -> binder::Result>>> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatNullableParcelableArray(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option>> = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatNullableParcelableList(&self, _arg_input: Option<&[Option]>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_input)?; Ok(aidl_data) } fn read_response_RepeatNullableParcelableList(&self, _arg_input: Option<&[Option]>, _aidl_reply: std::result::Result) -> binder::Result>>> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatNullableParcelableList(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option>> = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_TakesAnIBinder(&self, _arg_input: &binder::SpIBinder) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_TakesAnIBinder(&self, _arg_input: &binder::SpIBinder, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#TakesAnIBinder(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } Ok(()) } fn build_parcel_TakesANullableIBinder(&self, _arg_input: Option<&binder::SpIBinder>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_input)?; Ok(aidl_data) } fn read_response_TakesANullableIBinder(&self, _arg_input: Option<&binder::SpIBinder>, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#TakesANullableIBinder(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } Ok(()) } fn build_parcel_TakesAnIBinderList(&self, _arg_input: &[binder::SpIBinder]) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_TakesAnIBinderList(&self, _arg_input: &[binder::SpIBinder], _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#TakesAnIBinderList(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } Ok(()) } fn build_parcel_TakesANullableIBinderList(&self, _arg_input: Option<&[Option]>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_input)?; Ok(aidl_data) } fn read_response_TakesANullableIBinderList(&self, _arg_input: Option<&[Option]>, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#TakesANullableIBinderList(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } Ok(()) } fn build_parcel_RepeatUtf8CppString(&self, _arg_token: &str) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_token)?; Ok(aidl_data) } fn read_response_RepeatUtf8CppString(&self, _arg_token: &str, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatUtf8CppString(_arg_token); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: String = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatNullableUtf8CppString(&self, _arg_token: Option<&str>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_token)?; Ok(aidl_data) } fn read_response_RepeatNullableUtf8CppString(&self, _arg_token: Option<&str>, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatNullableUtf8CppString(_arg_token); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_ReverseUtf8CppString(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; aidl_data.write_slice_size(Some(_arg_repeated))?; Ok(aidl_data) } fn read_response_ReverseUtf8CppString(&self, _arg_input: &[String], _arg_repeated: &mut Vec, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseUtf8CppString(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_ReverseNullableUtf8CppString(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_input)?; aidl_data.write_slice_size(_arg_repeated.as_deref())?; Ok(aidl_data) } fn read_response_ReverseNullableUtf8CppString(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>, _aidl_reply: std::result::Result) -> binder::Result>>> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseNullableUtf8CppString(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option>> = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_ReverseUtf8CppStringList(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_input)?; Ok(aidl_data) } fn read_response_ReverseUtf8CppStringList(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>, _aidl_reply: std::result::Result) -> binder::Result>>> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseUtf8CppStringList(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option>> = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_GetCallback(&self, _arg_return_null: bool) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_return_null)?; Ok(aidl_data) } fn read_response_GetCallback(&self, _arg_return_null: bool, _aidl_reply: std::result::Result) -> binder::Result>> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#GetCallback(_arg_return_null); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option> = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_FillOutStructuredParcelable(&self, _arg_parcel: &mut crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_parcel)?; Ok(aidl_data) } fn read_response_FillOutStructuredParcelable(&self, _arg_parcel: &mut crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#FillOutStructuredParcelable(_arg_parcel); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } _aidl_reply.read_onto(_arg_parcel)?; Ok(()) } fn build_parcel_RepeatExtendableParcelable(&self, _arg_ep: &crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable, _arg_ep2: &mut crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_ep)?; Ok(aidl_data) } fn read_response_RepeatExtendableParcelable(&self, _arg_ep: &crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable, _arg_ep2: &mut crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatExtendableParcelable(_arg_ep, _arg_ep2); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } _aidl_reply.read_onto(_arg_ep2)?; Ok(()) } fn build_parcel_ReverseList(&self, _arg_list: &crate::mangled::_7_android_4_aidl_5_tests_13_RecursiveList) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_list)?; Ok(aidl_data) } fn read_response_ReverseList(&self, _arg_list: &crate::mangled::_7_android_4_aidl_5_tests_13_RecursiveList, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseList(_arg_list); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_5_tests_13_RecursiveList = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_ReverseIBinderArray(&self, _arg_input: &[binder::SpIBinder], _arg_repeated: &mut Vec>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; aidl_data.write_slice_size(Some(_arg_repeated))?; Ok(aidl_data) } fn read_response_ReverseIBinderArray(&self, _arg_input: &[binder::SpIBinder], _arg_repeated: &mut Vec>, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseIBinderArray(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_ReverseNullableIBinderArray(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_input)?; aidl_data.write_slice_size(_arg_repeated.as_deref())?; Ok(aidl_data) } fn read_response_ReverseNullableIBinderArray(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>, _aidl_reply: std::result::Result) -> binder::Result>>> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseNullableIBinderArray(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option>> = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_RepeatSimpleParcelable(&self, _arg_input: &simple_parcelable::SimpleParcelable, _arg_repeat: &mut simple_parcelable::SimpleParcelable) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_RepeatSimpleParcelable(&self, _arg_input: &simple_parcelable::SimpleParcelable, _arg_repeat: &mut simple_parcelable::SimpleParcelable, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatSimpleParcelable(_arg_input, _arg_repeat); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: simple_parcelable::SimpleParcelable = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeat)?; Ok(_aidl_return) } fn build_parcel_ReverseSimpleParcelables(&self, _arg_input: &[simple_parcelable::SimpleParcelable], _arg_repeated: &mut Vec) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; aidl_data.write_slice_size(Some(_arg_repeated))?; Ok(aidl_data) } fn read_response_ReverseSimpleParcelables(&self, _arg_input: &[simple_parcelable::SimpleParcelable], _arg_repeated: &mut Vec, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseSimpleParcelables(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_GetOldNameInterface(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); Ok(aidl_data) } fn read_response_GetOldNameInterface(&self, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#GetOldNameInterface(); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: binder::Strong = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_GetNewNameInterface(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); Ok(aidl_data) } fn read_response_GetNewNameInterface(&self, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#GetNewNameInterface(); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: binder::Strong = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_GetUnionTags(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_5_Union]) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_GetUnionTags(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_5_Union], _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#GetUnionTags(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_GetCppJavaTests(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); Ok(aidl_data) } fn read_response_GetCppJavaTests(&self, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#GetCppJavaTests(); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_getBackendType(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); Ok(aidl_data) } fn read_response_getBackendType(&self, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#getBackendType(); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_5_tests_11_BackendType = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_GetCircular(&self, _arg_cp: &mut crate::mangled::_7_android_4_aidl_5_tests_18_CircularParcelable) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); Ok(aidl_data) } fn read_response_GetCircular(&self, _arg_cp: &mut crate::mangled::_7_android_4_aidl_5_tests_18_CircularParcelable, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#GetCircular(_arg_cp); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: binder::Strong = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_cp)?; Ok(_aidl_return) } } impl ITestService for BpTestService { fn r#UnimplementedMethod(&self, _arg_arg: i32) -> binder::Result { let _aidl_data = self.build_parcel_UnimplementedMethod(_arg_arg)?; let _aidl_reply = self.binder.submit_transact(transactions::r#UnimplementedMethod, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_UnimplementedMethod(_arg_arg, _aidl_reply) } fn r#Deprecated(&self) -> binder::Result<()> { let _aidl_data = self.build_parcel_Deprecated()?; let _aidl_reply = self.binder.submit_transact(transactions::r#Deprecated, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_Deprecated(_aidl_reply) } fn r#TestOneway(&self) -> binder::Result<()> { let _aidl_data = self.build_parcel_TestOneway()?; let _aidl_reply = self.binder.submit_transact(transactions::r#TestOneway, _aidl_data, binder::binder_impl::FLAG_ONEWAY | binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_TestOneway(_aidl_reply) } fn r#RepeatBoolean(&self, _arg_token: bool) -> binder::Result { let _aidl_data = self.build_parcel_RepeatBoolean(_arg_token)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatBoolean, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatBoolean(_arg_token, _aidl_reply) } fn r#RepeatByte(&self, _arg_token: i8) -> binder::Result { let _aidl_data = self.build_parcel_RepeatByte(_arg_token)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatByte, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatByte(_arg_token, _aidl_reply) } fn r#RepeatChar(&self, _arg_token: u16) -> binder::Result { let _aidl_data = self.build_parcel_RepeatChar(_arg_token)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatChar, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatChar(_arg_token, _aidl_reply) } fn r#RepeatInt(&self, _arg_token: i32) -> binder::Result { let _aidl_data = self.build_parcel_RepeatInt(_arg_token)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatInt, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatInt(_arg_token, _aidl_reply) } fn r#RepeatLong(&self, _arg_token: i64) -> binder::Result { let _aidl_data = self.build_parcel_RepeatLong(_arg_token)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatLong, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatLong(_arg_token, _aidl_reply) } fn r#RepeatFloat(&self, _arg_token: f32) -> binder::Result { let _aidl_data = self.build_parcel_RepeatFloat(_arg_token)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatFloat, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatFloat(_arg_token, _aidl_reply) } fn r#RepeatDouble(&self, _arg_token: f64) -> binder::Result { let _aidl_data = self.build_parcel_RepeatDouble(_arg_token)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatDouble, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatDouble(_arg_token, _aidl_reply) } fn r#RepeatString(&self, _arg_token: &str) -> binder::Result { let _aidl_data = self.build_parcel_RepeatString(_arg_token)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatString, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatString(_arg_token, _aidl_reply) } fn r#RepeatByteEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum) -> binder::Result { let _aidl_data = self.build_parcel_RepeatByteEnum(_arg_token)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatByteEnum, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatByteEnum(_arg_token, _aidl_reply) } fn r#RepeatIntEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum) -> binder::Result { let _aidl_data = self.build_parcel_RepeatIntEnum(_arg_token)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatIntEnum, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatIntEnum(_arg_token, _aidl_reply) } fn r#RepeatLongEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum) -> binder::Result { let _aidl_data = self.build_parcel_RepeatLongEnum(_arg_token)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatLongEnum, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatLongEnum(_arg_token, _aidl_reply) } fn r#ReverseBoolean(&self, _arg_input: &[bool], _arg_repeated: &mut Vec) -> binder::Result> { let _aidl_data = self.build_parcel_ReverseBoolean(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseBoolean, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseBoolean(_arg_input, _arg_repeated, _aidl_reply) } fn r#ReverseByte(&self, _arg_input: &[u8], _arg_repeated: &mut Vec) -> binder::Result> { let _aidl_data = self.build_parcel_ReverseByte(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseByte, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseByte(_arg_input, _arg_repeated, _aidl_reply) } fn r#ReverseChar(&self, _arg_input: &[u16], _arg_repeated: &mut Vec) -> binder::Result> { let _aidl_data = self.build_parcel_ReverseChar(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseChar, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseChar(_arg_input, _arg_repeated, _aidl_reply) } fn r#ReverseInt(&self, _arg_input: &[i32], _arg_repeated: &mut Vec) -> binder::Result> { let _aidl_data = self.build_parcel_ReverseInt(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseInt, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseInt(_arg_input, _arg_repeated, _aidl_reply) } fn r#ReverseLong(&self, _arg_input: &[i64], _arg_repeated: &mut Vec) -> binder::Result> { let _aidl_data = self.build_parcel_ReverseLong(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseLong, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseLong(_arg_input, _arg_repeated, _aidl_reply) } fn r#ReverseFloat(&self, _arg_input: &[f32], _arg_repeated: &mut Vec) -> binder::Result> { let _aidl_data = self.build_parcel_ReverseFloat(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseFloat, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseFloat(_arg_input, _arg_repeated, _aidl_reply) } fn r#ReverseDouble(&self, _arg_input: &[f64], _arg_repeated: &mut Vec) -> binder::Result> { let _aidl_data = self.build_parcel_ReverseDouble(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseDouble, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseDouble(_arg_input, _arg_repeated, _aidl_reply) } fn r#ReverseString(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result> { let _aidl_data = self.build_parcel_ReverseString(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseString, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseString(_arg_input, _arg_repeated, _aidl_reply) } fn r#ReverseByteEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum], _arg_repeated: &mut Vec) -> binder::Result> { let _aidl_data = self.build_parcel_ReverseByteEnum(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseByteEnum, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseByteEnum(_arg_input, _arg_repeated, _aidl_reply) } fn r#ReverseIntEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum], _arg_repeated: &mut Vec) -> binder::Result> { let _aidl_data = self.build_parcel_ReverseIntEnum(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseIntEnum, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseIntEnum(_arg_input, _arg_repeated, _aidl_reply) } fn r#ReverseLongEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum], _arg_repeated: &mut Vec) -> binder::Result> { let _aidl_data = self.build_parcel_ReverseLongEnum(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseLongEnum, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseLongEnum(_arg_input, _arg_repeated, _aidl_reply) } fn r#GetOtherTestService(&self, _arg_name: &str) -> binder::Result> { let _aidl_data = self.build_parcel_GetOtherTestService(_arg_name)?; let _aidl_reply = self.binder.submit_transact(transactions::r#GetOtherTestService, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_GetOtherTestService(_arg_name, _aidl_reply) } fn r#SetOtherTestService(&self, _arg_name: &str, _arg_service: &binder::Strong) -> binder::Result { let _aidl_data = self.build_parcel_SetOtherTestService(_arg_name, _arg_service)?; let _aidl_reply = self.binder.submit_transact(transactions::r#SetOtherTestService, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_SetOtherTestService(_arg_name, _arg_service, _aidl_reply) } fn r#VerifyName(&self, _arg_service: &binder::Strong, _arg_name: &str) -> binder::Result { let _aidl_data = self.build_parcel_VerifyName(_arg_service, _arg_name)?; let _aidl_reply = self.binder.submit_transact(transactions::r#VerifyName, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_VerifyName(_arg_service, _arg_name, _aidl_reply) } fn r#GetInterfaceArray(&self, _arg_names: &[String]) -> binder::Result>> { let _aidl_data = self.build_parcel_GetInterfaceArray(_arg_names)?; let _aidl_reply = self.binder.submit_transact(transactions::r#GetInterfaceArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_GetInterfaceArray(_arg_names, _aidl_reply) } fn r#VerifyNamesWithInterfaceArray(&self, _arg_services: &[binder::Strong], _arg_names: &[String]) -> binder::Result { let _aidl_data = self.build_parcel_VerifyNamesWithInterfaceArray(_arg_services, _arg_names)?; let _aidl_reply = self.binder.submit_transact(transactions::r#VerifyNamesWithInterfaceArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_VerifyNamesWithInterfaceArray(_arg_services, _arg_names, _aidl_reply) } fn r#GetNullableInterfaceArray(&self, _arg_names: Option<&[Option]>) -> binder::Result>>>> { let _aidl_data = self.build_parcel_GetNullableInterfaceArray(_arg_names)?; let _aidl_reply = self.binder.submit_transact(transactions::r#GetNullableInterfaceArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_GetNullableInterfaceArray(_arg_names, _aidl_reply) } fn r#VerifyNamesWithNullableInterfaceArray(&self, _arg_services: Option<&[Option>]>, _arg_names: Option<&[Option]>) -> binder::Result { let _aidl_data = self.build_parcel_VerifyNamesWithNullableInterfaceArray(_arg_services, _arg_names)?; let _aidl_reply = self.binder.submit_transact(transactions::r#VerifyNamesWithNullableInterfaceArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_VerifyNamesWithNullableInterfaceArray(_arg_services, _arg_names, _aidl_reply) } fn r#GetInterfaceList(&self, _arg_names: Option<&[Option]>) -> binder::Result>>>> { let _aidl_data = self.build_parcel_GetInterfaceList(_arg_names)?; let _aidl_reply = self.binder.submit_transact(transactions::r#GetInterfaceList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_GetInterfaceList(_arg_names, _aidl_reply) } fn r#VerifyNamesWithInterfaceList(&self, _arg_services: Option<&[Option>]>, _arg_names: Option<&[Option]>) -> binder::Result { let _aidl_data = self.build_parcel_VerifyNamesWithInterfaceList(_arg_services, _arg_names)?; let _aidl_reply = self.binder.submit_transact(transactions::r#VerifyNamesWithInterfaceList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_VerifyNamesWithInterfaceList(_arg_services, _arg_names, _aidl_reply) } fn r#ReverseStringList(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result> { let _aidl_data = self.build_parcel_ReverseStringList(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseStringList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseStringList(_arg_input, _arg_repeated, _aidl_reply) } fn r#RepeatParcelFileDescriptor(&self, _arg_read: &binder::ParcelFileDescriptor) -> binder::Result { let _aidl_data = self.build_parcel_RepeatParcelFileDescriptor(_arg_read)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatParcelFileDescriptor, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatParcelFileDescriptor(_arg_read, _aidl_reply) } fn r#ReverseParcelFileDescriptorArray(&self, _arg_input: &[binder::ParcelFileDescriptor], _arg_repeated: &mut Vec>) -> binder::Result> { let _aidl_data = self.build_parcel_ReverseParcelFileDescriptorArray(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseParcelFileDescriptorArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseParcelFileDescriptorArray(_arg_input, _arg_repeated, _aidl_reply) } fn r#ThrowServiceException(&self, _arg_code: i32) -> binder::Result<()> { let _aidl_data = self.build_parcel_ThrowServiceException(_arg_code)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ThrowServiceException, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ThrowServiceException(_arg_code, _aidl_reply) } fn r#RepeatNullableIntArray(&self, _arg_input: Option<&[i32]>) -> binder::Result>> { let _aidl_data = self.build_parcel_RepeatNullableIntArray(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatNullableIntArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatNullableIntArray(_arg_input, _aidl_reply) } fn r#RepeatNullableByteEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum]>) -> binder::Result>> { let _aidl_data = self.build_parcel_RepeatNullableByteEnumArray(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatNullableByteEnumArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatNullableByteEnumArray(_arg_input, _aidl_reply) } fn r#RepeatNullableIntEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum]>) -> binder::Result>> { let _aidl_data = self.build_parcel_RepeatNullableIntEnumArray(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatNullableIntEnumArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatNullableIntEnumArray(_arg_input, _aidl_reply) } fn r#RepeatNullableLongEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum]>) -> binder::Result>> { let _aidl_data = self.build_parcel_RepeatNullableLongEnumArray(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatNullableLongEnumArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatNullableLongEnumArray(_arg_input, _aidl_reply) } fn r#RepeatNullableString(&self, _arg_input: Option<&str>) -> binder::Result> { let _aidl_data = self.build_parcel_RepeatNullableString(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatNullableString, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatNullableString(_arg_input, _aidl_reply) } fn r#RepeatNullableStringList(&self, _arg_input: Option<&[Option]>) -> binder::Result>>> { let _aidl_data = self.build_parcel_RepeatNullableStringList(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatNullableStringList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatNullableStringList(_arg_input, _aidl_reply) } fn r#RepeatNullableParcelable(&self, _arg_input: Option<&crate::mangled::_7_android_4_aidl_5_tests_12_ITestService_5_Empty>) -> binder::Result> { let _aidl_data = self.build_parcel_RepeatNullableParcelable(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatNullableParcelable, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatNullableParcelable(_arg_input, _aidl_reply) } fn r#RepeatNullableParcelableArray(&self, _arg_input: Option<&[Option]>) -> binder::Result>>> { let _aidl_data = self.build_parcel_RepeatNullableParcelableArray(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatNullableParcelableArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatNullableParcelableArray(_arg_input, _aidl_reply) } fn r#RepeatNullableParcelableList(&self, _arg_input: Option<&[Option]>) -> binder::Result>>> { let _aidl_data = self.build_parcel_RepeatNullableParcelableList(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatNullableParcelableList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatNullableParcelableList(_arg_input, _aidl_reply) } fn r#TakesAnIBinder(&self, _arg_input: &binder::SpIBinder) -> binder::Result<()> { let _aidl_data = self.build_parcel_TakesAnIBinder(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#TakesAnIBinder, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_TakesAnIBinder(_arg_input, _aidl_reply) } fn r#TakesANullableIBinder(&self, _arg_input: Option<&binder::SpIBinder>) -> binder::Result<()> { let _aidl_data = self.build_parcel_TakesANullableIBinder(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#TakesANullableIBinder, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_TakesANullableIBinder(_arg_input, _aidl_reply) } fn r#TakesAnIBinderList(&self, _arg_input: &[binder::SpIBinder]) -> binder::Result<()> { let _aidl_data = self.build_parcel_TakesAnIBinderList(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#TakesAnIBinderList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_TakesAnIBinderList(_arg_input, _aidl_reply) } fn r#TakesANullableIBinderList(&self, _arg_input: Option<&[Option]>) -> binder::Result<()> { let _aidl_data = self.build_parcel_TakesANullableIBinderList(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#TakesANullableIBinderList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_TakesANullableIBinderList(_arg_input, _aidl_reply) } fn r#RepeatUtf8CppString(&self, _arg_token: &str) -> binder::Result { let _aidl_data = self.build_parcel_RepeatUtf8CppString(_arg_token)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatUtf8CppString, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatUtf8CppString(_arg_token, _aidl_reply) } fn r#RepeatNullableUtf8CppString(&self, _arg_token: Option<&str>) -> binder::Result> { let _aidl_data = self.build_parcel_RepeatNullableUtf8CppString(_arg_token)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatNullableUtf8CppString, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatNullableUtf8CppString(_arg_token, _aidl_reply) } fn r#ReverseUtf8CppString(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result> { let _aidl_data = self.build_parcel_ReverseUtf8CppString(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseUtf8CppString, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseUtf8CppString(_arg_input, _arg_repeated, _aidl_reply) } fn r#ReverseNullableUtf8CppString(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>> { let _aidl_data = self.build_parcel_ReverseNullableUtf8CppString(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseNullableUtf8CppString, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseNullableUtf8CppString(_arg_input, _arg_repeated, _aidl_reply) } fn r#ReverseUtf8CppStringList(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>> { let _aidl_data = self.build_parcel_ReverseUtf8CppStringList(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseUtf8CppStringList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseUtf8CppStringList(_arg_input, _arg_repeated, _aidl_reply) } fn r#GetCallback(&self, _arg_return_null: bool) -> binder::Result>> { let _aidl_data = self.build_parcel_GetCallback(_arg_return_null)?; let _aidl_reply = self.binder.submit_transact(transactions::r#GetCallback, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_GetCallback(_arg_return_null, _aidl_reply) } fn r#FillOutStructuredParcelable(&self, _arg_parcel: &mut crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable) -> binder::Result<()> { let _aidl_data = self.build_parcel_FillOutStructuredParcelable(_arg_parcel)?; let _aidl_reply = self.binder.submit_transact(transactions::r#FillOutStructuredParcelable, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_FillOutStructuredParcelable(_arg_parcel, _aidl_reply) } fn r#RepeatExtendableParcelable(&self, _arg_ep: &crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable, _arg_ep2: &mut crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable) -> binder::Result<()> { let _aidl_data = self.build_parcel_RepeatExtendableParcelable(_arg_ep, _arg_ep2)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatExtendableParcelable, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatExtendableParcelable(_arg_ep, _arg_ep2, _aidl_reply) } fn r#ReverseList(&self, _arg_list: &crate::mangled::_7_android_4_aidl_5_tests_13_RecursiveList) -> binder::Result { let _aidl_data = self.build_parcel_ReverseList(_arg_list)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseList(_arg_list, _aidl_reply) } fn r#ReverseIBinderArray(&self, _arg_input: &[binder::SpIBinder], _arg_repeated: &mut Vec>) -> binder::Result> { let _aidl_data = self.build_parcel_ReverseIBinderArray(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseIBinderArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseIBinderArray(_arg_input, _arg_repeated, _aidl_reply) } fn r#ReverseNullableIBinderArray(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>> { let _aidl_data = self.build_parcel_ReverseNullableIBinderArray(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseNullableIBinderArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseNullableIBinderArray(_arg_input, _arg_repeated, _aidl_reply) } fn r#RepeatSimpleParcelable(&self, _arg_input: &simple_parcelable::SimpleParcelable, _arg_repeat: &mut simple_parcelable::SimpleParcelable) -> binder::Result { let _aidl_data = self.build_parcel_RepeatSimpleParcelable(_arg_input, _arg_repeat)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatSimpleParcelable, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatSimpleParcelable(_arg_input, _arg_repeat, _aidl_reply) } fn r#ReverseSimpleParcelables(&self, _arg_input: &[simple_parcelable::SimpleParcelable], _arg_repeated: &mut Vec) -> binder::Result> { let _aidl_data = self.build_parcel_ReverseSimpleParcelables(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseSimpleParcelables, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseSimpleParcelables(_arg_input, _arg_repeated, _aidl_reply) } fn r#GetOldNameInterface(&self) -> binder::Result> { let _aidl_data = self.build_parcel_GetOldNameInterface()?; let _aidl_reply = self.binder.submit_transact(transactions::r#GetOldNameInterface, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_GetOldNameInterface(_aidl_reply) } fn r#GetNewNameInterface(&self) -> binder::Result> { let _aidl_data = self.build_parcel_GetNewNameInterface()?; let _aidl_reply = self.binder.submit_transact(transactions::r#GetNewNameInterface, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_GetNewNameInterface(_aidl_reply) } fn r#GetUnionTags(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_5_Union]) -> binder::Result> { let _aidl_data = self.build_parcel_GetUnionTags(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#GetUnionTags, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_GetUnionTags(_arg_input, _aidl_reply) } fn r#GetCppJavaTests(&self) -> binder::Result> { let _aidl_data = self.build_parcel_GetCppJavaTests()?; let _aidl_reply = self.binder.submit_transact(transactions::r#GetCppJavaTests, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_GetCppJavaTests(_aidl_reply) } fn r#getBackendType(&self) -> binder::Result { let _aidl_data = self.build_parcel_getBackendType()?; let _aidl_reply = self.binder.submit_transact(transactions::r#getBackendType, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_getBackendType(_aidl_reply) } fn r#GetCircular(&self, _arg_cp: &mut crate::mangled::_7_android_4_aidl_5_tests_18_CircularParcelable) -> binder::Result> { let _aidl_data = self.build_parcel_GetCircular(_arg_cp)?; let _aidl_reply = self.binder.submit_transact(transactions::r#GetCircular, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_GetCircular(_arg_cp, _aidl_reply) } } impl ITestServiceAsync

for BpTestService { fn r#UnimplementedMethod<'a>(&'a self, _arg_arg: i32) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_UnimplementedMethod(_arg_arg) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#UnimplementedMethod, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_UnimplementedMethod(_arg_arg, _aidl_reply) } ) } fn r#Deprecated<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_Deprecated() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#Deprecated, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_Deprecated(_aidl_reply) } ) } fn r#TestOneway(&self) -> std::future::Ready> { let _aidl_data = match self.build_parcel_TestOneway() { Ok(_aidl_data) => _aidl_data, Err(err) => return std::future::ready(Err(err)), }; let _aidl_reply = self.binder.submit_transact(transactions::r#TestOneway, _aidl_data, binder::binder_impl::FLAG_ONEWAY | binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); std::future::ready(self.read_response_TestOneway(_aidl_reply)) } fn r#RepeatBoolean<'a>(&'a self, _arg_token: bool) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_RepeatBoolean(_arg_token) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatBoolean, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatBoolean(_arg_token, _aidl_reply) } ) } fn r#RepeatByte<'a>(&'a self, _arg_token: i8) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_RepeatByte(_arg_token) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatByte, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatByte(_arg_token, _aidl_reply) } ) } fn r#RepeatChar<'a>(&'a self, _arg_token: u16) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_RepeatChar(_arg_token) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatChar, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatChar(_arg_token, _aidl_reply) } ) } fn r#RepeatInt<'a>(&'a self, _arg_token: i32) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_RepeatInt(_arg_token) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatInt, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatInt(_arg_token, _aidl_reply) } ) } fn r#RepeatLong<'a>(&'a self, _arg_token: i64) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_RepeatLong(_arg_token) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatLong, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatLong(_arg_token, _aidl_reply) } ) } fn r#RepeatFloat<'a>(&'a self, _arg_token: f32) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_RepeatFloat(_arg_token) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatFloat, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatFloat(_arg_token, _aidl_reply) } ) } fn r#RepeatDouble<'a>(&'a self, _arg_token: f64) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_RepeatDouble(_arg_token) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatDouble, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatDouble(_arg_token, _aidl_reply) } ) } fn r#RepeatString<'a>(&'a self, _arg_token: &'a str) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_RepeatString(_arg_token) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatString, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatString(_arg_token, _aidl_reply) } ) } fn r#RepeatByteEnum<'a>(&'a self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_RepeatByteEnum(_arg_token) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatByteEnum, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatByteEnum(_arg_token, _aidl_reply) } ) } fn r#RepeatIntEnum<'a>(&'a self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_RepeatIntEnum(_arg_token) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatIntEnum, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatIntEnum(_arg_token, _aidl_reply) } ) } fn r#RepeatLongEnum<'a>(&'a self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_RepeatLongEnum(_arg_token) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatLongEnum, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatLongEnum(_arg_token, _aidl_reply) } ) } fn r#ReverseBoolean<'a>(&'a self, _arg_input: &'a [bool], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_ReverseBoolean(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseBoolean, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseBoolean(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#ReverseByte<'a>(&'a self, _arg_input: &'a [u8], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_ReverseByte(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseByte, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseByte(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#ReverseChar<'a>(&'a self, _arg_input: &'a [u16], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_ReverseChar(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseChar, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseChar(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#ReverseInt<'a>(&'a self, _arg_input: &'a [i32], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_ReverseInt(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseInt, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseInt(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#ReverseLong<'a>(&'a self, _arg_input: &'a [i64], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_ReverseLong(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseLong, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseLong(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#ReverseFloat<'a>(&'a self, _arg_input: &'a [f32], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_ReverseFloat(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseFloat, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseFloat(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#ReverseDouble<'a>(&'a self, _arg_input: &'a [f64], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_ReverseDouble(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseDouble, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseDouble(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#ReverseString<'a>(&'a self, _arg_input: &'a [String], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_ReverseString(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseString, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseString(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#ReverseByteEnum<'a>(&'a self, _arg_input: &'a [crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_ReverseByteEnum(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseByteEnum, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseByteEnum(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#ReverseIntEnum<'a>(&'a self, _arg_input: &'a [crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_ReverseIntEnum(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseIntEnum, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseIntEnum(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#ReverseLongEnum<'a>(&'a self, _arg_input: &'a [crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_ReverseLongEnum(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseLongEnum, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseLongEnum(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#GetOtherTestService<'a>(&'a self, _arg_name: &'a str) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_GetOtherTestService(_arg_name) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#GetOtherTestService, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_GetOtherTestService(_arg_name, _aidl_reply) } ) } fn r#SetOtherTestService<'a>(&'a self, _arg_name: &'a str, _arg_service: &'a binder::Strong) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_SetOtherTestService(_arg_name, _arg_service) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#SetOtherTestService, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_SetOtherTestService(_arg_name, _arg_service, _aidl_reply) } ) } fn r#VerifyName<'a>(&'a self, _arg_service: &'a binder::Strong, _arg_name: &'a str) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_VerifyName(_arg_service, _arg_name) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#VerifyName, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_VerifyName(_arg_service, _arg_name, _aidl_reply) } ) } fn r#GetInterfaceArray<'a>(&'a self, _arg_names: &'a [String]) -> binder::BoxFuture<'a, binder::Result>>> { let _aidl_data = match self.build_parcel_GetInterfaceArray(_arg_names) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#GetInterfaceArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_GetInterfaceArray(_arg_names, _aidl_reply) } ) } fn r#VerifyNamesWithInterfaceArray<'a>(&'a self, _arg_services: &'a [binder::Strong], _arg_names: &'a [String]) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_VerifyNamesWithInterfaceArray(_arg_services, _arg_names) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#VerifyNamesWithInterfaceArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_VerifyNamesWithInterfaceArray(_arg_services, _arg_names, _aidl_reply) } ) } fn r#GetNullableInterfaceArray<'a>(&'a self, _arg_names: Option<&'a [Option]>) -> binder::BoxFuture<'a, binder::Result>>>>> { let _aidl_data = match self.build_parcel_GetNullableInterfaceArray(_arg_names) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#GetNullableInterfaceArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_GetNullableInterfaceArray(_arg_names, _aidl_reply) } ) } fn r#VerifyNamesWithNullableInterfaceArray<'a>(&'a self, _arg_services: Option<&'a [Option>]>, _arg_names: Option<&'a [Option]>) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_VerifyNamesWithNullableInterfaceArray(_arg_services, _arg_names) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#VerifyNamesWithNullableInterfaceArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_VerifyNamesWithNullableInterfaceArray(_arg_services, _arg_names, _aidl_reply) } ) } fn r#GetInterfaceList<'a>(&'a self, _arg_names: Option<&'a [Option]>) -> binder::BoxFuture<'a, binder::Result>>>>> { let _aidl_data = match self.build_parcel_GetInterfaceList(_arg_names) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#GetInterfaceList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_GetInterfaceList(_arg_names, _aidl_reply) } ) } fn r#VerifyNamesWithInterfaceList<'a>(&'a self, _arg_services: Option<&'a [Option>]>, _arg_names: Option<&'a [Option]>) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_VerifyNamesWithInterfaceList(_arg_services, _arg_names) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#VerifyNamesWithInterfaceList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_VerifyNamesWithInterfaceList(_arg_services, _arg_names, _aidl_reply) } ) } fn r#ReverseStringList<'a>(&'a self, _arg_input: &'a [String], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_ReverseStringList(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseStringList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseStringList(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#RepeatParcelFileDescriptor<'a>(&'a self, _arg_read: &'a binder::ParcelFileDescriptor) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_RepeatParcelFileDescriptor(_arg_read) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatParcelFileDescriptor, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatParcelFileDescriptor(_arg_read, _aidl_reply) } ) } fn r#ReverseParcelFileDescriptorArray<'a>(&'a self, _arg_input: &'a [binder::ParcelFileDescriptor], _arg_repeated: &'a mut Vec>) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_ReverseParcelFileDescriptorArray(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseParcelFileDescriptorArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseParcelFileDescriptorArray(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#ThrowServiceException<'a>(&'a self, _arg_code: i32) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_ThrowServiceException(_arg_code) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ThrowServiceException, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ThrowServiceException(_arg_code, _aidl_reply) } ) } fn r#RepeatNullableIntArray<'a>(&'a self, _arg_input: Option<&'a [i32]>) -> binder::BoxFuture<'a, binder::Result>>> { let _aidl_data = match self.build_parcel_RepeatNullableIntArray(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatNullableIntArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatNullableIntArray(_arg_input, _aidl_reply) } ) } fn r#RepeatNullableByteEnumArray<'a>(&'a self, _arg_input: Option<&'a [crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum]>) -> binder::BoxFuture<'a, binder::Result>>> { let _aidl_data = match self.build_parcel_RepeatNullableByteEnumArray(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatNullableByteEnumArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatNullableByteEnumArray(_arg_input, _aidl_reply) } ) } fn r#RepeatNullableIntEnumArray<'a>(&'a self, _arg_input: Option<&'a [crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum]>) -> binder::BoxFuture<'a, binder::Result>>> { let _aidl_data = match self.build_parcel_RepeatNullableIntEnumArray(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatNullableIntEnumArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatNullableIntEnumArray(_arg_input, _aidl_reply) } ) } fn r#RepeatNullableLongEnumArray<'a>(&'a self, _arg_input: Option<&'a [crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum]>) -> binder::BoxFuture<'a, binder::Result>>> { let _aidl_data = match self.build_parcel_RepeatNullableLongEnumArray(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatNullableLongEnumArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatNullableLongEnumArray(_arg_input, _aidl_reply) } ) } fn r#RepeatNullableString<'a>(&'a self, _arg_input: Option<&'a str>) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_RepeatNullableString(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatNullableString, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatNullableString(_arg_input, _aidl_reply) } ) } fn r#RepeatNullableStringList<'a>(&'a self, _arg_input: Option<&'a [Option]>) -> binder::BoxFuture<'a, binder::Result>>>> { let _aidl_data = match self.build_parcel_RepeatNullableStringList(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatNullableStringList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatNullableStringList(_arg_input, _aidl_reply) } ) } fn r#RepeatNullableParcelable<'a>(&'a self, _arg_input: Option<&'a crate::mangled::_7_android_4_aidl_5_tests_12_ITestService_5_Empty>) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_RepeatNullableParcelable(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatNullableParcelable, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatNullableParcelable(_arg_input, _aidl_reply) } ) } fn r#RepeatNullableParcelableArray<'a>(&'a self, _arg_input: Option<&'a [Option]>) -> binder::BoxFuture<'a, binder::Result>>>> { let _aidl_data = match self.build_parcel_RepeatNullableParcelableArray(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatNullableParcelableArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatNullableParcelableArray(_arg_input, _aidl_reply) } ) } fn r#RepeatNullableParcelableList<'a>(&'a self, _arg_input: Option<&'a [Option]>) -> binder::BoxFuture<'a, binder::Result>>>> { let _aidl_data = match self.build_parcel_RepeatNullableParcelableList(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatNullableParcelableList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatNullableParcelableList(_arg_input, _aidl_reply) } ) } fn r#TakesAnIBinder<'a>(&'a self, _arg_input: &'a binder::SpIBinder) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_TakesAnIBinder(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#TakesAnIBinder, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_TakesAnIBinder(_arg_input, _aidl_reply) } ) } fn r#TakesANullableIBinder<'a>(&'a self, _arg_input: Option<&'a binder::SpIBinder>) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_TakesANullableIBinder(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#TakesANullableIBinder, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_TakesANullableIBinder(_arg_input, _aidl_reply) } ) } fn r#TakesAnIBinderList<'a>(&'a self, _arg_input: &'a [binder::SpIBinder]) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_TakesAnIBinderList(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#TakesAnIBinderList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_TakesAnIBinderList(_arg_input, _aidl_reply) } ) } fn r#TakesANullableIBinderList<'a>(&'a self, _arg_input: Option<&'a [Option]>) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_TakesANullableIBinderList(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#TakesANullableIBinderList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_TakesANullableIBinderList(_arg_input, _aidl_reply) } ) } fn r#RepeatUtf8CppString<'a>(&'a self, _arg_token: &'a str) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_RepeatUtf8CppString(_arg_token) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatUtf8CppString, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatUtf8CppString(_arg_token, _aidl_reply) } ) } fn r#RepeatNullableUtf8CppString<'a>(&'a self, _arg_token: Option<&'a str>) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_RepeatNullableUtf8CppString(_arg_token) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatNullableUtf8CppString, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatNullableUtf8CppString(_arg_token, _aidl_reply) } ) } fn r#ReverseUtf8CppString<'a>(&'a self, _arg_input: &'a [String], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_ReverseUtf8CppString(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseUtf8CppString, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseUtf8CppString(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#ReverseNullableUtf8CppString<'a>(&'a self, _arg_input: Option<&'a [Option]>, _arg_repeated: &'a mut Option>>) -> binder::BoxFuture<'a, binder::Result>>>> { let _aidl_data = match self.build_parcel_ReverseNullableUtf8CppString(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseNullableUtf8CppString, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseNullableUtf8CppString(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#ReverseUtf8CppStringList<'a>(&'a self, _arg_input: Option<&'a [Option]>, _arg_repeated: &'a mut Option>>) -> binder::BoxFuture<'a, binder::Result>>>> { let _aidl_data = match self.build_parcel_ReverseUtf8CppStringList(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseUtf8CppStringList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseUtf8CppStringList(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#GetCallback<'a>(&'a self, _arg_return_null: bool) -> binder::BoxFuture<'a, binder::Result>>> { let _aidl_data = match self.build_parcel_GetCallback(_arg_return_null) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#GetCallback, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_GetCallback(_arg_return_null, _aidl_reply) } ) } fn r#FillOutStructuredParcelable<'a>(&'a self, _arg_parcel: &'a mut crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_FillOutStructuredParcelable(_arg_parcel) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#FillOutStructuredParcelable, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_FillOutStructuredParcelable(_arg_parcel, _aidl_reply) } ) } fn r#RepeatExtendableParcelable<'a>(&'a self, _arg_ep: &'a crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable, _arg_ep2: &'a mut crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_RepeatExtendableParcelable(_arg_ep, _arg_ep2) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatExtendableParcelable, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatExtendableParcelable(_arg_ep, _arg_ep2, _aidl_reply) } ) } fn r#ReverseList<'a>(&'a self, _arg_list: &'a crate::mangled::_7_android_4_aidl_5_tests_13_RecursiveList) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_ReverseList(_arg_list) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseList(_arg_list, _aidl_reply) } ) } fn r#ReverseIBinderArray<'a>(&'a self, _arg_input: &'a [binder::SpIBinder], _arg_repeated: &'a mut Vec>) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_ReverseIBinderArray(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseIBinderArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseIBinderArray(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#ReverseNullableIBinderArray<'a>(&'a self, _arg_input: Option<&'a [Option]>, _arg_repeated: &'a mut Option>>) -> binder::BoxFuture<'a, binder::Result>>>> { let _aidl_data = match self.build_parcel_ReverseNullableIBinderArray(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseNullableIBinderArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseNullableIBinderArray(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#RepeatSimpleParcelable<'a>(&'a self, _arg_input: &'a simple_parcelable::SimpleParcelable, _arg_repeat: &'a mut simple_parcelable::SimpleParcelable) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_RepeatSimpleParcelable(_arg_input, _arg_repeat) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatSimpleParcelable, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatSimpleParcelable(_arg_input, _arg_repeat, _aidl_reply) } ) } fn r#ReverseSimpleParcelables<'a>(&'a self, _arg_input: &'a [simple_parcelable::SimpleParcelable], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_ReverseSimpleParcelables(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseSimpleParcelables, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseSimpleParcelables(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#GetOldNameInterface<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_GetOldNameInterface() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#GetOldNameInterface, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_GetOldNameInterface(_aidl_reply) } ) } fn r#GetNewNameInterface<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_GetNewNameInterface() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#GetNewNameInterface, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_GetNewNameInterface(_aidl_reply) } ) } fn r#GetUnionTags<'a>(&'a self, _arg_input: &'a [crate::mangled::_7_android_4_aidl_5_tests_5_Union]) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_GetUnionTags(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#GetUnionTags, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_GetUnionTags(_arg_input, _aidl_reply) } ) } fn r#GetCppJavaTests<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_GetCppJavaTests() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#GetCppJavaTests, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_GetCppJavaTests(_aidl_reply) } ) } fn r#getBackendType<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_getBackendType() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#getBackendType, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_getBackendType(_aidl_reply) } ) } fn r#GetCircular<'a>(&'a self, _arg_cp: &'a mut crate::mangled::_7_android_4_aidl_5_tests_18_CircularParcelable) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_GetCircular(_arg_cp) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#GetCircular, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_GetCircular(_arg_cp, _aidl_reply) } ) } } impl ITestService for binder::binder_impl::Binder { fn r#UnimplementedMethod(&self, _arg_arg: i32) -> binder::Result { self.0.r#UnimplementedMethod(_arg_arg) } fn r#Deprecated(&self) -> binder::Result<()> { self.0.r#Deprecated() } fn r#TestOneway(&self) -> binder::Result<()> { self.0.r#TestOneway() } fn r#RepeatBoolean(&self, _arg_token: bool) -> binder::Result { self.0.r#RepeatBoolean(_arg_token) } fn r#RepeatByte(&self, _arg_token: i8) -> binder::Result { self.0.r#RepeatByte(_arg_token) } fn r#RepeatChar(&self, _arg_token: u16) -> binder::Result { self.0.r#RepeatChar(_arg_token) } fn r#RepeatInt(&self, _arg_token: i32) -> binder::Result { self.0.r#RepeatInt(_arg_token) } fn r#RepeatLong(&self, _arg_token: i64) -> binder::Result { self.0.r#RepeatLong(_arg_token) } fn r#RepeatFloat(&self, _arg_token: f32) -> binder::Result { self.0.r#RepeatFloat(_arg_token) } fn r#RepeatDouble(&self, _arg_token: f64) -> binder::Result { self.0.r#RepeatDouble(_arg_token) } fn r#RepeatString(&self, _arg_token: &str) -> binder::Result { self.0.r#RepeatString(_arg_token) } fn r#RepeatByteEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum) -> binder::Result { self.0.r#RepeatByteEnum(_arg_token) } fn r#RepeatIntEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum) -> binder::Result { self.0.r#RepeatIntEnum(_arg_token) } fn r#RepeatLongEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum) -> binder::Result { self.0.r#RepeatLongEnum(_arg_token) } fn r#ReverseBoolean(&self, _arg_input: &[bool], _arg_repeated: &mut Vec) -> binder::Result> { self.0.r#ReverseBoolean(_arg_input, _arg_repeated) } fn r#ReverseByte(&self, _arg_input: &[u8], _arg_repeated: &mut Vec) -> binder::Result> { self.0.r#ReverseByte(_arg_input, _arg_repeated) } fn r#ReverseChar(&self, _arg_input: &[u16], _arg_repeated: &mut Vec) -> binder::Result> { self.0.r#ReverseChar(_arg_input, _arg_repeated) } fn r#ReverseInt(&self, _arg_input: &[i32], _arg_repeated: &mut Vec) -> binder::Result> { self.0.r#ReverseInt(_arg_input, _arg_repeated) } fn r#ReverseLong(&self, _arg_input: &[i64], _arg_repeated: &mut Vec) -> binder::Result> { self.0.r#ReverseLong(_arg_input, _arg_repeated) } fn r#ReverseFloat(&self, _arg_input: &[f32], _arg_repeated: &mut Vec) -> binder::Result> { self.0.r#ReverseFloat(_arg_input, _arg_repeated) } fn r#ReverseDouble(&self, _arg_input: &[f64], _arg_repeated: &mut Vec) -> binder::Result> { self.0.r#ReverseDouble(_arg_input, _arg_repeated) } fn r#ReverseString(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result> { self.0.r#ReverseString(_arg_input, _arg_repeated) } fn r#ReverseByteEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum], _arg_repeated: &mut Vec) -> binder::Result> { self.0.r#ReverseByteEnum(_arg_input, _arg_repeated) } fn r#ReverseIntEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum], _arg_repeated: &mut Vec) -> binder::Result> { self.0.r#ReverseIntEnum(_arg_input, _arg_repeated) } fn r#ReverseLongEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum], _arg_repeated: &mut Vec) -> binder::Result> { self.0.r#ReverseLongEnum(_arg_input, _arg_repeated) } fn r#GetOtherTestService(&self, _arg_name: &str) -> binder::Result> { self.0.r#GetOtherTestService(_arg_name) } fn r#SetOtherTestService(&self, _arg_name: &str, _arg_service: &binder::Strong) -> binder::Result { self.0.r#SetOtherTestService(_arg_name, _arg_service) } fn r#VerifyName(&self, _arg_service: &binder::Strong, _arg_name: &str) -> binder::Result { self.0.r#VerifyName(_arg_service, _arg_name) } fn r#GetInterfaceArray(&self, _arg_names: &[String]) -> binder::Result>> { self.0.r#GetInterfaceArray(_arg_names) } fn r#VerifyNamesWithInterfaceArray(&self, _arg_services: &[binder::Strong], _arg_names: &[String]) -> binder::Result { self.0.r#VerifyNamesWithInterfaceArray(_arg_services, _arg_names) } fn r#GetNullableInterfaceArray(&self, _arg_names: Option<&[Option]>) -> binder::Result>>>> { self.0.r#GetNullableInterfaceArray(_arg_names) } fn r#VerifyNamesWithNullableInterfaceArray(&self, _arg_services: Option<&[Option>]>, _arg_names: Option<&[Option]>) -> binder::Result { self.0.r#VerifyNamesWithNullableInterfaceArray(_arg_services, _arg_names) } fn r#GetInterfaceList(&self, _arg_names: Option<&[Option]>) -> binder::Result>>>> { self.0.r#GetInterfaceList(_arg_names) } fn r#VerifyNamesWithInterfaceList(&self, _arg_services: Option<&[Option>]>, _arg_names: Option<&[Option]>) -> binder::Result { self.0.r#VerifyNamesWithInterfaceList(_arg_services, _arg_names) } fn r#ReverseStringList(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result> { self.0.r#ReverseStringList(_arg_input, _arg_repeated) } fn r#RepeatParcelFileDescriptor(&self, _arg_read: &binder::ParcelFileDescriptor) -> binder::Result { self.0.r#RepeatParcelFileDescriptor(_arg_read) } fn r#ReverseParcelFileDescriptorArray(&self, _arg_input: &[binder::ParcelFileDescriptor], _arg_repeated: &mut Vec>) -> binder::Result> { self.0.r#ReverseParcelFileDescriptorArray(_arg_input, _arg_repeated) } fn r#ThrowServiceException(&self, _arg_code: i32) -> binder::Result<()> { self.0.r#ThrowServiceException(_arg_code) } fn r#RepeatNullableIntArray(&self, _arg_input: Option<&[i32]>) -> binder::Result>> { self.0.r#RepeatNullableIntArray(_arg_input) } fn r#RepeatNullableByteEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum]>) -> binder::Result>> { self.0.r#RepeatNullableByteEnumArray(_arg_input) } fn r#RepeatNullableIntEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum]>) -> binder::Result>> { self.0.r#RepeatNullableIntEnumArray(_arg_input) } fn r#RepeatNullableLongEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum]>) -> binder::Result>> { self.0.r#RepeatNullableLongEnumArray(_arg_input) } fn r#RepeatNullableString(&self, _arg_input: Option<&str>) -> binder::Result> { self.0.r#RepeatNullableString(_arg_input) } fn r#RepeatNullableStringList(&self, _arg_input: Option<&[Option]>) -> binder::Result>>> { self.0.r#RepeatNullableStringList(_arg_input) } fn r#RepeatNullableParcelable(&self, _arg_input: Option<&crate::mangled::_7_android_4_aidl_5_tests_12_ITestService_5_Empty>) -> binder::Result> { self.0.r#RepeatNullableParcelable(_arg_input) } fn r#RepeatNullableParcelableArray(&self, _arg_input: Option<&[Option]>) -> binder::Result>>> { self.0.r#RepeatNullableParcelableArray(_arg_input) } fn r#RepeatNullableParcelableList(&self, _arg_input: Option<&[Option]>) -> binder::Result>>> { self.0.r#RepeatNullableParcelableList(_arg_input) } fn r#TakesAnIBinder(&self, _arg_input: &binder::SpIBinder) -> binder::Result<()> { self.0.r#TakesAnIBinder(_arg_input) } fn r#TakesANullableIBinder(&self, _arg_input: Option<&binder::SpIBinder>) -> binder::Result<()> { self.0.r#TakesANullableIBinder(_arg_input) } fn r#TakesAnIBinderList(&self, _arg_input: &[binder::SpIBinder]) -> binder::Result<()> { self.0.r#TakesAnIBinderList(_arg_input) } fn r#TakesANullableIBinderList(&self, _arg_input: Option<&[Option]>) -> binder::Result<()> { self.0.r#TakesANullableIBinderList(_arg_input) } fn r#RepeatUtf8CppString(&self, _arg_token: &str) -> binder::Result { self.0.r#RepeatUtf8CppString(_arg_token) } fn r#RepeatNullableUtf8CppString(&self, _arg_token: Option<&str>) -> binder::Result> { self.0.r#RepeatNullableUtf8CppString(_arg_token) } fn r#ReverseUtf8CppString(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result> { self.0.r#ReverseUtf8CppString(_arg_input, _arg_repeated) } fn r#ReverseNullableUtf8CppString(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>> { self.0.r#ReverseNullableUtf8CppString(_arg_input, _arg_repeated) } fn r#ReverseUtf8CppStringList(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>> { self.0.r#ReverseUtf8CppStringList(_arg_input, _arg_repeated) } fn r#GetCallback(&self, _arg_return_null: bool) -> binder::Result>> { self.0.r#GetCallback(_arg_return_null) } fn r#FillOutStructuredParcelable(&self, _arg_parcel: &mut crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable) -> binder::Result<()> { self.0.r#FillOutStructuredParcelable(_arg_parcel) } fn r#RepeatExtendableParcelable(&self, _arg_ep: &crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable, _arg_ep2: &mut crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable) -> binder::Result<()> { self.0.r#RepeatExtendableParcelable(_arg_ep, _arg_ep2) } fn r#ReverseList(&self, _arg_list: &crate::mangled::_7_android_4_aidl_5_tests_13_RecursiveList) -> binder::Result { self.0.r#ReverseList(_arg_list) } fn r#ReverseIBinderArray(&self, _arg_input: &[binder::SpIBinder], _arg_repeated: &mut Vec>) -> binder::Result> { self.0.r#ReverseIBinderArray(_arg_input, _arg_repeated) } fn r#ReverseNullableIBinderArray(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>> { self.0.r#ReverseNullableIBinderArray(_arg_input, _arg_repeated) } fn r#RepeatSimpleParcelable(&self, _arg_input: &simple_parcelable::SimpleParcelable, _arg_repeat: &mut simple_parcelable::SimpleParcelable) -> binder::Result { self.0.r#RepeatSimpleParcelable(_arg_input, _arg_repeat) } fn r#ReverseSimpleParcelables(&self, _arg_input: &[simple_parcelable::SimpleParcelable], _arg_repeated: &mut Vec) -> binder::Result> { self.0.r#ReverseSimpleParcelables(_arg_input, _arg_repeated) } fn r#GetOldNameInterface(&self) -> binder::Result> { self.0.r#GetOldNameInterface() } fn r#GetNewNameInterface(&self) -> binder::Result> { self.0.r#GetNewNameInterface() } fn r#GetUnionTags(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_5_Union]) -> binder::Result> { self.0.r#GetUnionTags(_arg_input) } fn r#GetCppJavaTests(&self) -> binder::Result> { self.0.r#GetCppJavaTests() } fn r#getBackendType(&self) -> binder::Result { self.0.r#getBackendType() } fn r#GetCircular(&self, _arg_cp: &mut crate::mangled::_7_android_4_aidl_5_tests_18_CircularParcelable) -> binder::Result> { self.0.r#GetCircular(_arg_cp) } } fn on_transact(_aidl_service: &dyn ITestService, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#UnimplementedMethod => { let _arg_arg: i32 = _aidl_data.read()?; let _aidl_return = _aidl_service.r#UnimplementedMethod(_arg_arg); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#Deprecated => { let _aidl_return = _aidl_service.r#Deprecated(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#TestOneway => { let _aidl_return = _aidl_service.r#TestOneway(); Ok(()) } transactions::r#RepeatBoolean => { let _arg_token: bool = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatBoolean(_arg_token); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatByte => { let _arg_token: i8 = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatByte(_arg_token); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatChar => { let _arg_token: u16 = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatChar(_arg_token); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatInt => { let _arg_token: i32 = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatInt(_arg_token); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatLong => { let _arg_token: i64 = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatLong(_arg_token); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatFloat => { let _arg_token: f32 = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatFloat(_arg_token); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatDouble => { let _arg_token: f64 = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatDouble(_arg_token); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatString => { let _arg_token: String = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatString(&_arg_token); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatByteEnum => { let _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatByteEnum(_arg_token); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatIntEnum => { let _arg_token: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatIntEnum(_arg_token); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatLongEnum => { let _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatLongEnum(_arg_token); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseBoolean => { let _arg_input: Vec = _aidl_data.read()?; let mut _arg_repeated: Vec = Default::default(); _aidl_data.resize_out_vec(&mut _arg_repeated)?; let _aidl_return = _aidl_service.r#ReverseBoolean(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseByte => { let _arg_input: Vec = _aidl_data.read()?; let mut _arg_repeated: Vec = Default::default(); _aidl_data.resize_out_vec(&mut _arg_repeated)?; let _aidl_return = _aidl_service.r#ReverseByte(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseChar => { let _arg_input: Vec = _aidl_data.read()?; let mut _arg_repeated: Vec = Default::default(); _aidl_data.resize_out_vec(&mut _arg_repeated)?; let _aidl_return = _aidl_service.r#ReverseChar(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseInt => { let _arg_input: Vec = _aidl_data.read()?; let mut _arg_repeated: Vec = Default::default(); _aidl_data.resize_out_vec(&mut _arg_repeated)?; let _aidl_return = _aidl_service.r#ReverseInt(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseLong => { let _arg_input: Vec = _aidl_data.read()?; let mut _arg_repeated: Vec = Default::default(); _aidl_data.resize_out_vec(&mut _arg_repeated)?; let _aidl_return = _aidl_service.r#ReverseLong(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseFloat => { let _arg_input: Vec = _aidl_data.read()?; let mut _arg_repeated: Vec = Default::default(); _aidl_data.resize_out_vec(&mut _arg_repeated)?; let _aidl_return = _aidl_service.r#ReverseFloat(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseDouble => { let _arg_input: Vec = _aidl_data.read()?; let mut _arg_repeated: Vec = Default::default(); _aidl_data.resize_out_vec(&mut _arg_repeated)?; let _aidl_return = _aidl_service.r#ReverseDouble(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseString => { let _arg_input: Vec = _aidl_data.read()?; let mut _arg_repeated: Vec = Default::default(); _aidl_data.resize_out_vec(&mut _arg_repeated)?; let _aidl_return = _aidl_service.r#ReverseString(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseByteEnum => { let _arg_input: Vec = _aidl_data.read()?; let mut _arg_repeated: Vec = Default::default(); _aidl_data.resize_out_vec(&mut _arg_repeated)?; let _aidl_return = _aidl_service.r#ReverseByteEnum(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseIntEnum => { let _arg_input: Vec = _aidl_data.read()?; let mut _arg_repeated: Vec = Default::default(); _aidl_data.resize_out_vec(&mut _arg_repeated)?; let _aidl_return = _aidl_service.r#ReverseIntEnum(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseLongEnum => { let _arg_input: Vec = _aidl_data.read()?; let mut _arg_repeated: Vec = Default::default(); _aidl_data.resize_out_vec(&mut _arg_repeated)?; let _aidl_return = _aidl_service.r#ReverseLongEnum(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#GetOtherTestService => { let _arg_name: String = _aidl_data.read()?; let _aidl_return = _aidl_service.r#GetOtherTestService(&_arg_name); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#SetOtherTestService => { let _arg_name: String = _aidl_data.read()?; let _arg_service: binder::Strong = _aidl_data.read()?; let _aidl_return = _aidl_service.r#SetOtherTestService(&_arg_name, &_arg_service); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#VerifyName => { let _arg_service: binder::Strong = _aidl_data.read()?; let _arg_name: String = _aidl_data.read()?; let _aidl_return = _aidl_service.r#VerifyName(&_arg_service, &_arg_name); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#GetInterfaceArray => { let _arg_names: Vec = _aidl_data.read()?; let _aidl_return = _aidl_service.r#GetInterfaceArray(&_arg_names); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#VerifyNamesWithInterfaceArray => { let _arg_services: Vec> = _aidl_data.read()?; let _arg_names: Vec = _aidl_data.read()?; let _aidl_return = _aidl_service.r#VerifyNamesWithInterfaceArray(&_arg_services, &_arg_names); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#GetNullableInterfaceArray => { let _arg_names: Option>> = _aidl_data.read()?; let _aidl_return = _aidl_service.r#GetNullableInterfaceArray(_arg_names.as_deref()); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#VerifyNamesWithNullableInterfaceArray => { let _arg_services: Option>>> = _aidl_data.read()?; let _arg_names: Option>> = _aidl_data.read()?; let _aidl_return = _aidl_service.r#VerifyNamesWithNullableInterfaceArray(_arg_services.as_deref(), _arg_names.as_deref()); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#GetInterfaceList => { let _arg_names: Option>> = _aidl_data.read()?; let _aidl_return = _aidl_service.r#GetInterfaceList(_arg_names.as_deref()); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#VerifyNamesWithInterfaceList => { let _arg_services: Option>>> = _aidl_data.read()?; let _arg_names: Option>> = _aidl_data.read()?; let _aidl_return = _aidl_service.r#VerifyNamesWithInterfaceList(_arg_services.as_deref(), _arg_names.as_deref()); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseStringList => { let _arg_input: Vec = _aidl_data.read()?; let mut _arg_repeated: Vec = Default::default(); let _aidl_return = _aidl_service.r#ReverseStringList(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatParcelFileDescriptor => { let _arg_read: binder::ParcelFileDescriptor = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatParcelFileDescriptor(&_arg_read); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseParcelFileDescriptorArray => { let _arg_input: Vec = _aidl_data.read()?; let mut _arg_repeated: Vec> = Default::default(); _aidl_data.resize_out_vec(&mut _arg_repeated)?; let _aidl_return = _aidl_service.r#ReverseParcelFileDescriptorArray(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; if _arg_repeated.iter().any(Option::is_none) { return Err(binder::StatusCode::UNEXPECTED_NULL); } _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ThrowServiceException => { let _arg_code: i32 = _aidl_data.read()?; let _aidl_return = _aidl_service.r#ThrowServiceException(_arg_code); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatNullableIntArray => { let _arg_input: Option> = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatNullableIntArray(_arg_input.as_deref()); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatNullableByteEnumArray => { let _arg_input: Option> = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatNullableByteEnumArray(_arg_input.as_deref()); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatNullableIntEnumArray => { let _arg_input: Option> = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatNullableIntEnumArray(_arg_input.as_deref()); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatNullableLongEnumArray => { let _arg_input: Option> = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatNullableLongEnumArray(_arg_input.as_deref()); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatNullableString => { let _arg_input: Option = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatNullableString(_arg_input.as_deref()); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatNullableStringList => { let _arg_input: Option>> = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatNullableStringList(_arg_input.as_deref()); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatNullableParcelable => { let _arg_input: Option = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatNullableParcelable(_arg_input.as_ref()); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatNullableParcelableArray => { let _arg_input: Option>> = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatNullableParcelableArray(_arg_input.as_deref()); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatNullableParcelableList => { let _arg_input: Option>> = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatNullableParcelableList(_arg_input.as_deref()); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#TakesAnIBinder => { let _arg_input: binder::SpIBinder = _aidl_data.read()?; let _aidl_return = _aidl_service.r#TakesAnIBinder(&_arg_input); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#TakesANullableIBinder => { let _arg_input: Option = _aidl_data.read()?; let _aidl_return = _aidl_service.r#TakesANullableIBinder(_arg_input.as_ref()); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#TakesAnIBinderList => { let _arg_input: Vec = _aidl_data.read()?; let _aidl_return = _aidl_service.r#TakesAnIBinderList(&_arg_input); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#TakesANullableIBinderList => { let _arg_input: Option>> = _aidl_data.read()?; let _aidl_return = _aidl_service.r#TakesANullableIBinderList(_arg_input.as_deref()); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatUtf8CppString => { let _arg_token: String = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatUtf8CppString(&_arg_token); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatNullableUtf8CppString => { let _arg_token: Option = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatNullableUtf8CppString(_arg_token.as_deref()); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseUtf8CppString => { let _arg_input: Vec = _aidl_data.read()?; let mut _arg_repeated: Vec = Default::default(); _aidl_data.resize_out_vec(&mut _arg_repeated)?; let _aidl_return = _aidl_service.r#ReverseUtf8CppString(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseNullableUtf8CppString => { let _arg_input: Option>> = _aidl_data.read()?; let mut _arg_repeated: Option>> = Default::default(); _aidl_data.resize_nullable_out_vec(&mut _arg_repeated)?; let _aidl_return = _aidl_service.r#ReverseNullableUtf8CppString(_arg_input.as_deref(), &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseUtf8CppStringList => { let _arg_input: Option>> = _aidl_data.read()?; let mut _arg_repeated: Option>> = Default::default(); let _aidl_return = _aidl_service.r#ReverseUtf8CppStringList(_arg_input.as_deref(), &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#GetCallback => { let _arg_return_null: bool = _aidl_data.read()?; let _aidl_return = _aidl_service.r#GetCallback(_arg_return_null); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#FillOutStructuredParcelable => { let mut _arg_parcel: crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable = _aidl_data.read()?; let _aidl_return = _aidl_service.r#FillOutStructuredParcelable(&mut _arg_parcel); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(&_arg_parcel)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatExtendableParcelable => { let _arg_ep: crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable = _aidl_data.read()?; let mut _arg_ep2: crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable = Default::default(); let _aidl_return = _aidl_service.r#RepeatExtendableParcelable(&_arg_ep, &mut _arg_ep2); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(&_arg_ep2)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseList => { let _arg_list: crate::mangled::_7_android_4_aidl_5_tests_13_RecursiveList = _aidl_data.read()?; let _aidl_return = _aidl_service.r#ReverseList(&_arg_list); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseIBinderArray => { let _arg_input: Vec = _aidl_data.read()?; let mut _arg_repeated: Vec> = Default::default(); _aidl_data.resize_out_vec(&mut _arg_repeated)?; let _aidl_return = _aidl_service.r#ReverseIBinderArray(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseNullableIBinderArray => { let _arg_input: Option>> = _aidl_data.read()?; let mut _arg_repeated: Option>> = Default::default(); _aidl_data.resize_nullable_out_vec(&mut _arg_repeated)?; let _aidl_return = _aidl_service.r#ReverseNullableIBinderArray(_arg_input.as_deref(), &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatSimpleParcelable => { let _arg_input: simple_parcelable::SimpleParcelable = _aidl_data.read()?; let mut _arg_repeat: simple_parcelable::SimpleParcelable = Default::default(); let _aidl_return = _aidl_service.r#RepeatSimpleParcelable(&_arg_input, &mut _arg_repeat); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeat)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseSimpleParcelables => { let _arg_input: Vec = _aidl_data.read()?; let mut _arg_repeated: Vec = Default::default(); _aidl_data.resize_out_vec(&mut _arg_repeated)?; let _aidl_return = _aidl_service.r#ReverseSimpleParcelables(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#GetOldNameInterface => { let _aidl_return = _aidl_service.r#GetOldNameInterface(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#GetNewNameInterface => { let _aidl_return = _aidl_service.r#GetNewNameInterface(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#GetUnionTags => { let _arg_input: Vec = _aidl_data.read()?; let _aidl_return = _aidl_service.r#GetUnionTags(&_arg_input); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#GetCppJavaTests => { let _aidl_return = _aidl_service.r#GetCppJavaTests(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#getBackendType => { let _aidl_return = _aidl_service.r#getBackendType(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#GetCircular => { let mut _arg_cp: crate::mangled::_7_android_4_aidl_5_tests_18_CircularParcelable = Default::default(); let _aidl_return = _aidl_service.r#GetCircular(&mut _arg_cp); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_cp)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } pub mod r#Empty { #[derive(Debug, Clone, PartialEq)] pub struct r#Empty { } impl Default for r#Empty { fn default() -> Self { Self { } } } impl binder::Parcelable for r#Empty { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#Empty); binder::impl_deserialize_for_parcelable!(r#Empty); impl binder::binder_impl::ParcelableMetadata for r#Empty { fn get_descriptor() -> &'static str { "android.aidl.tests.ITestService.Empty" } } } pub mod r#CompilerChecks { #[derive(Debug)] pub struct r#CompilerChecks { pub r#binder: Option, pub r#nullable_binder: Option, pub r#binder_array: Vec, pub r#nullable_binder_array: Option>>, pub r#binder_list: Vec, pub r#nullable_binder_list: Option>>, pub r#pfd: Option, pub r#nullable_pfd: Option, pub r#pfd_array: Vec, pub r#nullable_pfd_array: Option>>, pub r#pfd_list: Vec, pub r#nullable_pfd_list: Option>>, pub r#parcel: crate::mangled::_7_android_4_aidl_5_tests_12_ITestService_5_Empty, pub r#nullable_parcel: Option, pub r#parcel_array: Vec, pub r#nullable_parcel_array: Option>>, pub r#parcel_list: Vec, pub r#nullable_parcel_list: Option>>, } impl Default for r#CompilerChecks { fn default() -> Self { Self { r#binder: Default::default(), r#nullable_binder: Default::default(), r#binder_array: Default::default(), r#nullable_binder_array: Default::default(), r#binder_list: Default::default(), r#nullable_binder_list: Default::default(), r#pfd: Default::default(), r#nullable_pfd: Default::default(), r#pfd_array: Default::default(), r#nullable_pfd_array: Default::default(), r#pfd_list: Default::default(), r#nullable_pfd_list: Default::default(), r#parcel: Default::default(), r#nullable_parcel: Default::default(), r#parcel_array: Default::default(), r#nullable_parcel_array: Default::default(), r#parcel_list: Default::default(), r#nullable_parcel_list: Default::default(), } } } impl binder::Parcelable for r#CompilerChecks { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { let __field_ref = self.r#binder.as_ref().ok_or(binder::StatusCode::UNEXPECTED_NULL)?; subparcel.write(__field_ref)?; subparcel.write(&self.r#nullable_binder)?; subparcel.write(&self.r#binder_array)?; subparcel.write(&self.r#nullable_binder_array)?; subparcel.write(&self.r#binder_list)?; subparcel.write(&self.r#nullable_binder_list)?; let __field_ref = self.r#pfd.as_ref().ok_or(binder::StatusCode::UNEXPECTED_NULL)?; subparcel.write(__field_ref)?; subparcel.write(&self.r#nullable_pfd)?; subparcel.write(&self.r#pfd_array)?; subparcel.write(&self.r#nullable_pfd_array)?; subparcel.write(&self.r#pfd_list)?; subparcel.write(&self.r#nullable_pfd_list)?; subparcel.write(&self.r#parcel)?; subparcel.write(&self.r#nullable_parcel)?; subparcel.write(&self.r#parcel_array)?; subparcel.write(&self.r#nullable_parcel_array)?; subparcel.write(&self.r#parcel_list)?; subparcel.write(&self.r#nullable_parcel_list)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#binder = Some(subparcel.read()?); } if subparcel.has_more_data() { self.r#nullable_binder = subparcel.read()?; } if subparcel.has_more_data() { self.r#binder_array = subparcel.read()?; } if subparcel.has_more_data() { self.r#nullable_binder_array = subparcel.read()?; } if subparcel.has_more_data() { self.r#binder_list = subparcel.read()?; } if subparcel.has_more_data() { self.r#nullable_binder_list = subparcel.read()?; } if subparcel.has_more_data() { self.r#pfd = Some(subparcel.read()?); } if subparcel.has_more_data() { self.r#nullable_pfd = subparcel.read()?; } if subparcel.has_more_data() { self.r#pfd_array = subparcel.read()?; } if subparcel.has_more_data() { self.r#nullable_pfd_array = subparcel.read()?; } if subparcel.has_more_data() { self.r#pfd_list = subparcel.read()?; } if subparcel.has_more_data() { self.r#nullable_pfd_list = subparcel.read()?; } if subparcel.has_more_data() { self.r#parcel = subparcel.read()?; } if subparcel.has_more_data() { self.r#nullable_parcel = subparcel.read()?; } if subparcel.has_more_data() { self.r#parcel_array = subparcel.read()?; } if subparcel.has_more_data() { self.r#nullable_parcel_array = subparcel.read()?; } if subparcel.has_more_data() { self.r#parcel_list = subparcel.read()?; } if subparcel.has_more_data() { self.r#nullable_parcel_list = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#CompilerChecks); binder::impl_deserialize_for_parcelable!(r#CompilerChecks); impl binder::binder_impl::ParcelableMetadata for r#CompilerChecks { fn get_descriptor() -> &'static str { "android.aidl.tests.ITestService.CompilerChecks" } } pub mod r#Foo { #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { IFoo["android.aidl.tests.ITestService.CompilerChecks.Foo"] { native: BnFoo(on_transact), proxy: BpFoo { }, async: IFooAsync, } } pub trait IFoo: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ITestService.CompilerChecks.Foo" } fn getDefaultImpl() -> IFooDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: IFooDefaultRef) -> IFooDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait IFooAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ITestService.CompilerChecks.Foo" } } #[::async_trait::async_trait] pub trait IFooAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ITestService.CompilerChecks.Foo" } } impl BnFoo { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: IFooAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl IFoo for Wrapper where T: IFooAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait IFooDefault: Send + Sync { } pub mod transactions { } pub type IFooDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); impl BpFoo { } impl IFoo for BpFoo { } impl IFooAsync

for BpFoo { } impl IFoo for binder::binder_impl::Binder { } fn on_transact(_aidl_service: &dyn IFoo, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } } pub mod r#HasDeprecated { #[derive(Debug)] pub struct r#HasDeprecated { #[deprecated = "field"] pub r#deprecated: i32, } impl Default for r#HasDeprecated { fn default() -> Self { Self { r#deprecated: 0, } } } impl binder::Parcelable for r#HasDeprecated { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#deprecated)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#deprecated = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#HasDeprecated); binder::impl_deserialize_for_parcelable!(r#HasDeprecated); impl binder::binder_impl::ParcelableMetadata for r#HasDeprecated { fn get_descriptor() -> &'static str { "android.aidl.tests.ITestService.CompilerChecks.HasDeprecated" } } } pub mod r#UsingHasDeprecated { #[derive(Debug)] pub enum r#UsingHasDeprecated { N(i32), M(crate::mangled::_7_android_4_aidl_5_tests_12_ITestService_14_CompilerChecks_13_HasDeprecated), } impl Default for r#UsingHasDeprecated { fn default() -> Self { Self::N(0) } } impl binder::Parcelable for r#UsingHasDeprecated { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { match self { Self::N(v) => { parcel.write(&0i32)?; parcel.write(v) } Self::M(v) => { parcel.write(&1i32)?; parcel.write(v) } } } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { let tag: i32 = parcel.read()?; match tag { 0 => { let value: i32 = parcel.read()?; *self = Self::N(value); Ok(()) } 1 => { let value: crate::mangled::_7_android_4_aidl_5_tests_12_ITestService_14_CompilerChecks_13_HasDeprecated = parcel.read()?; *self = Self::M(value); Ok(()) } _ => { Err(binder::StatusCode::BAD_VALUE) } } } } binder::impl_serialize_for_parcelable!(r#UsingHasDeprecated); binder::impl_deserialize_for_parcelable!(r#UsingHasDeprecated); impl binder::binder_impl::ParcelableMetadata for r#UsingHasDeprecated { fn get_descriptor() -> &'static str { "android.aidl.tests.ITestService.CompilerChecks.UsingHasDeprecated" } } pub mod r#Tag { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#Tag : [i32; 2] { r#n = 0, r#m = 1, } } } } pub mod r#NoPrefixInterface { #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { INoPrefixInterface["android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface"] { native: BnNoPrefixInterface(on_transact), proxy: BpNoPrefixInterface { }, async: INoPrefixInterfaceAsync, } } pub trait INoPrefixInterface: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface" } fn r#foo(&self) -> binder::Result<()>; fn getDefaultImpl() -> INoPrefixInterfaceDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: INoPrefixInterfaceDefaultRef) -> INoPrefixInterfaceDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait INoPrefixInterfaceAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface" } fn r#foo<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result<()>>; } #[::async_trait::async_trait] pub trait INoPrefixInterfaceAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface" } async fn r#foo(&self) -> binder::Result<()>; } impl BnNoPrefixInterface { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: INoPrefixInterfaceAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl INoPrefixInterface for Wrapper where T: INoPrefixInterfaceAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#foo(&self) -> binder::Result<()> { self._rt.block_on(self._inner.r#foo()) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait INoPrefixInterfaceDefault: Send + Sync { fn r#foo(&self) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#foo: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; } pub type INoPrefixInterfaceDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); impl BpNoPrefixInterface { fn build_parcel_foo(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_foo(&self, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#foo(); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } Ok(()) } } impl INoPrefixInterface for BpNoPrefixInterface { fn r#foo(&self) -> binder::Result<()> { let _aidl_data = self.build_parcel_foo()?; let _aidl_reply = self.binder.submit_transact(transactions::r#foo, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_foo(_aidl_reply) } } impl INoPrefixInterfaceAsync

for BpNoPrefixInterface { fn r#foo<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_foo() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#foo, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_foo(_aidl_reply) } ) } } impl INoPrefixInterface for binder::binder_impl::Binder { fn r#foo(&self) -> binder::Result<()> { self.0.r#foo() } } fn on_transact(_aidl_service: &dyn INoPrefixInterface, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#foo => { let _aidl_return = _aidl_service.r#foo(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } pub mod r#Nested { #[derive(Debug)] pub struct r#Nested { } impl Default for r#Nested { fn default() -> Self { Self { } } } impl binder::Parcelable for r#Nested { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#Nested); binder::impl_deserialize_for_parcelable!(r#Nested); impl binder::binder_impl::ParcelableMetadata for r#Nested { fn get_descriptor() -> &'static str { "android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.Nested" } } } pub mod r#NestedNoPrefixInterface { #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { INestedNoPrefixInterface["android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.NestedNoPrefixInterface"] { native: BnNestedNoPrefixInterface(on_transact), proxy: BpNestedNoPrefixInterface { }, async: INestedNoPrefixInterfaceAsync, } } pub trait INestedNoPrefixInterface: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.NestedNoPrefixInterface" } fn r#foo(&self) -> binder::Result<()>; fn getDefaultImpl() -> INestedNoPrefixInterfaceDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: INestedNoPrefixInterfaceDefaultRef) -> INestedNoPrefixInterfaceDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait INestedNoPrefixInterfaceAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.NestedNoPrefixInterface" } fn r#foo<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result<()>>; } #[::async_trait::async_trait] pub trait INestedNoPrefixInterfaceAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.NestedNoPrefixInterface" } async fn r#foo(&self) -> binder::Result<()>; } impl BnNestedNoPrefixInterface { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: INestedNoPrefixInterfaceAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl INestedNoPrefixInterface for Wrapper where T: INestedNoPrefixInterfaceAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#foo(&self) -> binder::Result<()> { self._rt.block_on(self._inner.r#foo()) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait INestedNoPrefixInterfaceDefault: Send + Sync { fn r#foo(&self) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#foo: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; } pub type INestedNoPrefixInterfaceDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); impl BpNestedNoPrefixInterface { fn build_parcel_foo(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_foo(&self, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#foo(); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } Ok(()) } } impl INestedNoPrefixInterface for BpNestedNoPrefixInterface { fn r#foo(&self) -> binder::Result<()> { let _aidl_data = self.build_parcel_foo()?; let _aidl_reply = self.binder.submit_transact(transactions::r#foo, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_foo(_aidl_reply) } } impl INestedNoPrefixInterfaceAsync

for BpNestedNoPrefixInterface { fn r#foo<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_foo() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#foo, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_foo(_aidl_reply) } ) } } impl INestedNoPrefixInterface for binder::binder_impl::Binder { fn r#foo(&self) -> binder::Result<()> { self.0.r#foo() } } fn on_transact(_aidl_service: &dyn INestedNoPrefixInterface, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#foo => { let _aidl_return = _aidl_service.r#foo(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } } } } pub(crate) mod mangled { pub use super::r#ITestService as _7_android_4_aidl_5_tests_12_ITestService; pub use super::r#Empty::r#Empty as _7_android_4_aidl_5_tests_12_ITestService_5_Empty; pub use super::r#CompilerChecks::r#CompilerChecks as _7_android_4_aidl_5_tests_12_ITestService_14_CompilerChecks; pub use super::r#CompilerChecks::r#Foo::r#IFoo as _7_android_4_aidl_5_tests_12_ITestService_14_CompilerChecks_3_Foo; pub use super::r#CompilerChecks::r#HasDeprecated::r#HasDeprecated as _7_android_4_aidl_5_tests_12_ITestService_14_CompilerChecks_13_HasDeprecated; pub use super::r#CompilerChecks::r#UsingHasDeprecated::r#UsingHasDeprecated as _7_android_4_aidl_5_tests_12_ITestService_14_CompilerChecks_18_UsingHasDeprecated; pub use super::r#CompilerChecks::r#UsingHasDeprecated::r#Tag::r#Tag as _7_android_4_aidl_5_tests_12_ITestService_14_CompilerChecks_18_UsingHasDeprecated_3_Tag; pub use super::r#CompilerChecks::r#NoPrefixInterface::r#INoPrefixInterface as _7_android_4_aidl_5_tests_12_ITestService_14_CompilerChecks_17_NoPrefixInterface; pub use super::r#CompilerChecks::r#NoPrefixInterface::r#Nested::r#Nested as _7_android_4_aidl_5_tests_12_ITestService_14_CompilerChecks_17_NoPrefixInterface_6_Nested; pub use super::r#CompilerChecks::r#NoPrefixInterface::r#NestedNoPrefixInterface::r#INestedNoPrefixInterface as _7_android_4_aidl_5_tests_12_ITestService_14_CompilerChecks_17_NoPrefixInterface_23_NestedNoPrefixInterface; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_ITestServ0100644 0000000 0000000 00000000034 15172120304 033242 xustar000000000 0000000 28 mtime=1776853188.4930000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/ITestService.rs.d0100644 0000000 0000000 00000002225 15172120304 031355 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/ITestService.rs : \ system/tools/aidl/tests/android/aidl/tests/ITestService.aidl \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ICircular.aidl \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl \ system/tools/aidl/tests/android/aidl/tests/SimpleParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_IntEnum.r0100644 0000000 0000000 00000000034 15172120304 033171 xustar000000000 0000000 28 mtime=1776853188.4930000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/IntEnum.rs0100644 0000000 0000000 00000001531 15172120304 030140 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/IntEnum.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#IntEnum : [i32; 4] { r#FOO = 1000, r#BAR = 2000, r#BAZ = 2001, #[deprecated = "do not use this"] r#QUX = 2002, } } pub(crate) mod mangled { pub use super::r#IntEnum as _7_android_4_aidl_5_tests_7_IntEnum; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_IntEnum.r0100644 0000000 0000000 00000000034 15172120304 033171 xustar000000000 0000000 28 mtime=1776853188.4940000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/IntEnum.rs.d0100644 0000000 0000000 00000000253 15172120304 030362 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/IntEnum.rs : \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_ListOfInt0100644 0000000 0000000 00000000034 15172120304 033225 xustar000000000 0000000 28 mtime=1776853188.4940000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/ListOfInterfaces.rs0100644 0000000 0000000 00000100321 15172120304 031762 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/ListOfInterfaces.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ListOfInterfaces.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub struct r#ListOfInterfaces { } impl Default for r#ListOfInterfaces { fn default() -> Self { Self { } } } impl binder::Parcelable for r#ListOfInterfaces { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#ListOfInterfaces); binder::impl_deserialize_for_parcelable!(r#ListOfInterfaces); impl binder::binder_impl::ParcelableMetadata for r#ListOfInterfaces { fn get_descriptor() -> &'static str { "android.aidl.tests.ListOfInterfaces" } } pub mod r#IEmptyInterface { #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { IEmptyInterface["android.aidl.tests.ListOfInterfaces.IEmptyInterface"] { native: BnEmptyInterface(on_transact), proxy: BpEmptyInterface { }, async: IEmptyInterfaceAsync, } } pub trait IEmptyInterface: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ListOfInterfaces.IEmptyInterface" } fn getDefaultImpl() -> IEmptyInterfaceDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: IEmptyInterfaceDefaultRef) -> IEmptyInterfaceDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait IEmptyInterfaceAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ListOfInterfaces.IEmptyInterface" } } #[::async_trait::async_trait] pub trait IEmptyInterfaceAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ListOfInterfaces.IEmptyInterface" } } impl BnEmptyInterface { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: IEmptyInterfaceAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl IEmptyInterface for Wrapper where T: IEmptyInterfaceAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait IEmptyInterfaceDefault: Send + Sync { } pub mod transactions { } pub type IEmptyInterfaceDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); impl BpEmptyInterface { } impl IEmptyInterface for BpEmptyInterface { } impl IEmptyInterfaceAsync

for BpEmptyInterface { } impl IEmptyInterface for binder::binder_impl::Binder { } fn on_transact(_aidl_service: &dyn IEmptyInterface, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } } pub mod r#IMyInterface { #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { IMyInterface["android.aidl.tests.ListOfInterfaces.IMyInterface"] { native: BnMyInterface(on_transact), proxy: BpMyInterface { }, async: IMyInterfaceAsync, } } pub trait IMyInterface: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ListOfInterfaces.IMyInterface" } fn r#methodWithInterfaces(&self, _arg_iface: &binder::Strong, _arg_nullable_iface: Option<&binder::Strong>, _arg_iface_list_in: &[binder::Strong], _arg_iface_list_out: &mut Vec>>, _arg_iface_list_inout: &mut Vec>, _arg_nullable_iface_list_in: Option<&[Option>]>, _arg_nullable_iface_list_out: &mut Option>>>, _arg_nullable_iface_list_inout: &mut Option>>>) -> binder::Result>>>>; fn getDefaultImpl() -> IMyInterfaceDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: IMyInterfaceDefaultRef) -> IMyInterfaceDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait IMyInterfaceAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ListOfInterfaces.IMyInterface" } fn r#methodWithInterfaces<'a>(&'a self, _arg_iface: &'a binder::Strong, _arg_nullable_iface: Option<&'a binder::Strong>, _arg_iface_list_in: &'a [binder::Strong], _arg_iface_list_out: &'a mut Vec>>, _arg_iface_list_inout: &'a mut Vec>, _arg_nullable_iface_list_in: Option<&'a [Option>]>, _arg_nullable_iface_list_out: &'a mut Option>>>, _arg_nullable_iface_list_inout: &'a mut Option>>>) -> binder::BoxFuture<'a, binder::Result>>>>>; } #[::async_trait::async_trait] pub trait IMyInterfaceAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ListOfInterfaces.IMyInterface" } async fn r#methodWithInterfaces(&self, _arg_iface: &binder::Strong, _arg_nullable_iface: Option<&binder::Strong>, _arg_iface_list_in: &[binder::Strong], _arg_iface_list_out: &mut Vec>>, _arg_iface_list_inout: &mut Vec>, _arg_nullable_iface_list_in: Option<&[Option>]>, _arg_nullable_iface_list_out: &mut Option>>>, _arg_nullable_iface_list_inout: &mut Option>>>) -> binder::Result>>>>; } impl BnMyInterface { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: IMyInterfaceAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl IMyInterface for Wrapper where T: IMyInterfaceAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#methodWithInterfaces(&self, _arg_iface: &binder::Strong, _arg_nullable_iface: Option<&binder::Strong>, _arg_iface_list_in: &[binder::Strong], _arg_iface_list_out: &mut Vec>>, _arg_iface_list_inout: &mut Vec>, _arg_nullable_iface_list_in: Option<&[Option>]>, _arg_nullable_iface_list_out: &mut Option>>>, _arg_nullable_iface_list_inout: &mut Option>>>) -> binder::Result>>>> { self._rt.block_on(self._inner.r#methodWithInterfaces(_arg_iface, _arg_nullable_iface, _arg_iface_list_in, _arg_iface_list_out, _arg_iface_list_inout, _arg_nullable_iface_list_in, _arg_nullable_iface_list_out, _arg_nullable_iface_list_inout)) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait IMyInterfaceDefault: Send + Sync { fn r#methodWithInterfaces(&self, _arg_iface: &binder::Strong, _arg_nullable_iface: Option<&binder::Strong>, _arg_iface_list_in: &[binder::Strong], _arg_iface_list_out: &mut Vec>>, _arg_iface_list_inout: &mut Vec>, _arg_nullable_iface_list_in: Option<&[Option>]>, _arg_nullable_iface_list_out: &mut Option>>>, _arg_nullable_iface_list_inout: &mut Option>>>) -> binder::Result>>>> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#methodWithInterfaces: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; } pub type IMyInterfaceDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); impl BpMyInterface { fn build_parcel_methodWithInterfaces(&self, _arg_iface: &binder::Strong, _arg_nullable_iface: Option<&binder::Strong>, _arg_iface_list_in: &[binder::Strong], _arg_iface_list_out: &mut Vec>>, _arg_iface_list_inout: &mut Vec>, _arg_nullable_iface_list_in: Option<&[Option>]>, _arg_nullable_iface_list_out: &mut Option>>>, _arg_nullable_iface_list_inout: &mut Option>>>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_iface)?; aidl_data.write(&_arg_nullable_iface)?; aidl_data.write(_arg_iface_list_in)?; aidl_data.write(_arg_iface_list_inout)?; aidl_data.write(&_arg_nullable_iface_list_in)?; aidl_data.write(_arg_nullable_iface_list_inout)?; Ok(aidl_data) } fn read_response_methodWithInterfaces(&self, _arg_iface: &binder::Strong, _arg_nullable_iface: Option<&binder::Strong>, _arg_iface_list_in: &[binder::Strong], _arg_iface_list_out: &mut Vec>>, _arg_iface_list_inout: &mut Vec>, _arg_nullable_iface_list_in: Option<&[Option>]>, _arg_nullable_iface_list_out: &mut Option>>>, _arg_nullable_iface_list_inout: &mut Option>>>, _aidl_reply: std::result::Result) -> binder::Result>>>> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#methodWithInterfaces(_arg_iface, _arg_nullable_iface, _arg_iface_list_in, _arg_iface_list_out, _arg_iface_list_inout, _arg_nullable_iface_list_in, _arg_nullable_iface_list_out, _arg_nullable_iface_list_inout); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option>>> = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_iface_list_out)?; _aidl_reply.read_onto(_arg_iface_list_inout)?; _aidl_reply.read_onto(_arg_nullable_iface_list_out)?; _aidl_reply.read_onto(_arg_nullable_iface_list_inout)?; Ok(_aidl_return) } } impl IMyInterface for BpMyInterface { fn r#methodWithInterfaces(&self, _arg_iface: &binder::Strong, _arg_nullable_iface: Option<&binder::Strong>, _arg_iface_list_in: &[binder::Strong], _arg_iface_list_out: &mut Vec>>, _arg_iface_list_inout: &mut Vec>, _arg_nullable_iface_list_in: Option<&[Option>]>, _arg_nullable_iface_list_out: &mut Option>>>, _arg_nullable_iface_list_inout: &mut Option>>>) -> binder::Result>>>> { let _aidl_data = self.build_parcel_methodWithInterfaces(_arg_iface, _arg_nullable_iface, _arg_iface_list_in, _arg_iface_list_out, _arg_iface_list_inout, _arg_nullable_iface_list_in, _arg_nullable_iface_list_out, _arg_nullable_iface_list_inout)?; let _aidl_reply = self.binder.submit_transact(transactions::r#methodWithInterfaces, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_methodWithInterfaces(_arg_iface, _arg_nullable_iface, _arg_iface_list_in, _arg_iface_list_out, _arg_iface_list_inout, _arg_nullable_iface_list_in, _arg_nullable_iface_list_out, _arg_nullable_iface_list_inout, _aidl_reply) } } impl IMyInterfaceAsync

for BpMyInterface { fn r#methodWithInterfaces<'a>(&'a self, _arg_iface: &'a binder::Strong, _arg_nullable_iface: Option<&'a binder::Strong>, _arg_iface_list_in: &'a [binder::Strong], _arg_iface_list_out: &'a mut Vec>>, _arg_iface_list_inout: &'a mut Vec>, _arg_nullable_iface_list_in: Option<&'a [Option>]>, _arg_nullable_iface_list_out: &'a mut Option>>>, _arg_nullable_iface_list_inout: &'a mut Option>>>) -> binder::BoxFuture<'a, binder::Result>>>>> { let _aidl_data = match self.build_parcel_methodWithInterfaces(_arg_iface, _arg_nullable_iface, _arg_iface_list_in, _arg_iface_list_out, _arg_iface_list_inout, _arg_nullable_iface_list_in, _arg_nullable_iface_list_out, _arg_nullable_iface_list_inout) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#methodWithInterfaces, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_methodWithInterfaces(_arg_iface, _arg_nullable_iface, _arg_iface_list_in, _arg_iface_list_out, _arg_iface_list_inout, _arg_nullable_iface_list_in, _arg_nullable_iface_list_out, _arg_nullable_iface_list_inout, _aidl_reply) } ) } } impl IMyInterface for binder::binder_impl::Binder { fn r#methodWithInterfaces(&self, _arg_iface: &binder::Strong, _arg_nullable_iface: Option<&binder::Strong>, _arg_iface_list_in: &[binder::Strong], _arg_iface_list_out: &mut Vec>>, _arg_iface_list_inout: &mut Vec>, _arg_nullable_iface_list_in: Option<&[Option>]>, _arg_nullable_iface_list_out: &mut Option>>>, _arg_nullable_iface_list_inout: &mut Option>>>) -> binder::Result>>>> { self.0.r#methodWithInterfaces(_arg_iface, _arg_nullable_iface, _arg_iface_list_in, _arg_iface_list_out, _arg_iface_list_inout, _arg_nullable_iface_list_in, _arg_nullable_iface_list_out, _arg_nullable_iface_list_inout) } } fn on_transact(_aidl_service: &dyn IMyInterface, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#methodWithInterfaces => { let _arg_iface: binder::Strong = _aidl_data.read()?; let _arg_nullable_iface: Option> = _aidl_data.read()?; let _arg_iface_list_in: Vec> = _aidl_data.read()?; let mut _arg_iface_list_out: Vec>> = Default::default(); let mut _arg_iface_list_inout: Vec> = _aidl_data.read()?; let _arg_nullable_iface_list_in: Option>>> = _aidl_data.read()?; let mut _arg_nullable_iface_list_out: Option>>> = Default::default(); let mut _arg_nullable_iface_list_inout: Option>>> = _aidl_data.read()?; let _aidl_return = _aidl_service.r#methodWithInterfaces(&_arg_iface, _arg_nullable_iface.as_ref(), &_arg_iface_list_in, &mut _arg_iface_list_out, &mut _arg_iface_list_inout, _arg_nullable_iface_list_in.as_deref(), &mut _arg_nullable_iface_list_out, &mut _arg_nullable_iface_list_inout); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_iface_list_out)?; _aidl_reply.write(&_arg_iface_list_inout)?; _aidl_reply.write(&_arg_nullable_iface_list_out)?; _aidl_reply.write(&_arg_nullable_iface_list_inout)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } } pub mod r#MyParcelable { #[derive(Debug)] pub struct r#MyParcelable { pub r#iface: Option>, pub r#nullable_iface: Option>, pub r#iface_list: Vec>, pub r#nullable_iface_list: Option>>>, } impl Default for r#MyParcelable { fn default() -> Self { Self { r#iface: Default::default(), r#nullable_iface: Default::default(), r#iface_list: Default::default(), r#nullable_iface_list: Default::default(), } } } impl binder::Parcelable for r#MyParcelable { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { let __field_ref = self.r#iface.as_ref().ok_or(binder::StatusCode::UNEXPECTED_NULL)?; subparcel.write(__field_ref)?; subparcel.write(&self.r#nullable_iface)?; subparcel.write(&self.r#iface_list)?; subparcel.write(&self.r#nullable_iface_list)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#iface = Some(subparcel.read()?); } if subparcel.has_more_data() { self.r#nullable_iface = subparcel.read()?; } if subparcel.has_more_data() { self.r#iface_list = subparcel.read()?; } if subparcel.has_more_data() { self.r#nullable_iface_list = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#MyParcelable); binder::impl_deserialize_for_parcelable!(r#MyParcelable); impl binder::binder_impl::ParcelableMetadata for r#MyParcelable { fn get_descriptor() -> &'static str { "android.aidl.tests.ListOfInterfaces.MyParcelable" } } } pub mod r#MyUnion { #[derive(Debug)] pub enum r#MyUnion { Iface(Option>), Nullable_iface(Option>), Iface_list(Vec>), Nullable_iface_list(Option>>>), } impl Default for r#MyUnion { fn default() -> Self { Self::Iface(Default::default()) } } impl binder::Parcelable for r#MyUnion { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { match self { Self::Iface(v) => { parcel.write(&0i32)?; let __field_ref = v.as_ref().ok_or(binder::StatusCode::UNEXPECTED_NULL)?; parcel.write(__field_ref) } Self::Nullable_iface(v) => { parcel.write(&1i32)?; parcel.write(v) } Self::Iface_list(v) => { parcel.write(&2i32)?; parcel.write(v) } Self::Nullable_iface_list(v) => { parcel.write(&3i32)?; parcel.write(v) } } } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { let tag: i32 = parcel.read()?; match tag { 0 => { let value: Option> = Some(parcel.read()?); *self = Self::Iface(value); Ok(()) } 1 => { let value: Option> = parcel.read()?; *self = Self::Nullable_iface(value); Ok(()) } 2 => { let value: Vec> = parcel.read()?; *self = Self::Iface_list(value); Ok(()) } 3 => { let value: Option>>> = parcel.read()?; *self = Self::Nullable_iface_list(value); Ok(()) } _ => { Err(binder::StatusCode::BAD_VALUE) } } } } binder::impl_serialize_for_parcelable!(r#MyUnion); binder::impl_deserialize_for_parcelable!(r#MyUnion); impl binder::binder_impl::ParcelableMetadata for r#MyUnion { fn get_descriptor() -> &'static str { "android.aidl.tests.ListOfInterfaces.MyUnion" } } pub mod r#Tag { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#Tag : [i32; 4] { r#iface = 0, r#nullable_iface = 1, r#iface_list = 2, r#nullable_iface_list = 3, } } } } pub(crate) mod mangled { pub use super::r#ListOfInterfaces as _7_android_4_aidl_5_tests_16_ListOfInterfaces; pub use super::r#IEmptyInterface::r#IEmptyInterface as _7_android_4_aidl_5_tests_16_ListOfInterfaces_15_IEmptyInterface; pub use super::r#IMyInterface::r#IMyInterface as _7_android_4_aidl_5_tests_16_ListOfInterfaces_12_IMyInterface; pub use super::r#MyParcelable::r#MyParcelable as _7_android_4_aidl_5_tests_16_ListOfInterfaces_12_MyParcelable; pub use super::r#MyUnion::r#MyUnion as _7_android_4_aidl_5_tests_16_ListOfInterfaces_7_MyUnion; pub use super::r#MyUnion::r#Tag::r#Tag as _7_android_4_aidl_5_tests_16_ListOfInterfaces_7_MyUnion_3_Tag; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_ListOfInt0100644 0000000 0000000 00000000034 15172120304 033225 xustar000000000 0000000 28 mtime=1776853188.4950000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/ListOfInterfaces.rs.d0100644 0000000 0000000 00000000275 15172120304 032213 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/ListOfInterfaces.rs : \ system/tools/aidl/tests/android/aidl/tests/ListOfInterfaces.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_LongEnum.0100644 0000000 0000000 00000000034 15172120304 033154 xustar000000000 0000000 28 mtime=1776853188.4950000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/LongEnum.rs0100644 0000000 0000000 00000001476 15172120304 030315 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/LongEnum.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#LongEnum : [i64; 3] { r#FOO = 100000000000, r#BAR = 200000000000, r#BAZ = 200000000001, } } pub(crate) mod mangled { pub use super::r#LongEnum as _7_android_4_aidl_5_tests_8_LongEnum; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_LongEnum.0100644 0000000 0000000 00000000034 15172120304 033154 xustar000000000 0000000 28 mtime=1776853188.4950000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/LongEnum.rs.d0100644 0000000 0000000 00000000255 15172120304 030531 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/LongEnum.rs : \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_OtherParc0100644 0000000 0000000 00000000216 15172120304 033243 xustar000000000 0000000 114 path=tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/OtherParcelableForToString.rs 28 mtime=1776853188.4950000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/OtherParcelableForToStrin0100644 0000000 0000000 00000003403 15172120304 033164 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/OtherParcelableForToString.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub struct r#OtherParcelableForToString { pub r#field: String, } impl Default for r#OtherParcelableForToString { fn default() -> Self { Self { r#field: Default::default(), } } } impl binder::Parcelable for r#OtherParcelableForToString { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#field)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#field = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#OtherParcelableForToString); binder::impl_deserialize_for_parcelable!(r#OtherParcelableForToString); impl binder::binder_impl::ParcelableMetadata for r#OtherParcelableForToString { fn get_descriptor() -> &'static str { "android.aidl.tests.OtherParcelableForToString" } } pub(crate) mod mangled { pub use super::r#OtherParcelableForToString as _7_android_4_aidl_5_tests_26_OtherParcelableForToString; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_OtherParc0100644 0000000 0000000 00000000220 15172120304 033236 xustar000000000 0000000 116 path=tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/OtherParcelableForToString.rs.d 28 mtime=1776853188.4950000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/OtherParcelableForToStrin0100644 0000000 0000000 00000000321 15172120304 033160 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/OtherParcelableForToString.rs : \ system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_Parcelabl0100644 0000000 0000000 00000000034 15172120304 033237 xustar000000000 0000000 28 mtime=1776853188.4950000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/ParcelableForToString.rs0100644 0000000 0000000 00000015115 15172120304 032757 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/ParcelableForToString.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ParcelableForToString.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub struct r#ParcelableForToString { pub r#intValue: i32, pub r#intArray: Vec, pub r#longValue: i64, pub r#longArray: Vec, pub r#doubleValue: f64, pub r#doubleArray: Vec, pub r#floatValue: f32, pub r#floatArray: Vec, pub r#byteValue: i8, pub r#byteArray: Vec, pub r#booleanValue: bool, pub r#booleanArray: Vec, pub r#stringValue: String, pub r#stringArray: Vec, pub r#stringList: Vec, pub r#parcelableValue: crate::mangled::_7_android_4_aidl_5_tests_26_OtherParcelableForToString, pub r#parcelableArray: Vec, pub r#enumValue: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum, pub r#enumArray: Vec, pub r#nullArray: Vec, pub r#nullList: Vec, pub r#parcelableGeneric: crate::mangled::_7_android_4_aidl_5_tests_27_GenericStructuredParcelable, pub r#unionValue: crate::mangled::_7_android_4_aidl_5_tests_5_Union, } impl Default for r#ParcelableForToString { fn default() -> Self { Self { r#intValue: 0, r#intArray: Default::default(), r#longValue: 0, r#longArray: Default::default(), r#doubleValue: 0.000000f64, r#doubleArray: Default::default(), r#floatValue: 0.000000f32, r#floatArray: Default::default(), r#byteValue: 0, r#byteArray: Default::default(), r#booleanValue: false, r#booleanArray: Default::default(), r#stringValue: Default::default(), r#stringArray: Default::default(), r#stringList: Default::default(), r#parcelableValue: Default::default(), r#parcelableArray: Default::default(), r#enumValue: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum::FOO, r#enumArray: Default::default(), r#nullArray: Default::default(), r#nullList: Default::default(), r#parcelableGeneric: Default::default(), r#unionValue: Default::default(), } } } impl binder::Parcelable for r#ParcelableForToString { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#intValue)?; subparcel.write(&self.r#intArray)?; subparcel.write(&self.r#longValue)?; subparcel.write(&self.r#longArray)?; subparcel.write(&self.r#doubleValue)?; subparcel.write(&self.r#doubleArray)?; subparcel.write(&self.r#floatValue)?; subparcel.write(&self.r#floatArray)?; subparcel.write(&self.r#byteValue)?; subparcel.write(&self.r#byteArray)?; subparcel.write(&self.r#booleanValue)?; subparcel.write(&self.r#booleanArray)?; subparcel.write(&self.r#stringValue)?; subparcel.write(&self.r#stringArray)?; subparcel.write(&self.r#stringList)?; subparcel.write(&self.r#parcelableValue)?; subparcel.write(&self.r#parcelableArray)?; subparcel.write(&self.r#enumValue)?; subparcel.write(&self.r#enumArray)?; subparcel.write(&self.r#nullArray)?; subparcel.write(&self.r#nullList)?; subparcel.write(&self.r#parcelableGeneric)?; subparcel.write(&self.r#unionValue)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#intValue = subparcel.read()?; } if subparcel.has_more_data() { self.r#intArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#longValue = subparcel.read()?; } if subparcel.has_more_data() { self.r#longArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#doubleValue = subparcel.read()?; } if subparcel.has_more_data() { self.r#doubleArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#floatValue = subparcel.read()?; } if subparcel.has_more_data() { self.r#floatArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#byteValue = subparcel.read()?; } if subparcel.has_more_data() { self.r#byteArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#booleanValue = subparcel.read()?; } if subparcel.has_more_data() { self.r#booleanArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#stringValue = subparcel.read()?; } if subparcel.has_more_data() { self.r#stringArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#stringList = subparcel.read()?; } if subparcel.has_more_data() { self.r#parcelableValue = subparcel.read()?; } if subparcel.has_more_data() { self.r#parcelableArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#enumValue = subparcel.read()?; } if subparcel.has_more_data() { self.r#enumArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#nullArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#nullList = subparcel.read()?; } if subparcel.has_more_data() { self.r#parcelableGeneric = subparcel.read()?; } if subparcel.has_more_data() { self.r#unionValue = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#ParcelableForToString); binder::impl_deserialize_for_parcelable!(r#ParcelableForToString); impl binder::binder_impl::ParcelableMetadata for r#ParcelableForToString { fn get_descriptor() -> &'static str { "android.aidl.tests.ParcelableForToString" } } pub(crate) mod mangled { pub use super::r#ParcelableForToString as _7_android_4_aidl_5_tests_21_ParcelableForToString; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_Parcelabl0100644 0000000 0000000 00000000213 15172120304 033236 xustar000000000 0000000 111 path=tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/ParcelableForToString.rs.d 28 mtime=1776853188.4960000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/ParcelableForToString.rs.0100644 0000000 0000000 00000001352 15172120304 033033 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/ParcelableForToString.rs : \ system/tools/aidl/tests/android/aidl/tests/ParcelableForToString.aidl \ system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_Recursive0100644 0000000 0000000 00000000034 15172120304 033321 xustar000000000 0000000 28 mtime=1776853188.4960000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/RecursiveList.rs0100644 0000000 0000000 00000003525 15172120304 031371 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/RecursiveList.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub struct r#RecursiveList { pub r#value: i32, pub r#next: Option>, } impl Default for r#RecursiveList { fn default() -> Self { Self { r#value: 0, r#next: Default::default(), } } } impl binder::Parcelable for r#RecursiveList { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#value)?; subparcel.write(&self.r#next)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#value = subparcel.read()?; } if subparcel.has_more_data() { self.r#next = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#RecursiveList); binder::impl_deserialize_for_parcelable!(r#RecursiveList); impl binder::binder_impl::ParcelableMetadata for r#RecursiveList { fn get_descriptor() -> &'static str { "android.aidl.tests.RecursiveList" } } pub(crate) mod mangled { pub use super::r#RecursiveList as _7_android_4_aidl_5_tests_13_RecursiveList; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_Recursive0100644 0000000 0000000 00000000034 15172120304 033321 xustar000000000 0000000 28 mtime=1776853188.4960000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/RecursiveList.rs.d0100644 0000000 0000000 00000000267 15172120304 031613 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/RecursiveList.rs : \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_Structure0100644 0000000 0000000 00000000034 15172120304 033352 xustar000000000 0000000 28 mtime=1776853188.4960000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/StructuredParcelable.rs0100644 0000000 0000000 00000036674 15172120304 032720 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/StructuredParcelable.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug, Clone, PartialEq)] pub struct r#StructuredParcelable { pub r#shouldContainThreeFs: Vec, pub r#f: i32, pub r#shouldBeJerry: String, pub r#shouldBeByteBar: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum, pub r#shouldBeIntBar: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum, pub r#shouldBeLongBar: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum, pub r#shouldContainTwoByteFoos: Vec, pub r#shouldContainTwoIntFoos: Vec, pub r#shouldContainTwoLongFoos: Vec, pub r#stringDefaultsToFoo: String, pub r#byteDefaultsToFour: i8, pub r#intDefaultsToFive: i32, pub r#longDefaultsToNegativeSeven: i64, pub r#booleanDefaultsToTrue: bool, pub r#charDefaultsToC: u16, pub r#floatDefaultsToPi: f32, pub r#doubleWithDefault: f64, pub r#arrayDefaultsTo123: Vec, pub r#arrayDefaultsToEmpty: Vec, pub r#boolDefault: bool, pub r#byteDefault: i8, pub r#intDefault: i32, pub r#longDefault: i64, pub r#floatDefault: f32, pub r#doubleDefault: f64, pub r#checkDoubleFromFloat: f64, pub r#checkStringArray1: Vec, pub r#checkStringArray2: Vec, pub r#int32_min: i32, pub r#int32_max: i32, pub r#int64_max: i64, pub r#hexInt32_neg_1: i32, pub r#ibinder: Option, pub r#empty: crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable_5_Empty, pub r#int8_1: Vec, pub r#int32_1: Vec, pub r#int64_1: Vec, pub r#hexInt32_pos_1: i32, pub r#hexInt64_pos_1: i32, pub r#const_exprs_1: crate::mangled::_7_android_4_aidl_5_tests_22_ConstantExpressionEnum, pub r#const_exprs_2: crate::mangled::_7_android_4_aidl_5_tests_22_ConstantExpressionEnum, pub r#const_exprs_3: crate::mangled::_7_android_4_aidl_5_tests_22_ConstantExpressionEnum, pub r#const_exprs_4: crate::mangled::_7_android_4_aidl_5_tests_22_ConstantExpressionEnum, pub r#const_exprs_5: crate::mangled::_7_android_4_aidl_5_tests_22_ConstantExpressionEnum, pub r#const_exprs_6: crate::mangled::_7_android_4_aidl_5_tests_22_ConstantExpressionEnum, pub r#const_exprs_7: crate::mangled::_7_android_4_aidl_5_tests_22_ConstantExpressionEnum, pub r#const_exprs_8: crate::mangled::_7_android_4_aidl_5_tests_22_ConstantExpressionEnum, pub r#const_exprs_9: crate::mangled::_7_android_4_aidl_5_tests_22_ConstantExpressionEnum, pub r#const_exprs_10: crate::mangled::_7_android_4_aidl_5_tests_22_ConstantExpressionEnum, pub r#addString1: String, pub r#addString2: String, pub r#shouldSetBit0AndBit2: i32, pub r#u: Option, pub r#shouldBeConstS1: Option, pub r#defaultWithFoo: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum, } pub const r#BIT0: i32 = 1; pub const r#BIT1: i32 = 2; pub const r#BIT2: i32 = 4; impl Default for r#StructuredParcelable { fn default() -> Self { Self { r#shouldContainThreeFs: Default::default(), r#f: 0, r#shouldBeJerry: Default::default(), r#shouldBeByteBar: Default::default(), r#shouldBeIntBar: Default::default(), r#shouldBeLongBar: Default::default(), r#shouldContainTwoByteFoos: Default::default(), r#shouldContainTwoIntFoos: Default::default(), r#shouldContainTwoLongFoos: Default::default(), r#stringDefaultsToFoo: "foo".into(), r#byteDefaultsToFour: 4, r#intDefaultsToFive: 5, r#longDefaultsToNegativeSeven: -7, r#booleanDefaultsToTrue: true, r#charDefaultsToC: 'C' as u16, r#floatDefaultsToPi: 3.140000f32, r#doubleWithDefault: -314000000000000000.000000f64, r#arrayDefaultsTo123: vec![1, 2, 3], r#arrayDefaultsToEmpty: vec![], r#boolDefault: false, r#byteDefault: 0, r#intDefault: 0, r#longDefault: 0, r#floatDefault: 0.000000f32, r#doubleDefault: 0.000000f64, r#checkDoubleFromFloat: 3.140000f64, r#checkStringArray1: vec!["a".into(), "b".into()], r#checkStringArray2: vec!["a".into(), "b".into()], r#int32_min: -2147483648, r#int32_max: 2147483647, r#int64_max: 9223372036854775807, r#hexInt32_neg_1: -1, r#ibinder: Default::default(), r#empty: Default::default(), r#int8_1: vec![1, 1, 1, 1, 1], r#int32_1: vec![1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], r#int64_1: vec![1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], r#hexInt32_pos_1: 1, r#hexInt64_pos_1: 1, r#const_exprs_1: Default::default(), r#const_exprs_2: Default::default(), r#const_exprs_3: Default::default(), r#const_exprs_4: Default::default(), r#const_exprs_5: Default::default(), r#const_exprs_6: Default::default(), r#const_exprs_7: Default::default(), r#const_exprs_8: Default::default(), r#const_exprs_9: Default::default(), r#const_exprs_10: Default::default(), r#addString1: "hello world!".into(), r#addString2: "The quick brown fox jumps over the lazy dog.".into(), r#shouldSetBit0AndBit2: 0, r#u: Default::default(), r#shouldBeConstS1: Default::default(), r#defaultWithFoo: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum::FOO, } } } impl binder::Parcelable for r#StructuredParcelable { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#shouldContainThreeFs)?; subparcel.write(&self.r#f)?; subparcel.write(&self.r#shouldBeJerry)?; subparcel.write(&self.r#shouldBeByteBar)?; subparcel.write(&self.r#shouldBeIntBar)?; subparcel.write(&self.r#shouldBeLongBar)?; subparcel.write(&self.r#shouldContainTwoByteFoos)?; subparcel.write(&self.r#shouldContainTwoIntFoos)?; subparcel.write(&self.r#shouldContainTwoLongFoos)?; subparcel.write(&self.r#stringDefaultsToFoo)?; subparcel.write(&self.r#byteDefaultsToFour)?; subparcel.write(&self.r#intDefaultsToFive)?; subparcel.write(&self.r#longDefaultsToNegativeSeven)?; subparcel.write(&self.r#booleanDefaultsToTrue)?; subparcel.write(&self.r#charDefaultsToC)?; subparcel.write(&self.r#floatDefaultsToPi)?; subparcel.write(&self.r#doubleWithDefault)?; subparcel.write(&self.r#arrayDefaultsTo123)?; subparcel.write(&self.r#arrayDefaultsToEmpty)?; subparcel.write(&self.r#boolDefault)?; subparcel.write(&self.r#byteDefault)?; subparcel.write(&self.r#intDefault)?; subparcel.write(&self.r#longDefault)?; subparcel.write(&self.r#floatDefault)?; subparcel.write(&self.r#doubleDefault)?; subparcel.write(&self.r#checkDoubleFromFloat)?; subparcel.write(&self.r#checkStringArray1)?; subparcel.write(&self.r#checkStringArray2)?; subparcel.write(&self.r#int32_min)?; subparcel.write(&self.r#int32_max)?; subparcel.write(&self.r#int64_max)?; subparcel.write(&self.r#hexInt32_neg_1)?; subparcel.write(&self.r#ibinder)?; subparcel.write(&self.r#empty)?; subparcel.write(&self.r#int8_1)?; subparcel.write(&self.r#int32_1)?; subparcel.write(&self.r#int64_1)?; subparcel.write(&self.r#hexInt32_pos_1)?; subparcel.write(&self.r#hexInt64_pos_1)?; subparcel.write(&self.r#const_exprs_1)?; subparcel.write(&self.r#const_exprs_2)?; subparcel.write(&self.r#const_exprs_3)?; subparcel.write(&self.r#const_exprs_4)?; subparcel.write(&self.r#const_exprs_5)?; subparcel.write(&self.r#const_exprs_6)?; subparcel.write(&self.r#const_exprs_7)?; subparcel.write(&self.r#const_exprs_8)?; subparcel.write(&self.r#const_exprs_9)?; subparcel.write(&self.r#const_exprs_10)?; subparcel.write(&self.r#addString1)?; subparcel.write(&self.r#addString2)?; subparcel.write(&self.r#shouldSetBit0AndBit2)?; subparcel.write(&self.r#u)?; subparcel.write(&self.r#shouldBeConstS1)?; subparcel.write(&self.r#defaultWithFoo)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#shouldContainThreeFs = subparcel.read()?; } if subparcel.has_more_data() { self.r#f = subparcel.read()?; } if subparcel.has_more_data() { self.r#shouldBeJerry = subparcel.read()?; } if subparcel.has_more_data() { self.r#shouldBeByteBar = subparcel.read()?; } if subparcel.has_more_data() { self.r#shouldBeIntBar = subparcel.read()?; } if subparcel.has_more_data() { self.r#shouldBeLongBar = subparcel.read()?; } if subparcel.has_more_data() { self.r#shouldContainTwoByteFoos = subparcel.read()?; } if subparcel.has_more_data() { self.r#shouldContainTwoIntFoos = subparcel.read()?; } if subparcel.has_more_data() { self.r#shouldContainTwoLongFoos = subparcel.read()?; } if subparcel.has_more_data() { self.r#stringDefaultsToFoo = subparcel.read()?; } if subparcel.has_more_data() { self.r#byteDefaultsToFour = subparcel.read()?; } if subparcel.has_more_data() { self.r#intDefaultsToFive = subparcel.read()?; } if subparcel.has_more_data() { self.r#longDefaultsToNegativeSeven = subparcel.read()?; } if subparcel.has_more_data() { self.r#booleanDefaultsToTrue = subparcel.read()?; } if subparcel.has_more_data() { self.r#charDefaultsToC = subparcel.read()?; } if subparcel.has_more_data() { self.r#floatDefaultsToPi = subparcel.read()?; } if subparcel.has_more_data() { self.r#doubleWithDefault = subparcel.read()?; } if subparcel.has_more_data() { self.r#arrayDefaultsTo123 = subparcel.read()?; } if subparcel.has_more_data() { self.r#arrayDefaultsToEmpty = subparcel.read()?; } if subparcel.has_more_data() { self.r#boolDefault = subparcel.read()?; } if subparcel.has_more_data() { self.r#byteDefault = subparcel.read()?; } if subparcel.has_more_data() { self.r#intDefault = subparcel.read()?; } if subparcel.has_more_data() { self.r#longDefault = subparcel.read()?; } if subparcel.has_more_data() { self.r#floatDefault = subparcel.read()?; } if subparcel.has_more_data() { self.r#doubleDefault = subparcel.read()?; } if subparcel.has_more_data() { self.r#checkDoubleFromFloat = subparcel.read()?; } if subparcel.has_more_data() { self.r#checkStringArray1 = subparcel.read()?; } if subparcel.has_more_data() { self.r#checkStringArray2 = subparcel.read()?; } if subparcel.has_more_data() { self.r#int32_min = subparcel.read()?; } if subparcel.has_more_data() { self.r#int32_max = subparcel.read()?; } if subparcel.has_more_data() { self.r#int64_max = subparcel.read()?; } if subparcel.has_more_data() { self.r#hexInt32_neg_1 = subparcel.read()?; } if subparcel.has_more_data() { self.r#ibinder = subparcel.read()?; } if subparcel.has_more_data() { self.r#empty = subparcel.read()?; } if subparcel.has_more_data() { self.r#int8_1 = subparcel.read()?; } if subparcel.has_more_data() { self.r#int32_1 = subparcel.read()?; } if subparcel.has_more_data() { self.r#int64_1 = subparcel.read()?; } if subparcel.has_more_data() { self.r#hexInt32_pos_1 = subparcel.read()?; } if subparcel.has_more_data() { self.r#hexInt64_pos_1 = subparcel.read()?; } if subparcel.has_more_data() { self.r#const_exprs_1 = subparcel.read()?; } if subparcel.has_more_data() { self.r#const_exprs_2 = subparcel.read()?; } if subparcel.has_more_data() { self.r#const_exprs_3 = subparcel.read()?; } if subparcel.has_more_data() { self.r#const_exprs_4 = subparcel.read()?; } if subparcel.has_more_data() { self.r#const_exprs_5 = subparcel.read()?; } if subparcel.has_more_data() { self.r#const_exprs_6 = subparcel.read()?; } if subparcel.has_more_data() { self.r#const_exprs_7 = subparcel.read()?; } if subparcel.has_more_data() { self.r#const_exprs_8 = subparcel.read()?; } if subparcel.has_more_data() { self.r#const_exprs_9 = subparcel.read()?; } if subparcel.has_more_data() { self.r#const_exprs_10 = subparcel.read()?; } if subparcel.has_more_data() { self.r#addString1 = subparcel.read()?; } if subparcel.has_more_data() { self.r#addString2 = subparcel.read()?; } if subparcel.has_more_data() { self.r#shouldSetBit0AndBit2 = subparcel.read()?; } if subparcel.has_more_data() { self.r#u = subparcel.read()?; } if subparcel.has_more_data() { self.r#shouldBeConstS1 = subparcel.read()?; } if subparcel.has_more_data() { self.r#defaultWithFoo = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#StructuredParcelable); binder::impl_deserialize_for_parcelable!(r#StructuredParcelable); impl binder::binder_impl::ParcelableMetadata for r#StructuredParcelable { fn get_descriptor() -> &'static str { "android.aidl.tests.StructuredParcelable" } } pub mod r#Empty { #[derive(Debug, Clone, PartialEq)] pub struct r#Empty { } impl Default for r#Empty { fn default() -> Self { Self { } } } impl binder::Parcelable for r#Empty { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#Empty); binder::impl_deserialize_for_parcelable!(r#Empty); impl binder::binder_impl::ParcelableMetadata for r#Empty { fn get_descriptor() -> &'static str { "android.aidl.tests.StructuredParcelable.Empty" } } } pub(crate) mod mangled { pub use super::r#StructuredParcelable as _7_android_4_aidl_5_tests_20_StructuredParcelable; pub use super::r#Empty::r#Empty as _7_android_4_aidl_5_tests_20_StructuredParcelable_5_Empty; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_Structure0100644 0000000 0000000 00000000212 15172120304 033350 xustar000000000 0000000 110 path=tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/StructuredParcelable.rs.d 28 mtime=1776853188.4960000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/StructuredParcelable.rs.d0100644 0000000 0000000 00000001000 15172120304 033111 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/StructuredParcelable.rs : \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_Union.rs0100644 0000000 0000000 00000000034 15172120304 033065 xustar000000000 0000000 28 mtime=1776853188.4960000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/Union.rs0100644 0000000 0000000 00000006557 15172120304 027666 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/Union.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/Union.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug, Clone, PartialEq)] pub enum r#Union { Ns(Vec), N(i32), M(i32), S(String), Ibinder(Option), Ss(Vec), Be(crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum), } pub const r#S1: &str = "a string constant in union"; impl Default for r#Union { fn default() -> Self { Self::Ns(vec![]) } } impl binder::Parcelable for r#Union { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { match self { Self::Ns(v) => { parcel.write(&0i32)?; parcel.write(v) } Self::N(v) => { parcel.write(&1i32)?; parcel.write(v) } Self::M(v) => { parcel.write(&2i32)?; parcel.write(v) } Self::S(v) => { parcel.write(&3i32)?; parcel.write(v) } Self::Ibinder(v) => { parcel.write(&4i32)?; parcel.write(v) } Self::Ss(v) => { parcel.write(&5i32)?; parcel.write(v) } Self::Be(v) => { parcel.write(&6i32)?; parcel.write(v) } } } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { let tag: i32 = parcel.read()?; match tag { 0 => { let value: Vec = parcel.read()?; *self = Self::Ns(value); Ok(()) } 1 => { let value: i32 = parcel.read()?; *self = Self::N(value); Ok(()) } 2 => { let value: i32 = parcel.read()?; *self = Self::M(value); Ok(()) } 3 => { let value: String = parcel.read()?; *self = Self::S(value); Ok(()) } 4 => { let value: Option = parcel.read()?; *self = Self::Ibinder(value); Ok(()) } 5 => { let value: Vec = parcel.read()?; *self = Self::Ss(value); Ok(()) } 6 => { let value: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum = parcel.read()?; *self = Self::Be(value); Ok(()) } _ => { Err(binder::StatusCode::BAD_VALUE) } } } } binder::impl_serialize_for_parcelable!(r#Union); binder::impl_deserialize_for_parcelable!(r#Union); impl binder::binder_impl::ParcelableMetadata for r#Union { fn get_descriptor() -> &'static str { "android.aidl.tests.Union" } } pub mod r#Tag { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#Tag : [i32; 7] { r#ns = 0, r#n = 1, r#m = 2, r#s = 3, r#ibinder = 4, r#ss = 5, r#be = 6, } } } pub(crate) mod mangled { pub use super::r#Union as _7_android_4_aidl_5_tests_5_Union; pub use super::r#Tag::r#Tag as _7_android_4_aidl_5_tests_5_Union_3_Tag; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_Union.rs.0100644 0000000 0000000 00000000034 15172120304 033143 xustar000000000 0000000 28 mtime=1776853188.4960000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/Union.rs.d0100644 0000000 0000000 00000000344 15172120304 030074 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/Union.rs : \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_UnionWith0100644 0000000 0000000 00000000034 15172120304 033276 xustar000000000 0000000 28 mtime=1776853188.4960000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/UnionWithFd.rs0100644 0000000 0000000 00000004416 15172120304 030764 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/UnionWithFd.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/UnionWithFd.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub enum r#UnionWithFd { Num(i32), Pfd(Option), } impl Default for r#UnionWithFd { fn default() -> Self { Self::Num(0) } } impl binder::Parcelable for r#UnionWithFd { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { match self { Self::Num(v) => { parcel.write(&0i32)?; parcel.write(v) } Self::Pfd(v) => { parcel.write(&1i32)?; let __field_ref = v.as_ref().ok_or(binder::StatusCode::UNEXPECTED_NULL)?; parcel.write(__field_ref) } } } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { let tag: i32 = parcel.read()?; match tag { 0 => { let value: i32 = parcel.read()?; *self = Self::Num(value); Ok(()) } 1 => { let value: Option = Some(parcel.read()?); *self = Self::Pfd(value); Ok(()) } _ => { Err(binder::StatusCode::BAD_VALUE) } } } } binder::impl_serialize_for_parcelable!(r#UnionWithFd); binder::impl_deserialize_for_parcelable!(r#UnionWithFd); impl binder::binder_impl::ParcelableMetadata for r#UnionWithFd { fn get_descriptor() -> &'static str { "android.aidl.tests.UnionWithFd" } } pub mod r#Tag { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#Tag : [i32; 2] { r#num = 0, r#pfd = 1, } } } pub(crate) mod mangled { pub use super::r#UnionWithFd as _7_android_4_aidl_5_tests_11_UnionWithFd; pub use super::r#Tag::r#Tag as _7_android_4_aidl_5_tests_11_UnionWithFd_3_Tag; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_UnionWith0100644 0000000 0000000 00000000034 15172120304 033276 xustar000000000 0000000 28 mtime=1776853188.4960000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/UnionWithFd.rs.d0100644 0000000 0000000 00000000263 15172120304 031202 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/UnionWithFd.rs : \ system/tools/aidl/tests/android/aidl/tests/UnionWithFd.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_extension0100644 0000000 0000000 00000000034 15172120304 033366 xustar000000000 0000000 28 mtime=1776853188.4970000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/0040755 0000000 0000000 00000000000 15172120304 030232 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_extension0100644 0000000 0000000 00000000222 15172120304 033365 xustar000000000 0000000 118 path=tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/ExtendableParcelable.rs 28 mtime=1776853188.4970000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/ExtendableParce0100644 0000000 0000000 00000004757 15172120304 033215 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/ExtendableParcelable.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub struct r#ExtendableParcelable { pub r#a: i32, pub r#b: String, pub r#ext: binder::ParcelableHolder, pub r#c: i64, pub r#ext2: binder::ParcelableHolder, } impl Default for r#ExtendableParcelable { fn default() -> Self { Self { r#a: 0, r#b: Default::default(), r#ext: binder::ParcelableHolder::new(binder::binder_impl::Stability::Local), r#c: 0, r#ext2: binder::ParcelableHolder::new(binder::binder_impl::Stability::Local), } } } impl binder::Parcelable for r#ExtendableParcelable { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#a)?; subparcel.write(&self.r#b)?; subparcel.write(&self.r#ext)?; subparcel.write(&self.r#c)?; subparcel.write(&self.r#ext2)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#a = subparcel.read()?; } if subparcel.has_more_data() { self.r#b = subparcel.read()?; } if subparcel.has_more_data() { self.r#ext = subparcel.read()?; } if subparcel.has_more_data() { self.r#c = subparcel.read()?; } if subparcel.has_more_data() { self.r#ext2 = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#ExtendableParcelable); binder::impl_deserialize_for_parcelable!(r#ExtendableParcelable); impl binder::binder_impl::ParcelableMetadata for r#ExtendableParcelable { fn get_descriptor() -> &'static str { "android.aidl.tests.extension.ExtendableParcelable" } } pub(crate) mod mangled { pub use super::r#ExtendableParcelable as _7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_extension0100644 0000000 0000000 00000000224 15172120304 033367 xustar000000000 0000000 120 path=tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/ExtendableParcelable.rs.d 28 mtime=1776853188.4970000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/ExtendableParce0100644 0000000 0000000 00000000331 15172120304 033175 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/ExtendableParcelable.rs : \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_extension0100644 0000000 0000000 00000000034 15172120304 033366 xustar000000000 0000000 28 mtime=1776853188.4970000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/MyExt.rs0100644 0000000 0000000 00000003311 15172120304 031641 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/MyExt.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub struct r#MyExt { pub r#a: i32, pub r#b: String, } impl Default for r#MyExt { fn default() -> Self { Self { r#a: 0, r#b: Default::default(), } } } impl binder::Parcelable for r#MyExt { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#a)?; subparcel.write(&self.r#b)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#a = subparcel.read()?; } if subparcel.has_more_data() { self.r#b = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#MyExt); binder::impl_deserialize_for_parcelable!(r#MyExt); impl binder::binder_impl::ParcelableMetadata for r#MyExt { fn get_descriptor() -> &'static str { "android.aidl.tests.extension.MyExt" } } pub(crate) mod mangled { pub use super::r#MyExt as _7_android_4_aidl_5_tests_9_extension_5_MyExt; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_extension0100644 0000000 0000000 00000000034 15172120304 033366 xustar000000000 0000000 28 mtime=1776853188.4970000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/MyExt.rs.d0100644 0000000 0000000 00000000273 15172120304 032067 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/MyExt.rs : \ system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_extension0100644 0000000 0000000 00000000034 15172120304 033366 xustar000000000 0000000 28 mtime=1776853188.4970000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/MyExt2.rs0100644 0000000 0000000 00000003663 15172120304 031735 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/MyExt2.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt2.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub struct r#MyExt2 { pub r#a: i32, pub r#b: crate::mangled::_7_android_4_aidl_5_tests_9_extension_5_MyExt, pub r#c: String, } impl Default for r#MyExt2 { fn default() -> Self { Self { r#a: 0, r#b: Default::default(), r#c: Default::default(), } } } impl binder::Parcelable for r#MyExt2 { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#a)?; subparcel.write(&self.r#b)?; subparcel.write(&self.r#c)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#a = subparcel.read()?; } if subparcel.has_more_data() { self.r#b = subparcel.read()?; } if subparcel.has_more_data() { self.r#c = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#MyExt2); binder::impl_deserialize_for_parcelable!(r#MyExt2); impl binder::binder_impl::ParcelableMetadata for r#MyExt2 { fn get_descriptor() -> &'static str { "android.aidl.tests.extension.MyExt2" } } pub(crate) mod mangled { pub use super::r#MyExt2 as _7_android_4_aidl_5_tests_9_extension_6_MyExt2; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_extension0100644 0000000 0000000 00000000034 15172120304 033366 xustar000000000 0000000 28 mtime=1776853188.4970000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/MyExt2.rs.d0100644 0000000 0000000 00000000401 15172120304 032142 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/MyExt2.rs : \ system/tools/aidl/tests/android/aidl/tests/extension/MyExt2.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_extension0100644 0000000 0000000 00000000034 15172120304 033366 xustar000000000 0000000 28 mtime=1776853188.4970000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/MyExtLike.rs0100644 0000000 0000000 00000003365 15172120304 032457 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/MyExtLike.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExtLike.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub struct r#MyExtLike { pub r#a: i32, pub r#b: String, } impl Default for r#MyExtLike { fn default() -> Self { Self { r#a: 0, r#b: Default::default(), } } } impl binder::Parcelable for r#MyExtLike { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#a)?; subparcel.write(&self.r#b)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#a = subparcel.read()?; } if subparcel.has_more_data() { self.r#b = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#MyExtLike); binder::impl_deserialize_for_parcelable!(r#MyExtLike); impl binder::binder_impl::ParcelableMetadata for r#MyExtLike { fn get_descriptor() -> &'static str { "android.aidl.tests.extension.MyExtLike" } } pub(crate) mod mangled { pub use super::r#MyExtLike as _7_android_4_aidl_5_tests_9_extension_9_MyExtLike; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_extension0100644 0000000 0000000 00000000034 15172120304 033366 xustar000000000 0000000 28 mtime=1776853188.4970000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/MyExtLike.rs.d0100644 0000000 0000000 00000000303 15172120304 032666 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/MyExtLike.rs : \ system/tools/aidl/tests/android/aidl/tests/extension/MyExtLike.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_nested_0100644 0000000 0000000 00000000034 15172120304 032773 xustar000000000 0000000 28 mtime=1776853188.4970000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/nested/0040755 0000000 0000000 00000000000 15172120304 027500 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_nested_De0100644 0000000 0000000 00000000034 15172120304 033244 xustar000000000 0000000 28 mtime=1776853188.4970000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/nested/DeeplyNested.rs0100644 0000000 0000000 00000013503 15172120304 032432 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/nested/DeeplyNested.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/DeeplyNested.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub struct r#DeeplyNested { } impl Default for r#DeeplyNested { fn default() -> Self { Self { } } } impl binder::Parcelable for r#DeeplyNested { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#DeeplyNested); binder::impl_deserialize_for_parcelable!(r#DeeplyNested); impl binder::binder_impl::ParcelableMetadata for r#DeeplyNested { fn get_descriptor() -> &'static str { "android.aidl.tests.nested.DeeplyNested" } } pub mod r#A { #[derive(Debug)] pub struct r#A { pub r#e: crate::mangled::_7_android_4_aidl_5_tests_6_nested_12_DeeplyNested_1_B_1_C_1_D_1_E, } impl Default for r#A { fn default() -> Self { Self { r#e: crate::mangled::_7_android_4_aidl_5_tests_6_nested_12_DeeplyNested_1_B_1_C_1_D_1_E::OK, } } } impl binder::Parcelable for r#A { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#e)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#e = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#A); binder::impl_deserialize_for_parcelable!(r#A); impl binder::binder_impl::ParcelableMetadata for r#A { fn get_descriptor() -> &'static str { "android.aidl.tests.nested.DeeplyNested.A" } } } pub mod r#B { #[derive(Debug)] pub struct r#B { } impl Default for r#B { fn default() -> Self { Self { } } } impl binder::Parcelable for r#B { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#B); binder::impl_deserialize_for_parcelable!(r#B); impl binder::binder_impl::ParcelableMetadata for r#B { fn get_descriptor() -> &'static str { "android.aidl.tests.nested.DeeplyNested.B" } } pub mod r#C { #[derive(Debug)] pub struct r#C { } impl Default for r#C { fn default() -> Self { Self { } } } impl binder::Parcelable for r#C { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#C); binder::impl_deserialize_for_parcelable!(r#C); impl binder::binder_impl::ParcelableMetadata for r#C { fn get_descriptor() -> &'static str { "android.aidl.tests.nested.DeeplyNested.B.C" } } pub mod r#D { #[derive(Debug)] pub struct r#D { } impl Default for r#D { fn default() -> Self { Self { } } } impl binder::Parcelable for r#D { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#D); binder::impl_deserialize_for_parcelable!(r#D); impl binder::binder_impl::ParcelableMetadata for r#D { fn get_descriptor() -> &'static str { "android.aidl.tests.nested.DeeplyNested.B.C.D" } } pub mod r#E { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#E : [i8; 1] { r#OK = 0, } } } } } } pub(crate) mod mangled { pub use super::r#DeeplyNested as _7_android_4_aidl_5_tests_6_nested_12_DeeplyNested; pub use super::r#A::r#A as _7_android_4_aidl_5_tests_6_nested_12_DeeplyNested_1_A; pub use super::r#B::r#B as _7_android_4_aidl_5_tests_6_nested_12_DeeplyNested_1_B; pub use super::r#B::r#C::r#C as _7_android_4_aidl_5_tests_6_nested_12_DeeplyNested_1_B_1_C; pub use super::r#B::r#C::r#D::r#D as _7_android_4_aidl_5_tests_6_nested_12_DeeplyNested_1_B_1_C_1_D; pub use super::r#B::r#C::r#D::r#E::r#E as _7_android_4_aidl_5_tests_6_nested_12_DeeplyNested_1_B_1_C_1_D_1_E; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_nested_De0100644 0000000 0000000 00000000034 15172120304 033244 xustar000000000 0000000 28 mtime=1776853188.4970000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/nested/DeeplyNested.rs.d0100644 0000000 0000000 00000000303 15172120304 032646 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/nested/DeeplyNested.rs : \ system/tools/aidl/tests/android/aidl/tests/nested/DeeplyNested.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_nested_IN0100644 0000000 0000000 00000000034 15172120304 033222 xustar000000000 0000000 28 mtime=1776853188.4980000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/nested/INestedService.rs0100644 0000000 0000000 00000052107 15172120304 032724 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/nested/INestedService.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/INestedService.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { INestedService["android.aidl.tests.nested.INestedService"] { native: BnNestedService(on_transact), proxy: BpNestedService { }, async: INestedServiceAsync, } } pub trait INestedService: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.nested.INestedService" } fn r#flipStatus(&self, _arg_p: &crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested) -> binder::Result; fn r#flipStatusWithCallback(&self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status, _arg_cb: &binder::Strong) -> binder::Result<()>; fn getDefaultImpl() -> INestedServiceDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: INestedServiceDefaultRef) -> INestedServiceDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait INestedServiceAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.nested.INestedService" } fn r#flipStatus<'a>(&'a self, _arg_p: &'a crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested) -> binder::BoxFuture<'a, binder::Result>; fn r#flipStatusWithCallback<'a>(&'a self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status, _arg_cb: &'a binder::Strong) -> binder::BoxFuture<'a, binder::Result<()>>; } #[::async_trait::async_trait] pub trait INestedServiceAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.nested.INestedService" } async fn r#flipStatus(&self, _arg_p: &crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested) -> binder::Result; async fn r#flipStatusWithCallback(&self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status, _arg_cb: &binder::Strong) -> binder::Result<()>; } impl BnNestedService { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: INestedServiceAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl INestedService for Wrapper where T: INestedServiceAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#flipStatus(&self, _arg_p: &crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested) -> binder::Result { self._rt.block_on(self._inner.r#flipStatus(_arg_p)) } fn r#flipStatusWithCallback(&self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status, _arg_cb: &binder::Strong) -> binder::Result<()> { self._rt.block_on(self._inner.r#flipStatusWithCallback(_arg_status, _arg_cb)) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait INestedServiceDefault: Send + Sync { fn r#flipStatus(&self, _arg_p: &crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#flipStatusWithCallback(&self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status, _arg_cb: &binder::Strong) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#flipStatus: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; pub const r#flipStatusWithCallback: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 1; } pub type INestedServiceDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); impl BpNestedService { fn build_parcel_flipStatus(&self, _arg_p: &crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_p)?; Ok(aidl_data) } fn read_response_flipStatus(&self, _arg_p: &crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#flipStatus(_arg_p); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_5_tests_6_nested_14_INestedService_6_Result = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_flipStatusWithCallback(&self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status, _arg_cb: &binder::Strong) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(&_arg_status)?; aidl_data.write(_arg_cb)?; Ok(aidl_data) } fn read_response_flipStatusWithCallback(&self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status, _arg_cb: &binder::Strong, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#flipStatusWithCallback(_arg_status, _arg_cb); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } Ok(()) } } impl INestedService for BpNestedService { fn r#flipStatus(&self, _arg_p: &crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested) -> binder::Result { let _aidl_data = self.build_parcel_flipStatus(_arg_p)?; let _aidl_reply = self.binder.submit_transact(transactions::r#flipStatus, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_flipStatus(_arg_p, _aidl_reply) } fn r#flipStatusWithCallback(&self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status, _arg_cb: &binder::Strong) -> binder::Result<()> { let _aidl_data = self.build_parcel_flipStatusWithCallback(_arg_status, _arg_cb)?; let _aidl_reply = self.binder.submit_transact(transactions::r#flipStatusWithCallback, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_flipStatusWithCallback(_arg_status, _arg_cb, _aidl_reply) } } impl INestedServiceAsync

for BpNestedService { fn r#flipStatus<'a>(&'a self, _arg_p: &'a crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_flipStatus(_arg_p) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#flipStatus, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_flipStatus(_arg_p, _aidl_reply) } ) } fn r#flipStatusWithCallback<'a>(&'a self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status, _arg_cb: &'a binder::Strong) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_flipStatusWithCallback(_arg_status, _arg_cb) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#flipStatusWithCallback, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_flipStatusWithCallback(_arg_status, _arg_cb, _aidl_reply) } ) } } impl INestedService for binder::binder_impl::Binder { fn r#flipStatus(&self, _arg_p: &crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested) -> binder::Result { self.0.r#flipStatus(_arg_p) } fn r#flipStatusWithCallback(&self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status, _arg_cb: &binder::Strong) -> binder::Result<()> { self.0.r#flipStatusWithCallback(_arg_status, _arg_cb) } } fn on_transact(_aidl_service: &dyn INestedService, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#flipStatus => { let _arg_p: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested = _aidl_data.read()?; let _aidl_return = _aidl_service.r#flipStatus(&_arg_p); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#flipStatusWithCallback => { let _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status = _aidl_data.read()?; let _arg_cb: binder::Strong = _aidl_data.read()?; let _aidl_return = _aidl_service.r#flipStatusWithCallback(_arg_status, &_arg_cb); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } pub mod r#Result { #[derive(Debug, PartialEq)] pub struct r#Result { pub r#status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status, } impl Default for r#Result { fn default() -> Self { Self { r#status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status::OK, } } } impl binder::Parcelable for r#Result { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#status)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#status = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#Result); binder::impl_deserialize_for_parcelable!(r#Result); impl binder::binder_impl::ParcelableMetadata for r#Result { fn get_descriptor() -> &'static str { "android.aidl.tests.nested.INestedService.Result" } } } pub mod r#ICallback { #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { ICallback["android.aidl.tests.nested.INestedService.ICallback"] { native: BnCallback(on_transact), proxy: BpCallback { }, async: ICallbackAsync, } } pub trait ICallback: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.nested.INestedService.ICallback" } fn r#done(&self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status) -> binder::Result<()>; fn getDefaultImpl() -> ICallbackDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: ICallbackDefaultRef) -> ICallbackDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait ICallbackAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.nested.INestedService.ICallback" } fn r#done<'a>(&'a self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status) -> binder::BoxFuture<'a, binder::Result<()>>; } #[::async_trait::async_trait] pub trait ICallbackAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.nested.INestedService.ICallback" } async fn r#done(&self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status) -> binder::Result<()>; } impl BnCallback { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: ICallbackAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl ICallback for Wrapper where T: ICallbackAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#done(&self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status) -> binder::Result<()> { self._rt.block_on(self._inner.r#done(_arg_status)) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait ICallbackDefault: Send + Sync { fn r#done(&self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#done: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; } pub type ICallbackDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); impl BpCallback { fn build_parcel_done(&self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(&_arg_status)?; Ok(aidl_data) } fn read_response_done(&self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#done(_arg_status); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } Ok(()) } } impl ICallback for BpCallback { fn r#done(&self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status) -> binder::Result<()> { let _aidl_data = self.build_parcel_done(_arg_status)?; let _aidl_reply = self.binder.submit_transact(transactions::r#done, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_done(_arg_status, _aidl_reply) } } impl ICallbackAsync

for BpCallback { fn r#done<'a>(&'a self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_done(_arg_status) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#done, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_done(_arg_status, _aidl_reply) } ) } } impl ICallback for binder::binder_impl::Binder { fn r#done(&self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status) -> binder::Result<()> { self.0.r#done(_arg_status) } } fn on_transact(_aidl_service: &dyn ICallback, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#done => { let _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status = _aidl_data.read()?; let _aidl_return = _aidl_service.r#done(_arg_status); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } } pub(crate) mod mangled { pub use super::r#INestedService as _7_android_4_aidl_5_tests_6_nested_14_INestedService; pub use super::r#Result::r#Result as _7_android_4_aidl_5_tests_6_nested_14_INestedService_6_Result; pub use super::r#ICallback::r#ICallback as _7_android_4_aidl_5_tests_6_nested_14_INestedService_9_ICallback; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_nested_IN0100644 0000000 0000000 00000000213 15172120304 033221 xustar000000000 0000000 111 path=tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/nested/INestedService.rs.d 28 mtime=1776853188.4980000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/nested/INestedService.rs.0100644 0000000 0000000 00000000427 15172120304 033000 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/nested/INestedService.rs : \ system/tools/aidl/tests/android/aidl/tests/nested/INestedService.aidl \ system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_nested_Pa0100644 0000000 0000000 00000000217 15172120304 033257 xustar000000000 0000000 115 path=tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/nested/ParcelableWithNested.rs 28 mtime=1776853188.4980000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/nested/ParcelableWithNest0100644 0000000 0000000 00000004234 15172120304 033143 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/nested/ParcelableWithNested.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub struct r#ParcelableWithNested { pub r#status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status, } impl Default for r#ParcelableWithNested { fn default() -> Self { Self { r#status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status::OK, } } } impl binder::Parcelable for r#ParcelableWithNested { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#status)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#status = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#ParcelableWithNested); binder::impl_deserialize_for_parcelable!(r#ParcelableWithNested); impl binder::binder_impl::ParcelableMetadata for r#ParcelableWithNested { fn get_descriptor() -> &'static str { "android.aidl.tests.nested.ParcelableWithNested" } } pub mod r#Status { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#Status : [i8; 2] { r#OK = 0, r#NOT_OK = 1, } } } pub(crate) mod mangled { pub use super::r#ParcelableWithNested as _7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested; pub use super::r#Status::r#Status as _7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_nested_Pa0100644 0000000 0000000 00000000221 15172120304 033252 xustar000000000 0000000 117 path=tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/nested/ParcelableWithNested.rs.d 28 mtime=1776853188.4980000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/nested/ParcelableWithNest0100644 0000000 0000000 00000000323 15172120304 033136 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/nested/ParcelableWithNested.rs : \ system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_unions_0100644 0000000 0000000 00000000034 15172120304 033024 xustar000000000 0000000 28 mtime=1776853188.4980000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/unions/0040755 0000000 0000000 00000000000 15172120304 027531 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_unions_En0100644 0000000 0000000 00000000034 15172120304 033307 xustar000000000 0000000 28 mtime=1776853188.4980000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/unions/EnumUnion.rs0100644 0000000 0000000 00000005410 15172120304 032011 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/unions/EnumUnion.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug, Clone, PartialEq)] pub enum r#EnumUnion { IntEnum(crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum), LongEnum(crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum), #[deprecated = "do not use this"] DeprecatedField(i32), } impl Default for r#EnumUnion { fn default() -> Self { Self::IntEnum(crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum::FOO) } } impl binder::Parcelable for r#EnumUnion { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { match self { Self::IntEnum(v) => { parcel.write(&0i32)?; parcel.write(v) } Self::LongEnum(v) => { parcel.write(&1i32)?; parcel.write(v) } Self::DeprecatedField(v) => { parcel.write(&2i32)?; parcel.write(v) } } } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { let tag: i32 = parcel.read()?; match tag { 0 => { let value: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum = parcel.read()?; *self = Self::IntEnum(value); Ok(()) } 1 => { let value: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum = parcel.read()?; *self = Self::LongEnum(value); Ok(()) } 2 => { let value: i32 = parcel.read()?; *self = Self::DeprecatedField(value); Ok(()) } _ => { Err(binder::StatusCode::BAD_VALUE) } } } } binder::impl_serialize_for_parcelable!(r#EnumUnion); binder::impl_deserialize_for_parcelable!(r#EnumUnion); impl binder::binder_impl::ParcelableMetadata for r#EnumUnion { fn get_descriptor() -> &'static str { "android.aidl.tests.unions.EnumUnion" } } pub mod r#Tag { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#Tag : [i32; 3] { r#intEnum = 0, r#longEnum = 1, #[deprecated = "do not use this"] r#deprecatedField = 2, } } } pub(crate) mod mangled { pub use super::r#EnumUnion as _7_android_4_aidl_5_tests_6_unions_9_EnumUnion; pub use super::r#Tag::r#Tag as _7_android_4_aidl_5_tests_6_unions_9_EnumUnion_3_Tag; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_unions_En0100644 0000000 0000000 00000000034 15172120304 033307 xustar000000000 0000000 28 mtime=1776853188.4980000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/unions/EnumUnion.rs.d0100644 0000000 0000000 00000000466 15172120304 032241 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/unions/EnumUnion.rs : \ system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_unions_Un0100644 0000000 0000000 00000000034 15172120304 033327 xustar000000000 0000000 28 mtime=1776853188.4980000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/unions/UnionInUnion.rs0100644 0000000 0000000 00000004514 15172120304 032470 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/unions/UnionInUnion.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/UnionInUnion.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug, Clone, PartialEq)] pub enum r#UnionInUnion { First(crate::mangled::_7_android_4_aidl_5_tests_6_unions_9_EnumUnion), Second(i32), } impl Default for r#UnionInUnion { fn default() -> Self { Self::First(Default::default()) } } impl binder::Parcelable for r#UnionInUnion { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { match self { Self::First(v) => { parcel.write(&0i32)?; parcel.write(v) } Self::Second(v) => { parcel.write(&1i32)?; parcel.write(v) } } } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { let tag: i32 = parcel.read()?; match tag { 0 => { let value: crate::mangled::_7_android_4_aidl_5_tests_6_unions_9_EnumUnion = parcel.read()?; *self = Self::First(value); Ok(()) } 1 => { let value: i32 = parcel.read()?; *self = Self::Second(value); Ok(()) } _ => { Err(binder::StatusCode::BAD_VALUE) } } } } binder::impl_serialize_for_parcelable!(r#UnionInUnion); binder::impl_deserialize_for_parcelable!(r#UnionInUnion); impl binder::binder_impl::ParcelableMetadata for r#UnionInUnion { fn get_descriptor() -> &'static str { "android.aidl.tests.unions.UnionInUnion" } } pub mod r#Tag { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#Tag : [i32; 2] { r#first = 0, r#second = 1, } } } pub(crate) mod mangled { pub use super::r#UnionInUnion as _7_android_4_aidl_5_tests_6_unions_12_UnionInUnion; pub use super::r#Tag::r#Tag as _7_android_4_aidl_5_tests_6_unions_12_UnionInUnion_3_Tag; } ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_android_aidl_tests_unions_Un0100644 0000000 0000000 00000000034 15172120304 033327 xustar000000000 0000000 28 mtime=1776853188.4980000 tests/golden_output/aidl-test-interface-rust-source/gen/android/aidl/tests/unions/UnionInUnion.rs.d0100644 0000000 0000000 00000000601 15172120304 032703 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/unions/UnionInUnion.rs : \ system/tools/aidl/tests/android/aidl/tests/unions/UnionInUnion.aidl \ system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-interface-rust-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 027442 xustar000000000 0000000 28 mtime=1776853188.4980000 tests/golden_output/aidl-test-interface-rust-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 024434 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-cpp-source_0100644 0000000 0000000 00000000034 15172120304 026732 xustar000000000 0000000 28 mtime=1776853188.4980000 tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/0040755 0000000 0000000 00000000000 15172120304 024017 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-cpp-source_gen_0100644 0000000 0000000 00000000034 15172120304 027563 xustar000000000 0000000 28 mtime=1776853188.4990000 tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/0040755 0000000 0000000 00000000000 15172120304 024570 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-cpp-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 031263 xustar000000000 0000000 28 mtime=1776853188.4990000 tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 026210 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-cpp-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 032254 xustar000000000 0000000 28 mtime=1776853188.4990000 tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 027121 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-cpp-source_gen_android_aidl_ver0100644 0000000 0000000 00000000034 15172120304 032771 xustar000000000 0000000 28 mtime=1776853188.4990000 tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/versioned/0040755 0000000 0000000 00000000000 15172120304 031117 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-cpp-source_gen_android_aidl_ver0100644 0000000 0000000 00000000034 15172120304 032771 xustar000000000 0000000 28 mtime=1776853188.4990000 tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/versioned/tests/0040755 0000000 0000000 00000000000 15172120304 032261 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-cpp-source_gen_android_aidl_ver0100644 0000000 0000000 00000000223 15172120304 032771 xustar000000000 0000000 119 path=tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/versioned/tests/BazUnion.cpp 28 mtime=1776853188.4990000 tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/versioned/tests/Baz0100644 0000000 0000000 00000004050 15172120304 032714 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl */ #include namespace android { namespace aidl { namespace versioned { namespace tests { ::android::status_t BazUnion::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_tag)) != ::android::OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case intNum: { int32_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } } return ::android::BAD_VALUE; } ::android::status_t BazUnion::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(getTag())); if (_aidl_ret_status != ::android::OK) return _aidl_ret_status; switch (getTag()) { case intNum: return _aidl_parcel->writeInt32(get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-cpp-source_gen_android_aidl_ver0100644 0000000 0000000 00000000225 15172120304 032773 xustar000000000 0000000 121 path=tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/versioned/tests/BazUnion.cpp.d 28 mtime=1776853188.4990000 tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/versioned/tests/Baz0100644 0000000 0000000 00000000361 15172120304 032715 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/versioned/tests/BazUnion.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-cpp-source_gen_android_aidl_ver0100644 0000000 0000000 00000000216 15172120304 032773 xustar000000000 0000000 114 path=tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/versioned/tests/Foo.cpp 28 mtime=1776853188.4990000 tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/versioned/tests/Foo0100644 0000000 0000000 00000004160 15172120304 032725 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl */ #include namespace android { namespace aidl { namespace versioned { namespace tests { ::android::status_t Foo::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t Foo::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-cpp-source_gen_android_aidl_ver0100644 0000000 0000000 00000000220 15172120304 032766 xustar000000000 0000000 116 path=tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/versioned/tests/Foo.cpp.d 28 mtime=1776853188.4990000 tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/versioned/tests/Foo0100644 0000000 0000000 00000000347 15172120304 032730 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/versioned/tests/Foo.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-cpp-source_gen_android_aidl_ver0100644 0000000 0000000 00000000230 15172120304 032767 xustar000000000 0000000 124 path=tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/versioned/tests/IFooInterface.cpp 28 mtime=1776853188.4990000 tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/versioned/tests/IFo0100644 0000000 0000000 00000036263 15172120304 032670 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/IFooInterface.aidl */ #include #include namespace android { namespace aidl { namespace versioned { namespace tests { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE(FooInterface, "android.aidl.versioned.tests.IFooInterface") } // namespace tests } // namespace versioned } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace versioned { namespace tests { BpFooInterface::BpFooInterface(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } ::android::binder::Status BpFooInterface::originalApi() { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::originalApi::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnFooInterface::TRANSACTION_originalApi, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) [[unlikely]] { return IFooInterface::getDefaultImpl()->originalApi(); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpFooInterface::acceptUnionAndReturnString(const ::android::aidl::versioned::tests::BazUnion& u, ::std::string* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::acceptUnionAndReturnString::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(u); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnFooInterface::TRANSACTION_acceptUnionAndReturnString, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) [[unlikely]] { return IFooInterface::getDefaultImpl()->acceptUnionAndReturnString(u, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readUtf8FromUtf16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpFooInterface::ignoreParcelablesAndRepeatInt(const ::android::aidl::versioned::tests::Foo& inFoo, ::android::aidl::versioned::tests::Foo* inoutFoo, ::android::aidl::versioned::tests::Foo* outFoo, int32_t value, int32_t* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::ignoreParcelablesAndRepeatInt::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(inFoo); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(*inoutFoo); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeInt32(value); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnFooInterface::TRANSACTION_ignoreParcelablesAndRepeatInt, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) [[unlikely]] { return IFooInterface::getDefaultImpl()->ignoreParcelablesAndRepeatInt(inFoo, inoutFoo, outFoo, value, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readInt32(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readParcelable(inoutFoo); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readParcelable(outFoo); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpFooInterface::returnsLengthOfFooArray(const ::std::vector<::android::aidl::versioned::tests::Foo>& foos, int32_t* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::returnsLengthOfFooArray::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelableVector(foos); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnFooInterface::TRANSACTION_returnsLengthOfFooArray, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) [[unlikely]] { return IFooInterface::getDefaultImpl()->returnsLengthOfFooArray(foos, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readInt32(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } int32_t BpFooInterface::getInterfaceVersion() { if (cached_version_ == -1) { ::android::Parcel data; ::android::Parcel reply; data.writeInterfaceToken(getInterfaceDescriptor()); ::android::status_t err = remote()->transact(BnFooInterface::TRANSACTION_getInterfaceVersion, data, &reply); if (err == ::android::OK) { ::android::binder::Status _aidl_status; err = _aidl_status.readFromParcel(reply); if (err == ::android::OK && _aidl_status.isOk()) { cached_version_ = reply.readInt32(); } } } return cached_version_; } std::string BpFooInterface::getInterfaceHash() { std::lock_guard lockGuard(cached_hash_mutex_); if (cached_hash_ == "-1") { ::android::Parcel data; ::android::Parcel reply; data.writeInterfaceToken(getInterfaceDescriptor()); ::android::status_t err = remote()->transact(BnFooInterface::TRANSACTION_getInterfaceHash, data, &reply); if (err == ::android::OK) { ::android::binder::Status _aidl_status; err = _aidl_status.readFromParcel(reply); if (err == ::android::OK && _aidl_status.isOk()) { reply.readUtf8FromUtf16(&cached_hash_); } } } return cached_hash_; } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace versioned { namespace tests { BnFooInterface::BnFooInterface() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t BnFooInterface::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnFooInterface::TRANSACTION_originalApi: { if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::originalApi::cppServer"); ::android::binder::Status _aidl_status(originalApi()); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; case BnFooInterface::TRANSACTION_acceptUnionAndReturnString: { ::android::aidl::versioned::tests::BazUnion in_u; ::std::string _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::acceptUnionAndReturnString::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_u); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(acceptUnionAndReturnString(in_u, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeUtf8AsUtf16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnFooInterface::TRANSACTION_ignoreParcelablesAndRepeatInt: { ::android::aidl::versioned::tests::Foo in_inFoo; ::android::aidl::versioned::tests::Foo in_inoutFoo; ::android::aidl::versioned::tests::Foo out_outFoo; int32_t in_value; int32_t _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::ignoreParcelablesAndRepeatInt::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_inFoo); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readParcelable(&in_inoutFoo); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readInt32(&in_value); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ignoreParcelablesAndRepeatInt(in_inFoo, &in_inoutFoo, &out_outFoo, in_value, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeInt32(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(in_inoutFoo); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(out_outFoo); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnFooInterface::TRANSACTION_returnsLengthOfFooArray: { ::std::vector<::android::aidl::versioned::tests::Foo> in_foos; int32_t _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::returnsLengthOfFooArray::cppServer"); _aidl_ret_status = _aidl_data.readParcelableVector(&in_foos); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(returnsLengthOfFooArray(in_foos, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeInt32(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnFooInterface::TRANSACTION_getInterfaceVersion: { _aidl_data.checkInterface(this); _aidl_reply->writeNoException(); _aidl_reply->writeInt32(IFooInterface::VERSION); } break; case BnFooInterface::TRANSACTION_getInterfaceHash: { _aidl_data.checkInterface(this); _aidl_reply->writeNoException(); _aidl_reply->writeUtf8AsUtf16(IFooInterface::HASH); } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } int32_t BnFooInterface::getInterfaceVersion() { return IFooInterface::VERSION; } std::string BnFooInterface::getInterfaceHash() { return IFooInterface::HASH; } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-cpp-source_gen_android_aidl_ver0100644 0000000 0000000 00000000232 15172120304 032771 xustar000000000 0000000 126 path=tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/versioned/tests/IFooInterface.cpp.d 28 mtime=1776853188.4990000 tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/versioned/tests/IFo0100644 0000000 0000000 00000000712 15172120304 032656 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/versioned/tests/IFooInterface.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/IFooInterface.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-cpp-source_gen_include_0100644 0000000 0000000 00000000034 15172120304 031266 xustar000000000 0000000 28 mtime=1776853188.4990000 tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/include/0040755 0000000 0000000 00000000000 15172120304 026213 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-cpp-source_gen_include_android_0100644 0000000 0000000 00000000034 15172120304 032766 xustar000000000 0000000 28 mtime=1776853188.5000000 tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/0040755 0000000 0000000 00000000000 15172120304 027633 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-cpp-source_gen_include_android_0100644 0000000 0000000 00000000034 15172120304 032766 xustar000000000 0000000 28 mtime=1776853188.5000000 tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/0040755 0000000 0000000 00000000000 15172120304 030544 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-cpp-source_gen_include_android_0100644 0000000 0000000 00000000034 15172120304 032766 xustar000000000 0000000 28 mtime=1776853188.5000000 tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/versioned/0040755 0000000 0000000 00000000000 15172120304 032542 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-cpp-source_gen_include_android_0100644 0000000 0000000 00000000217 15172120304 032771 xustar000000000 0000000 115 path=tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/versioned/tests/ 28 mtime=1776853188.5000000 tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/versioned/t0040755 0000000 0000000 00000000000 15172120304 032726 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-cpp-source_gen_include_android_0100644 0000000 0000000 00000000231 15172120304 032765 xustar000000000 0000000 125 path=tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/versioned/tests/BazUnion.h 28 mtime=1776853188.5000000 tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/versioned/t0100644 0000000 0000000 00000012035 15172120304 032726 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace android { namespace aidl { namespace versioned { namespace tests { class BazUnion : public ::android::Parcelable { public: enum class Tag : int32_t { intNum = 0, }; // Expose tag symbols for legacy code static const inline Tag intNum = Tag::intNum; template static constexpr bool _not_self = !std::is_same_v>, BazUnion>; BazUnion() : _value(std::in_place_index(intNum)>, int32_t(0)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr BazUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit BazUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static BazUnion make(_Tp&&... _args) { return BazUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static BazUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return BazUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } inline bool operator==(const BazUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const BazUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const BazUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const BazUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const BazUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const BazUnion& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.versioned.tests.BazUnion"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream os; os << "BazUnion{"; switch (getTag()) { case intNum: os << "intNum: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant _value; }; // class BazUnion } // namespace tests } // namespace versioned } // namespace aidl } // namespace android namespace android { namespace aidl { namespace versioned { namespace tests { [[nodiscard]] static inline std::string toString(BazUnion::Tag val) { switch(val) { case BazUnion::Tag::intNum: return "intNum"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::versioned::tests::BazUnion::Tag, 1> enum_values<::android::aidl::versioned::tests::BazUnion::Tag> = { ::android::aidl::versioned::tests::BazUnion::Tag::intNum, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-cpp-source_gen_include_android_0100644 0000000 0000000 00000000233 15172120304 032767 xustar000000000 0000000 127 path=tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/versioned/tests/BnBazUnion.h 28 mtime=1776853188.5000000 tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/versioned/t0100644 0000000 0000000 00000001432 15172120304 032725 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-cpp-source_gen_include_android_0100644 0000000 0000000 00000000226 15172120304 032771 xustar000000000 0000000 122 path=tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/versioned/tests/BnFoo.h 28 mtime=1776853188.5000000 tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/versioned/t0100644 0000000 0000000 00000001420 15172120304 032722 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-cpp-source_gen_include_android_0100644 0000000 0000000 00000000237 15172120304 032773 xustar000000000 0000000 131 path=tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/versioned/tests/BnFooInterface.h 28 mtime=1776853188.5000000 tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/versioned/t0100644 0000000 0000000 00000007224 15172120304 032732 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace versioned { namespace tests { class BnFooInterface : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_originalApi = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_acceptUnionAndReturnString = ::android::IBinder::FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_ignoreParcelablesAndRepeatInt = ::android::IBinder::FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_returnsLengthOfFooArray = ::android::IBinder::FIRST_CALL_TRANSACTION + 3; static constexpr uint32_t TRANSACTION_getInterfaceVersion = ::android::IBinder::FIRST_CALL_TRANSACTION + 16777214; static constexpr uint32_t TRANSACTION_getInterfaceHash = ::android::IBinder::FIRST_CALL_TRANSACTION + 16777213; explicit BnFooInterface(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; int32_t getInterfaceVersion(); std::string getInterfaceHash(); }; // class BnFooInterface class IFooInterfaceDelegator : public BnFooInterface { public: explicit IFooInterfaceDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status originalApi() override { return _aidl_delegate->originalApi(); } ::android::binder::Status acceptUnionAndReturnString(const ::android::aidl::versioned::tests::BazUnion& u, ::std::string* _aidl_return) override { return _aidl_delegate->acceptUnionAndReturnString(u, _aidl_return); } ::android::binder::Status ignoreParcelablesAndRepeatInt(const ::android::aidl::versioned::tests::Foo& inFoo, ::android::aidl::versioned::tests::Foo* inoutFoo, ::android::aidl::versioned::tests::Foo* outFoo, int32_t value, int32_t* _aidl_return) override { return _aidl_delegate->ignoreParcelablesAndRepeatInt(inFoo, inoutFoo, outFoo, value, _aidl_return); } ::android::binder::Status returnsLengthOfFooArray(const ::std::vector<::android::aidl::versioned::tests::Foo>& foos, int32_t* _aidl_return) override { return _aidl_delegate->returnsLengthOfFooArray(foos, _aidl_return); } int32_t getInterfaceVersion() override { int32_t _delegator_ver = BnFooInterface::getInterfaceVersion(); int32_t _impl_ver = _aidl_delegate->getInterfaceVersion(); return _delegator_ver < _impl_ver ? _delegator_ver : _impl_ver; } std::string getInterfaceHash() override { return _aidl_delegate->getInterfaceHash(); } private: ::android::sp _aidl_delegate; }; // class IFooInterfaceDelegator } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-cpp-source_gen_include_android_0100644 0000000 0000000 00000000233 15172120304 032767 xustar000000000 0000000 127 path=tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/versioned/tests/BpBazUnion.h 28 mtime=1776853188.5000000 tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/versioned/t0100644 0000000 0000000 00000001432 15172120304 032725 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-cpp-source_gen_include_android_0100644 0000000 0000000 00000000226 15172120304 032771 xustar000000000 0000000 122 path=tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/versioned/tests/BpFoo.h 28 mtime=1776853188.5000000 tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/versioned/t0100644 0000000 0000000 00000001420 15172120304 032722 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-cpp-source_gen_include_android_0100644 0000000 0000000 00000000237 15172120304 032773 xustar000000000 0000000 131 path=tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/versioned/tests/BpFooInterface.h 28 mtime=1776853188.5000000 tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/versioned/t0100644 0000000 0000000 00000004063 15172120304 032730 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace versioned { namespace tests { class BpFooInterface : public ::android::BpInterface { public: explicit BpFooInterface(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpFooInterface() = default; ::android::binder::Status originalApi() override; ::android::binder::Status acceptUnionAndReturnString(const ::android::aidl::versioned::tests::BazUnion& u, ::std::string* _aidl_return) override; ::android::binder::Status ignoreParcelablesAndRepeatInt(const ::android::aidl::versioned::tests::Foo& inFoo, ::android::aidl::versioned::tests::Foo* inoutFoo, ::android::aidl::versioned::tests::Foo* outFoo, int32_t value, int32_t* _aidl_return) override; ::android::binder::Status returnsLengthOfFooArray(const ::std::vector<::android::aidl::versioned::tests::Foo>& foos, int32_t* _aidl_return) override; int32_t getInterfaceVersion() override; std::string getInterfaceHash() override; private: int32_t cached_version_ = -1; std::string cached_hash_ = "-1"; std::mutex cached_hash_mutex_; }; // class BpFooInterface } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-cpp-source_gen_include_android_0100644 0000000 0000000 00000000224 15172120304 032767 xustar000000000 0000000 120 path=tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/versioned/tests/Foo.h 28 mtime=1776853188.5000000 tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/versioned/t0100644 0000000 0000000 00000004075 15172120304 032733 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl */ #pragma once #include #include #include #include #include namespace android { namespace aidl { namespace versioned { namespace tests { class Foo : public ::android::Parcelable { public: inline bool operator==(const Foo&) const { return std::tie() == std::tie(); } inline bool operator<(const Foo&) const { return std::tie() < std::tie(); } inline bool operator!=(const Foo& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Foo& _rhs) const { return _rhs < *this; } inline bool operator>=(const Foo& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Foo& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.versioned.tests.Foo"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "Foo{"; _aidl_os << "}"; return _aidl_os.str(); } }; // class Foo } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-cpp-source_gen_include_android_0100644 0000000 0000000 00000000236 15172120304 032772 xustar000000000 0000000 130 path=tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/versioned/tests/IFooInterface.h 28 mtime=1776853188.5000000 tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/versioned/t0100644 0000000 0000000 00000007155 15172120304 032735 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include namespace android::aidl::versioned::tests { class Foo; } // namespace android::aidl::versioned::tests namespace android { namespace aidl { namespace versioned { namespace tests { class IFooInterfaceDelegator; class IFooInterface : public ::android::IInterface { public: typedef IFooInterfaceDelegator DefaultDelegator; DECLARE_META_INTERFACE(FooInterface) static inline const int32_t VERSION = 1; static inline const std::string HASH = "9e7be1859820c59d9d55dd133e71a3687b5d2e5b"; virtual ::android::binder::Status originalApi() = 0; virtual ::android::binder::Status acceptUnionAndReturnString(const ::android::aidl::versioned::tests::BazUnion& u, ::std::string* _aidl_return) = 0; virtual ::android::binder::Status ignoreParcelablesAndRepeatInt(const ::android::aidl::versioned::tests::Foo& inFoo, ::android::aidl::versioned::tests::Foo* inoutFoo, ::android::aidl::versioned::tests::Foo* outFoo, int32_t value, int32_t* _aidl_return) = 0; virtual ::android::binder::Status returnsLengthOfFooArray(const ::std::vector<::android::aidl::versioned::tests::Foo>& foos, int32_t* _aidl_return) = 0; virtual int32_t getInterfaceVersion() = 0; virtual std::string getInterfaceHash() = 0; }; // class IFooInterface class IFooInterfaceDefault : public IFooInterface { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status originalApi() override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status acceptUnionAndReturnString(const ::android::aidl::versioned::tests::BazUnion& /*u*/, ::std::string* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ignoreParcelablesAndRepeatInt(const ::android::aidl::versioned::tests::Foo& /*inFoo*/, ::android::aidl::versioned::tests::Foo* /*inoutFoo*/, ::android::aidl::versioned::tests::Foo* /*outFoo*/, int32_t /*value*/, int32_t* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status returnsLengthOfFooArray(const ::std::vector<::android::aidl::versioned::tests::Foo>& /*foos*/, int32_t* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } int32_t getInterfaceVersion() override { return 0; } std::string getInterfaceHash() override { return ""; } }; // class IFooInterfaceDefault } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-cpp-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 031507 xustar000000000 0000000 28 mtime=1776853188.5010000 tests/golden_output/aidl-test-versioned-interface-V1-cpp-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 026501 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-java-source_0100644 0000000 0000000 00000000034 15172120304 027071 xustar000000000 0000000 28 mtime=1776853188.5010000 tests/golden_output/aidl-test-versioned-interface-V1-java-source/0040755 0000000 0000000 00000000000 15172120304 024156 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-java-source_gen_0100644 0000000 0000000 00000000034 15172120304 027722 xustar000000000 0000000 28 mtime=1776853188.5010000 tests/golden_output/aidl-test-versioned-interface-V1-java-source/gen/0040755 0000000 0000000 00000000000 15172120304 024727 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-java-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 031422 xustar000000000 0000000 28 mtime=1776853188.5010000 tests/golden_output/aidl-test-versioned-interface-V1-java-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 026347 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-java-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 032413 xustar000000000 0000000 28 mtime=1776853188.5010000 tests/golden_output/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 027260 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-java-source_gen_android_aidl_ve0100644 0000000 0000000 00000000034 15172120304 032746 xustar000000000 0000000 28 mtime=1776853188.5010000 tests/golden_output/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/0040755 0000000 0000000 00000000000 15172120304 031256 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-java-source_gen_android_aidl_ve0100644 0000000 0000000 00000000034 15172120304 032746 xustar000000000 0000000 28 mtime=1776853188.5010000 tests/golden_output/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/tests/0040755 0000000 0000000 00000000000 15172120304 032420 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-java-source_gen_android_aidl_ve0100644 0000000 0000000 00000000225 15172120304 032750 xustar000000000 0000000 121 path=tests/golden_output/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/tests/BazUnion.java 28 mtime=1776853188.5010000 tests/golden_output/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/tests/Ba0100644 0000000 0000000 00000005776 15172120304 032701 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --rpc --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/tests/BazUnion.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-java-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl */ package android.aidl.versioned.tests; public final class BazUnion implements android.os.Parcelable { // tags for union fields public final static int intNum = 0; // int intNum; private int _tag; private Object _value; public BazUnion() { int _value = 0; this._tag = intNum; this._value = _value; } private BazUnion(android.os.Parcel _aidl_parcel) { readFromParcel(_aidl_parcel); } private BazUnion(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public int getTag() { return _tag; } // int intNum; public static BazUnion intNum(int _value) { return new BazUnion(intNum, _value); } public int getIntNum() { _assertTag(intNum); return (int) _value; } public void setIntNum(int _value) { _set(intNum, _value); } public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public BazUnion createFromParcel(android.os.Parcel _aidl_source) { return new BazUnion(_aidl_source); } @Override public BazUnion[] newArray(int _aidl_size) { return new BazUnion[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { _aidl_parcel.writeInt(_tag); switch (_tag) { case intNum: _aidl_parcel.writeInt(getIntNum()); break; } } public void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_tag; _aidl_tag = _aidl_parcel.readInt(); switch (_aidl_tag) { case intNum: { int _aidl_value; _aidl_value = _aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } } throw new IllegalArgumentException("union: unknown tag: " + _aidl_tag); } @Override public int describeContents() { int _mask = 0; switch (getTag()) { } return _mask; } private void _assertTag(int tag) { if (getTag() != tag) { throw new IllegalStateException("bad access: " + _tagString(tag) + ", " + _tagString(getTag()) + " is available."); } } private String _tagString(int _tag) { switch (_tag) { case intNum: return "intNum"; } throw new IllegalStateException("unknown field: " + _tag); } private void _set(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public static @interface Tag { public static final int intNum = 0; } } ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-java-source_gen_android_aidl_ve0100644 0000000 0000000 00000000227 15172120304 032752 xustar000000000 0000000 123 path=tests/golden_output/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/tests/BazUnion.java.d 28 mtime=1776853188.5010000 tests/golden_output/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/tests/Ba0100644 0000000 0000000 00000000363 15172120304 032664 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/tests/BazUnion.java : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-java-source_gen_android_aidl_ve0100644 0000000 0000000 00000000220 15172120304 032743 xustar000000000 0000000 116 path=tests/golden_output/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/tests/Foo.java 28 mtime=1776853188.5010000 tests/golden_output/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/tests/Fo0100644 0000000 0000000 00000004161 15172120304 032706 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --rpc --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/tests/Foo.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-java-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl */ package android.aidl.versioned.tests; public class Foo implements android.os.Parcelable { public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public Foo createFromParcel(android.os.Parcel _aidl_source) { Foo _aidl_out = new Foo(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public Foo[] newArray(int _aidl_size) { return new Foo[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } } ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-java-source_gen_android_aidl_ve0100644 0000000 0000000 00000000222 15172120304 032745 xustar000000000 0000000 118 path=tests/golden_output/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/tests/Foo.java.d 28 mtime=1776853188.5010000 tests/golden_output/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/tests/Fo0100644 0000000 0000000 00000000351 15172120304 032703 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/tests/Foo.java : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-java-source_gen_android_aidl_ve0100644 0000000 0000000 00000000232 15172120304 032746 xustar000000000 0000000 126 path=tests/golden_output/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/tests/IFooInterface.java 28 mtime=1776853188.5010000 tests/golden_output/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/tests/IF0100644 0000000 0000000 00000031054 15172120304 032641 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --rpc --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/tests/IFooInterface.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-java-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/IFooInterface.aidl */ package android.aidl.versioned.tests; public interface IFooInterface extends android.os.IInterface { /** * The version of this interface that the caller is built against. * This might be different from what {@link #getInterfaceVersion() * getInterfaceVersion} returns as that is the version of the interface * that the remote object is implementing. */ public static final int VERSION = 1; public static final String HASH = "9e7be1859820c59d9d55dd133e71a3687b5d2e5b"; /** Default implementation for IFooInterface. */ public static class Default implements android.aidl.versioned.tests.IFooInterface { @Override public void originalApi() throws android.os.RemoteException { } @Override public java.lang.String acceptUnionAndReturnString(android.aidl.versioned.tests.BazUnion u) throws android.os.RemoteException { return null; } @Override public int ignoreParcelablesAndRepeatInt(android.aidl.versioned.tests.Foo inFoo, android.aidl.versioned.tests.Foo inoutFoo, android.aidl.versioned.tests.Foo outFoo, int value) throws android.os.RemoteException { return 0; } @Override public int returnsLengthOfFooArray(android.aidl.versioned.tests.Foo[] foos) throws android.os.RemoteException { return 0; } @Override public int getInterfaceVersion() { return 0; } @Override public String getInterfaceHash() { return ""; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.versioned.tests.IFooInterface { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.versioned.tests.IFooInterface interface, * generating a proxy if needed. */ public static android.aidl.versioned.tests.IFooInterface asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.versioned.tests.IFooInterface))) { return ((android.aidl.versioned.tests.IFooInterface)iin); } return new android.aidl.versioned.tests.IFooInterface.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } else if (code == TRANSACTION_getInterfaceVersion) { reply.writeNoException(); reply.writeInt(getInterfaceVersion()); return true; } else if (code == TRANSACTION_getInterfaceHash) { reply.writeNoException(); reply.writeString(getInterfaceHash()); return true; } switch (code) { case TRANSACTION_originalApi: { this.originalApi(); reply.writeNoException(); break; } case TRANSACTION_acceptUnionAndReturnString: { android.aidl.versioned.tests.BazUnion _arg0; _arg0 = data.readTypedObject(android.aidl.versioned.tests.BazUnion.CREATOR); data.enforceNoDataAvail(); java.lang.String _result = this.acceptUnionAndReturnString(_arg0); reply.writeNoException(); reply.writeString(_result); break; } case TRANSACTION_ignoreParcelablesAndRepeatInt: { android.aidl.versioned.tests.Foo _arg0; _arg0 = data.readTypedObject(android.aidl.versioned.tests.Foo.CREATOR); android.aidl.versioned.tests.Foo _arg1; _arg1 = data.readTypedObject(android.aidl.versioned.tests.Foo.CREATOR); android.aidl.versioned.tests.Foo _arg2; _arg2 = new android.aidl.versioned.tests.Foo(); int _arg3; _arg3 = data.readInt(); data.enforceNoDataAvail(); int _result = this.ignoreParcelablesAndRepeatInt(_arg0, _arg1, _arg2, _arg3); reply.writeNoException(); reply.writeInt(_result); reply.writeTypedObject(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); reply.writeTypedObject(_arg2, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_returnsLengthOfFooArray: { android.aidl.versioned.tests.Foo[] _arg0; _arg0 = data.createTypedArray(android.aidl.versioned.tests.Foo.CREATOR); data.enforceNoDataAvail(); int _result = this.returnsLengthOfFooArray(_arg0); reply.writeNoException(); reply.writeInt(_result); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.versioned.tests.IFooInterface { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } private int mCachedVersion = -1; private String mCachedHash = "-1"; @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public void originalApi() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_originalApi, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method originalApi is unimplemented."); } _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } @Override public java.lang.String acceptUnionAndReturnString(android.aidl.versioned.tests.BazUnion u) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.lang.String _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(u, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_acceptUnionAndReturnString, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method acceptUnionAndReturnString is unimplemented."); } _reply.readException(); _result = _reply.readString(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int ignoreParcelablesAndRepeatInt(android.aidl.versioned.tests.Foo inFoo, android.aidl.versioned.tests.Foo inoutFoo, android.aidl.versioned.tests.Foo outFoo, int value) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); int _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(inFoo, 0); _data.writeTypedObject(inoutFoo, 0); _data.writeInt(value); boolean _status = mRemote.transact(Stub.TRANSACTION_ignoreParcelablesAndRepeatInt, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method ignoreParcelablesAndRepeatInt is unimplemented."); } _reply.readException(); _result = _reply.readInt(); if ((0!=_reply.readInt())) { inoutFoo.readFromParcel(_reply); } if ((0!=_reply.readInt())) { outFoo.readFromParcel(_reply); } } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int returnsLengthOfFooArray(android.aidl.versioned.tests.Foo[] foos) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); int _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedArray(foos, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_returnsLengthOfFooArray, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method returnsLengthOfFooArray is unimplemented."); } _reply.readException(); _result = _reply.readInt(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int getInterfaceVersion() throws android.os.RemoteException { if (mCachedVersion == -1) { android.os.Parcel data = android.os.Parcel.obtain(asBinder()); android.os.Parcel reply = android.os.Parcel.obtain(); try { data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getInterfaceVersion, data, reply, 0); reply.readException(); mCachedVersion = reply.readInt(); } finally { reply.recycle(); data.recycle(); } } return mCachedVersion; } @Override public synchronized String getInterfaceHash() throws android.os.RemoteException { if ("-1".equals(mCachedHash)) { android.os.Parcel data = android.os.Parcel.obtain(asBinder()); android.os.Parcel reply = android.os.Parcel.obtain(); try { data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getInterfaceHash, data, reply, 0); reply.readException(); mCachedHash = reply.readString(); } finally { reply.recycle(); data.recycle(); } } return mCachedHash; } } static final int TRANSACTION_originalApi = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); static final int TRANSACTION_acceptUnionAndReturnString = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1); static final int TRANSACTION_ignoreParcelablesAndRepeatInt = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2); static final int TRANSACTION_returnsLengthOfFooArray = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3); static final int TRANSACTION_getInterfaceVersion = (android.os.IBinder.FIRST_CALL_TRANSACTION + 16777214); static final int TRANSACTION_getInterfaceHash = (android.os.IBinder.FIRST_CALL_TRANSACTION + 16777213); } /** @hide */ public static final java.lang.String DESCRIPTOR = "android$aidl$versioned$tests$IFooInterface".replace('$', '.'); public void originalApi() throws android.os.RemoteException; public java.lang.String acceptUnionAndReturnString(android.aidl.versioned.tests.BazUnion u) throws android.os.RemoteException; public int ignoreParcelablesAndRepeatInt(android.aidl.versioned.tests.Foo inFoo, android.aidl.versioned.tests.Foo inoutFoo, android.aidl.versioned.tests.Foo outFoo, int value) throws android.os.RemoteException; public int returnsLengthOfFooArray(android.aidl.versioned.tests.Foo[] foos) throws android.os.RemoteException; public int getInterfaceVersion() throws android.os.RemoteException; public String getInterfaceHash() throws android.os.RemoteException; } ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-java-source_gen_android_aidl_ve0100644 0000000 0000000 00000000234 15172120304 032750 xustar000000000 0000000 128 path=tests/golden_output/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/tests/IFooInterface.java.d 28 mtime=1776853188.5020000 tests/golden_output/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/tests/IF0100644 0000000 0000000 00000000714 15172120304 032640 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/tests/IFooInterface.java : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/IFooInterface.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-java-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 031646 xustar000000000 0000000 28 mtime=1776853188.5020000 tests/golden_output/aidl-test-versioned-interface-V1-java-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 026640 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-ndk-source_0100644 0000000 0000000 00000000034 15172120304 026724 xustar000000000 0000000 28 mtime=1776853188.5020000 tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/0040755 0000000 0000000 00000000000 15172120304 024011 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-ndk-source_gen_0100644 0000000 0000000 00000000034 15172120304 027555 xustar000000000 0000000 28 mtime=1776853188.5020000 tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/0040755 0000000 0000000 00000000000 15172120304 024562 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-ndk-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 031255 xustar000000000 0000000 28 mtime=1776853188.5020000 tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 026202 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-ndk-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 032246 xustar000000000 0000000 28 mtime=1776853188.5020000 tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 027113 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-ndk-source_gen_android_aidl_ver0100644 0000000 0000000 00000000034 15172120304 032763 xustar000000000 0000000 28 mtime=1776853188.5020000 tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/versioned/0040755 0000000 0000000 00000000000 15172120304 031111 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-ndk-source_gen_android_aidl_ver0100644 0000000 0000000 00000000034 15172120304 032763 xustar000000000 0000000 28 mtime=1776853188.5020000 tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/versioned/tests/0040755 0000000 0000000 00000000000 15172120304 032253 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-ndk-source_gen_android_aidl_ver0100644 0000000 0000000 00000000223 15172120304 032763 xustar000000000 0000000 119 path=tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/versioned/tests/BazUnion.cpp 28 mtime=1776853188.5020000 tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/versioned/tests/Baz0100644 0000000 0000000 00000004252 15172120304 032712 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl */ #include "aidl/android/aidl/versioned/tests/BazUnion.h" #include namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { const char* BazUnion::descriptor = "android.aidl.versioned.tests.BazUnion"; binder_status_t BazUnion::readFromParcel(const AParcel* _parcel) { binder_status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_tag)) != STATUS_OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case intNum: { int32_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } } return STATUS_BAD_VALUE; } binder_status_t BazUnion::writeToParcel(AParcel* _parcel) const { binder_status_t _aidl_ret_status = ::ndk::AParcel_writeData(_parcel, static_cast(getTag())); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; switch (getTag()) { case intNum: return ::ndk::AParcel_writeData(_parcel, get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-ndk-source_gen_android_aidl_ver0100644 0000000 0000000 00000000225 15172120304 032765 xustar000000000 0000000 121 path=tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/versioned/tests/BazUnion.cpp.d 28 mtime=1776853188.5020000 tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/versioned/tests/Baz0100644 0000000 0000000 00000000361 15172120304 032707 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/versioned/tests/BazUnion.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-ndk-source_gen_android_aidl_ver0100644 0000000 0000000 00000000216 15172120304 032765 xustar000000000 0000000 114 path=tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/versioned/tests/Foo.cpp 28 mtime=1776853188.5020000 tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/versioned/tests/Foo0100644 0000000 0000000 00000004336 15172120304 032724 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl */ #include "aidl/android/aidl/versioned/tests/Foo.h" #include namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { const char* Foo::descriptor = "android.aidl.versioned.tests.Foo"; binder_status_t Foo::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t Foo::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-ndk-source_gen_android_aidl_ver0100644 0000000 0000000 00000000220 15172120304 032760 xustar000000000 0000000 116 path=tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/versioned/tests/Foo.cpp.d 28 mtime=1776853188.5020000 tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/versioned/tests/Foo0100644 0000000 0000000 00000000347 15172120304 032722 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/versioned/tests/Foo.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-ndk-source_gen_android_aidl_ver0100644 0000000 0000000 00000000230 15172120304 032761 xustar000000000 0000000 124 path=tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/versioned/tests/IFooInterface.cpp 28 mtime=1776853188.5020000 tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/versioned/tests/IFo0100644 0000000 0000000 00000050350 15172120304 032653 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/IFooInterface.aidl */ #include "aidl/android/aidl/versioned/tests/IFooInterface.h" #include #include #include namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { static binder_status_t _aidl_android_aidl_versioned_tests_IFooInterface_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*originalApi*/): { ::ndk::ScopedAStatus _aidl_status = _aidl_impl->originalApi(); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } case (FIRST_CALL_TRANSACTION + 1 /*acceptUnionAndReturnString*/): { ::aidl::android::aidl::versioned::tests::BazUnion in_u; std::string _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_u); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->acceptUnionAndReturnString(in_u, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 2 /*ignoreParcelablesAndRepeatInt*/): { ::aidl::android::aidl::versioned::tests::Foo in_inFoo; ::aidl::android::aidl::versioned::tests::Foo in_inoutFoo; ::aidl::android::aidl::versioned::tests::Foo out_outFoo; int32_t in_value; int32_t _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_inFoo); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_inoutFoo); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_value); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ignoreParcelablesAndRepeatInt(in_inFoo, &in_inoutFoo, &out_outFoo, in_value, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, in_inoutFoo); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_outFoo); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 3 /*returnsLengthOfFooArray*/): { std::vector<::aidl::android::aidl::versioned::tests::Foo> in_foos; int32_t _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_foos); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->returnsLengthOfFooArray(in_foos, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 16777214 /*getInterfaceVersion*/): { int32_t _aidl_return; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->getInterfaceVersion(&_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 16777213 /*getInterfaceHash*/): { std::string _aidl_return; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->getInterfaceHash(&_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_versioned_tests_IFooInterface_clazz = ::ndk::ICInterface::defineClass(IFooInterface::descriptor, _aidl_android_aidl_versioned_tests_IFooInterface_onTransact); BpFooInterface::BpFooInterface(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} BpFooInterface::~BpFooInterface() {} ::ndk::ScopedAStatus BpFooInterface::originalApi() { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*originalApi*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->originalApi(); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpFooInterface::acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& in_u, std::string* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_u); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 1 /*acceptUnionAndReturnString*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->acceptUnionAndReturnString(in_u, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpFooInterface::ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& in_inFoo, ::aidl::android::aidl::versioned::tests::Foo* in_inoutFoo, ::aidl::android::aidl::versioned::tests::Foo* out_outFoo, int32_t in_value, int32_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_inFoo); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), *in_inoutFoo); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_value); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 2 /*ignoreParcelablesAndRepeatInt*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->ignoreParcelablesAndRepeatInt(in_inFoo, in_inoutFoo, out_outFoo, in_value, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), in_inoutFoo); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_outFoo); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpFooInterface::returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& in_foos, int32_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_foos); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 3 /*returnsLengthOfFooArray*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->returnsLengthOfFooArray(in_foos, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpFooInterface::getInterfaceVersion(int32_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; if (_aidl_cached_version != -1) { *_aidl_return = _aidl_cached_version; _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); return _aidl_status; } ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 16777214 /*getInterfaceVersion*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->getInterfaceVersion(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_cached_version = *_aidl_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpFooInterface::getInterfaceHash(std::string* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; const std::lock_guard lock(_aidl_cached_hash_mutex); if (_aidl_cached_hash != "-1") { *_aidl_return = _aidl_cached_hash; _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); return _aidl_status; } ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 16777213 /*getInterfaceHash*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->getInterfaceHash(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_cached_hash = *_aidl_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } // Source for BnFooInterface BnFooInterface::BnFooInterface() {} BnFooInterface::~BnFooInterface() {} ::ndk::SpAIBinder BnFooInterface::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_versioned_tests_IFooInterface_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } ::ndk::ScopedAStatus BnFooInterface::getInterfaceVersion(int32_t* _aidl_return) { *_aidl_return = IFooInterface::version; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::ScopedAStatus BnFooInterface::getInterfaceHash(std::string* _aidl_return) { *_aidl_return = IFooInterface::hash; return ::ndk::ScopedAStatus(AStatus_newOk()); } // Source for IFooInterface const char* IFooInterface::descriptor = "android.aidl.versioned.tests.IFooInterface"; IFooInterface::IFooInterface() {} IFooInterface::~IFooInterface() {} std::shared_ptr IFooInterface::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_versioned_tests_IFooInterface_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t IFooInterface::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t IFooInterface::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = IFooInterface::fromBinder(binder); return STATUS_OK; } bool IFooInterface::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!IFooInterface::default_impl); if (impl) { IFooInterface::default_impl = impl; return true; } return false; } const std::shared_ptr& IFooInterface::getDefaultImpl() { return IFooInterface::default_impl; } std::shared_ptr IFooInterface::default_impl = nullptr; ::ndk::ScopedAStatus IFooInterfaceDefault::originalApi() { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus IFooInterfaceDefault::acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& /*in_u*/, std::string* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus IFooInterfaceDefault::ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& /*in_inFoo*/, ::aidl::android::aidl::versioned::tests::Foo* /*in_inoutFoo*/, ::aidl::android::aidl::versioned::tests::Foo* /*out_outFoo*/, int32_t /*in_value*/, int32_t* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus IFooInterfaceDefault::returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& /*in_foos*/, int32_t* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus IFooInterfaceDefault::getInterfaceVersion(int32_t* _aidl_return) { *_aidl_return = 0; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::ScopedAStatus IFooInterfaceDefault::getInterfaceHash(std::string* _aidl_return) { *_aidl_return = ""; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::SpAIBinder IFooInterfaceDefault::asBinder() { return ::ndk::SpAIBinder(); } bool IFooInterfaceDefault::isRemote() { return false; } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-ndk-source_gen_android_aidl_ver0100644 0000000 0000000 00000000232 15172120304 032763 xustar000000000 0000000 126 path=tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/versioned/tests/IFooInterface.cpp.d 28 mtime=1776853188.5030000 tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/versioned/tests/IFo0100644 0000000 0000000 00000000712 15172120304 032650 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/versioned/tests/IFooInterface.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/IFooInterface.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-ndk-source_gen_include_0100644 0000000 0000000 00000000034 15172120304 031260 xustar000000000 0000000 28 mtime=1776853188.5030000 tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/include/0040755 0000000 0000000 00000000000 15172120304 026205 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-ndk-source_gen_include_aidl_0100644 0000000 0000000 00000000034 15172120304 032251 xustar000000000 0000000 28 mtime=1776853188.5030000 tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/0040755 0000000 0000000 00000000000 15172120304 027116 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000034 15172120304 032734 xustar000000000 0000000 28 mtime=1776853188.5030000 tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/0040755 0000000 0000000 00000000000 15172120304 030536 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000034 15172120304 032734 xustar000000000 0000000 28 mtime=1776853188.5030000 tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl/0040755 0000000 0000000 00000000000 15172120304 031447 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000216 15172120304 032736 xustar000000000 0000000 114 path=tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl/versioned/ 28 mtime=1776853188.5030000 tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl/versio0040755 0000000 0000000 00000000000 15172120304 032677 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000224 15172120304 032735 xustar000000000 0000000 120 path=tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl/versioned/tests/ 28 mtime=1776853188.5030000 tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl/versio0040755 0000000 0000000 00000000000 15172120304 032677 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000236 15172120304 032740 xustar000000000 0000000 130 path=tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BazUnion.h 28 mtime=1776853188.5030000 tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl/versio0100644 0000000 0000000 00000012233 15172120304 032677 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { class BazUnion { public: typedef std::false_type fixed_size; static const char* descriptor; enum class Tag : int32_t { intNum = 0, }; // Expose tag symbols for legacy code static const inline Tag intNum = Tag::intNum; template static constexpr bool _not_self = !std::is_same_v>, BazUnion>; BazUnion() : _value(std::in_place_index(intNum)>, int32_t(0)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr BazUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit BazUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static BazUnion make(_Tp&&... _args) { return BazUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static BazUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return BazUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } binder_status_t readFromParcel(const AParcel* _parcel); binder_status_t writeToParcel(AParcel* _parcel) const; inline bool operator==(const BazUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const BazUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const BazUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const BazUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const BazUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const BazUnion& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream os; os << "BazUnion{"; switch (getTag()) { case intNum: os << "intNum: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant _value; }; } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { [[nodiscard]] static inline std::string toString(BazUnion::Tag val) { switch(val) { case BazUnion::Tag::intNum: return "intNum"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::versioned::tests::BazUnion::Tag::intNum, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000240 15172120304 032733 xustar000000000 0000000 132 path=tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BnBazUnion.h 28 mtime=1776853188.5030000 tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl/versio0100644 0000000 0000000 00000001432 15172120304 032676 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000233 15172120304 032735 xustar000000000 0000000 127 path=tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BnFoo.h 28 mtime=1776853188.5030000 tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl/versio0100644 0000000 0000000 00000001420 15172120304 032673 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000244 15172120304 032737 xustar000000000 0000000 136 path=tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BnFooInterface.h 28 mtime=1776853188.5030000 tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl/versio0100644 0000000 0000000 00000005765 15172120304 032713 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include "aidl/android/aidl/versioned/tests/IFooInterface.h" #include #include #ifndef __BIONIC__ #ifndef __assert2 #define __assert2(a,b,c,d) ((void)0) #endif #endif namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { class BnFooInterface : public ::ndk::BnCInterface { public: BnFooInterface(); virtual ~BnFooInterface(); ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) final; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) final; protected: ::ndk::SpAIBinder createBinder() override; private: }; class IFooInterfaceDelegator : public BnFooInterface { public: explicit IFooInterfaceDelegator(const std::shared_ptr &impl) : _impl(impl) { int32_t _impl_ver = 0; if (!impl->getInterfaceVersion(&_impl_ver).isOk()) {; __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Delegator failed to get version of the implementation."); } if (_impl_ver != IFooInterface::version) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Mismatched versions of delegator and implementation is not allowed."); } } ::ndk::ScopedAStatus originalApi() override { return _impl->originalApi(); } ::ndk::ScopedAStatus acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& in_u, std::string* _aidl_return) override { return _impl->acceptUnionAndReturnString(in_u, _aidl_return); } ::ndk::ScopedAStatus ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& in_inFoo, ::aidl::android::aidl::versioned::tests::Foo* in_inoutFoo, ::aidl::android::aidl::versioned::tests::Foo* out_outFoo, int32_t in_value, int32_t* _aidl_return) override { return _impl->ignoreParcelablesAndRepeatInt(in_inFoo, in_inoutFoo, out_outFoo, in_value, _aidl_return); } ::ndk::ScopedAStatus returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& in_foos, int32_t* _aidl_return) override { return _impl->returnsLengthOfFooArray(in_foos, _aidl_return); } protected: private: std::shared_ptr _impl; }; } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000240 15172120304 032733 xustar000000000 0000000 132 path=tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BpBazUnion.h 28 mtime=1776853188.5030000 tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl/versio0100644 0000000 0000000 00000001432 15172120304 032676 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000233 15172120304 032735 xustar000000000 0000000 127 path=tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BpFoo.h 28 mtime=1776853188.5030000 tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl/versio0100644 0000000 0000000 00000001420 15172120304 032673 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000244 15172120304 032737 xustar000000000 0000000 136 path=tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BpFooInterface.h 28 mtime=1776853188.5030000 tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl/versio0100644 0000000 0000000 00000004125 15172120304 032700 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include "aidl/android/aidl/versioned/tests/IFooInterface.h" #include namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { class BpFooInterface : public ::ndk::BpCInterface { public: explicit BpFooInterface(const ::ndk::SpAIBinder& binder); virtual ~BpFooInterface(); ::ndk::ScopedAStatus originalApi() override; ::ndk::ScopedAStatus acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& in_u, std::string* _aidl_return) override; ::ndk::ScopedAStatus ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& in_inFoo, ::aidl::android::aidl::versioned::tests::Foo* in_inoutFoo, ::aidl::android::aidl::versioned::tests::Foo* out_outFoo, int32_t in_value, int32_t* _aidl_return) override; ::ndk::ScopedAStatus returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& in_foos, int32_t* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) override; int32_t _aidl_cached_version = -1; std::string _aidl_cached_hash = "-1"; std::mutex _aidl_cached_hash_mutex; }; } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000231 15172120304 032733 xustar000000000 0000000 125 path=tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl/versioned/tests/Foo.h 28 mtime=1776853188.5030000 tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl/versio0100644 0000000 0000000 00000004245 15172120304 032703 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl */ #pragma once #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { class Foo { public: typedef std::false_type fixed_size; static const char* descriptor; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const Foo&) const { return std::tie() == std::tie(); } inline bool operator<(const Foo&) const { return std::tie() < std::tie(); } inline bool operator!=(const Foo& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Foo& _rhs) const { return _rhs < *this; } inline bool operator>=(const Foo& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Foo& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "Foo{"; _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000243 15172120304 032736 xustar000000000 0000000 135 path=tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl/versioned/tests/IFooInterface.h 28 mtime=1776853188.5030000 tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl/versio0100644 0000000 0000000 00000010432 15172120304 032676 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl::android::aidl::versioned::tests { class Foo; } // namespace aidl::android::aidl::versioned::tests namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { class IFooInterfaceDelegator; class IFooInterface : public ::ndk::ICInterface { public: typedef IFooInterfaceDelegator DefaultDelegator; static const char* descriptor; IFooInterface(); virtual ~IFooInterface(); static inline const int32_t version = 1; static inline const std::string hash = "9e7be1859820c59d9d55dd133e71a3687b5d2e5b"; static constexpr uint32_t TRANSACTION_originalApi = FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_acceptUnionAndReturnString = FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_ignoreParcelablesAndRepeatInt = FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_returnsLengthOfFooArray = FIRST_CALL_TRANSACTION + 3; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus originalApi() = 0; virtual ::ndk::ScopedAStatus acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& in_u, std::string* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& in_inFoo, ::aidl::android::aidl::versioned::tests::Foo* in_inoutFoo, ::aidl::android::aidl::versioned::tests::Foo* out_outFoo, int32_t in_value, int32_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& in_foos, int32_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) = 0; private: static std::shared_ptr default_impl; }; class IFooInterfaceDefault : public IFooInterface { public: ::ndk::ScopedAStatus originalApi() override; ::ndk::ScopedAStatus acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& in_u, std::string* _aidl_return) override; ::ndk::ScopedAStatus ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& in_inFoo, ::aidl::android::aidl::versioned::tests::Foo* in_inoutFoo, ::aidl::android::aidl::versioned::tests::Foo* out_outFoo, int32_t in_value, int32_t* _aidl_return) override; ::ndk::ScopedAStatus returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& in_foos, int32_t* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-ndk-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 031501 xustar000000000 0000000 28 mtime=1776853188.5040000 tests/golden_output/aidl-test-versioned-interface-V1-ndk-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 026473 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-rust-source_0100644 0000000 0000000 00000000034 15172120304 027145 xustar000000000 0000000 28 mtime=1776853188.5040000 tests/golden_output/aidl-test-versioned-interface-V1-rust-source/0040755 0000000 0000000 00000000000 15172120304 024232 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-rust-source_gen_0100644 0000000 0000000 00000000034 15172120304 027776 xustar000000000 0000000 28 mtime=1776853188.5040000 tests/golden_output/aidl-test-versioned-interface-V1-rust-source/gen/0040755 0000000 0000000 00000000000 15172120304 025003 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-rust-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 031476 xustar000000000 0000000 28 mtime=1776853188.5040000 tests/golden_output/aidl-test-versioned-interface-V1-rust-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 026423 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-rust-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 032467 xustar000000000 0000000 28 mtime=1776853188.5040000 tests/golden_output/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 027334 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-rust-source_gen_android_aidl_ve0100644 0000000 0000000 00000000034 15172120304 033022 xustar000000000 0000000 28 mtime=1776853188.5040000 tests/golden_output/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/0040755 0000000 0000000 00000000000 15172120304 031332 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-rust-source_gen_android_aidl_ve0100644 0000000 0000000 00000000034 15172120304 033022 xustar000000000 0000000 28 mtime=1776853188.5040000 tests/golden_output/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/tests/0040755 0000000 0000000 00000000000 15172120304 032474 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-rust-source_gen_android_aidl_ve0100644 0000000 0000000 00000000223 15172120304 033022 xustar000000000 0000000 119 path=tests/golden_output/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/tests/BazUnion.rs 28 mtime=1776853188.5040000 tests/golden_output/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/tests/Ba0100644 0000000 0000000 00000004030 15172120304 032733 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/tests/BazUnion.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-rust-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub enum r#BazUnion { IntNum(i32), } impl Default for r#BazUnion { fn default() -> Self { Self::IntNum(0) } } impl binder::Parcelable for r#BazUnion { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { match self { Self::IntNum(v) => { parcel.write(&0i32)?; parcel.write(v) } } } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { let tag: i32 = parcel.read()?; match tag { 0 => { let value: i32 = parcel.read()?; *self = Self::IntNum(value); Ok(()) } _ => { Err(binder::StatusCode::BAD_VALUE) } } } } binder::impl_serialize_for_parcelable!(r#BazUnion); binder::impl_deserialize_for_parcelable!(r#BazUnion); impl binder::binder_impl::ParcelableMetadata for r#BazUnion { fn get_descriptor() -> &'static str { "android.aidl.versioned.tests.BazUnion" } } pub mod r#Tag { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#Tag : [i32; 1] { r#intNum = 0, } } } pub(crate) mod mangled { pub use super::r#BazUnion as _7_android_4_aidl_9_versioned_5_tests_8_BazUnion; pub use super::r#Tag::r#Tag as _7_android_4_aidl_9_versioned_5_tests_8_BazUnion_3_Tag; } ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-rust-source_gen_android_aidl_ve0100644 0000000 0000000 00000000225 15172120304 033024 xustar000000000 0000000 121 path=tests/golden_output/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/tests/BazUnion.rs.d 28 mtime=1776853188.5040000 tests/golden_output/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/tests/Ba0100644 0000000 0000000 00000000361 15172120304 032736 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/tests/BazUnion.rs : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-rust-source_gen_android_aidl_ve0100644 0000000 0000000 00000000216 15172120304 033024 xustar000000000 0000000 114 path=tests/golden_output/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/tests/Foo.rs 28 mtime=1776853188.5040000 tests/golden_output/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/tests/Fo0100644 0000000 0000000 00000002750 15172120304 032764 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/tests/Foo.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-rust-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub struct r#Foo { } impl Default for r#Foo { fn default() -> Self { Self { } } } impl binder::Parcelable for r#Foo { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#Foo); binder::impl_deserialize_for_parcelable!(r#Foo); impl binder::binder_impl::ParcelableMetadata for r#Foo { fn get_descriptor() -> &'static str { "android.aidl.versioned.tests.Foo" } } pub(crate) mod mangled { pub use super::r#Foo as _7_android_4_aidl_9_versioned_5_tests_3_Foo; } ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-rust-source_gen_android_aidl_ve0100644 0000000 0000000 00000000220 15172120304 033017 xustar000000000 0000000 116 path=tests/golden_output/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/tests/Foo.rs.d 28 mtime=1776853188.5040000 tests/golden_output/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/tests/Fo0100644 0000000 0000000 00000000347 15172120304 032764 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/tests/Foo.rs : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-rust-source_gen_android_aidl_ve0100644 0000000 0000000 00000000230 15172120304 033020 xustar000000000 0000000 124 path=tests/golden_output/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/tests/IFooInterface.rs 28 mtime=1776853188.5040000 tests/golden_output/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/tests/IF0100644 0000000 0000000 00000063012 15172120304 032714 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/tests/IFooInterface.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-rust-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/IFooInterface.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { IFooInterface["android.aidl.versioned.tests.IFooInterface"] { native: BnFooInterface(on_transact), proxy: BpFooInterface { cached_version: std::sync::atomic::AtomicI32 = std::sync::atomic::AtomicI32::new(-1), cached_hash: std::sync::Mutex> = std::sync::Mutex::new(None) }, async: IFooInterfaceAsync, } } pub trait IFooInterface: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.versioned.tests.IFooInterface" } fn r#originalApi(&self) -> binder::Result<()>; fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result; fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result; fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result; fn r#getInterfaceVersion(&self) -> binder::Result { Ok(VERSION) } fn r#getInterfaceHash(&self) -> binder::Result { Ok(HASH.into()) } fn getDefaultImpl() -> IFooInterfaceDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: IFooInterfaceDefaultRef) -> IFooInterfaceDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait IFooInterfaceAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.versioned.tests.IFooInterface" } fn r#originalApi<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result<()>>; fn r#acceptUnionAndReturnString<'a>(&'a self, _arg_u: &'a crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::BoxFuture<'a, binder::Result>; fn r#ignoreParcelablesAndRepeatInt<'a>(&'a self, _arg_inFoo: &'a crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &'a mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &'a mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::BoxFuture<'a, binder::Result>; fn r#returnsLengthOfFooArray<'a>(&'a self, _arg_foos: &'a [crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::BoxFuture<'a, binder::Result>; fn r#getInterfaceVersion<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { Box::pin(async move { Ok(VERSION) }) } fn r#getInterfaceHash<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { Box::pin(async move { Ok(HASH.into()) }) } } #[::async_trait::async_trait] pub trait IFooInterfaceAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.versioned.tests.IFooInterface" } async fn r#originalApi(&self) -> binder::Result<()>; async fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result; async fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result; async fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result; } impl BnFooInterface { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: IFooInterfaceAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl IFooInterface for Wrapper where T: IFooInterfaceAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#originalApi(&self) -> binder::Result<()> { self._rt.block_on(self._inner.r#originalApi()) } fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result { self._rt.block_on(self._inner.r#acceptUnionAndReturnString(_arg_u)) } fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result { self._rt.block_on(self._inner.r#ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value)) } fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result { self._rt.block_on(self._inner.r#returnsLengthOfFooArray(_arg_foos)) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait IFooInterfaceDefault: Send + Sync { fn r#originalApi(&self) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#originalApi: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; pub const r#acceptUnionAndReturnString: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 1; pub const r#ignoreParcelablesAndRepeatInt: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 2; pub const r#returnsLengthOfFooArray: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 3; pub const r#getInterfaceVersion: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 16777214; pub const r#getInterfaceHash: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 16777213; } pub type IFooInterfaceDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); pub const VERSION: i32 = 1; pub const HASH: &str = "9e7be1859820c59d9d55dd133e71a3687b5d2e5b"; impl BpFooInterface { fn build_parcel_originalApi(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_originalApi(&self, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#originalApi(); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } Ok(()) } fn build_parcel_acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_u)?; Ok(aidl_data) } fn read_response_acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#acceptUnionAndReturnString(_arg_u); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: String = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_inFoo)?; aidl_data.write(_arg_inoutFoo)?; aidl_data.write(&_arg_value)?; Ok(aidl_data) } fn read_response_ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: i32 = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_inoutFoo)?; _aidl_reply.read_onto(_arg_outFoo)?; Ok(_aidl_return) } fn build_parcel_returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_foos)?; Ok(aidl_data) } fn read_response_returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo], _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#returnsLengthOfFooArray(_arg_foos); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: i32 = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_getInterfaceVersion(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_getInterfaceVersion(&self, _aidl_reply: std::result::Result) -> binder::Result { let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: i32 = _aidl_reply.read()?; self.cached_version.store(_aidl_return, std::sync::atomic::Ordering::Relaxed); Ok(_aidl_return) } fn build_parcel_getInterfaceHash(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_getInterfaceHash(&self, _aidl_reply: std::result::Result) -> binder::Result { let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: String = _aidl_reply.read()?; *self.cached_hash.lock().unwrap() = Some(_aidl_return.clone()); Ok(_aidl_return) } } impl IFooInterface for BpFooInterface { fn r#originalApi(&self) -> binder::Result<()> { let _aidl_data = self.build_parcel_originalApi()?; let _aidl_reply = self.binder.submit_transact(transactions::r#originalApi, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_originalApi(_aidl_reply) } fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result { let _aidl_data = self.build_parcel_acceptUnionAndReturnString(_arg_u)?; let _aidl_reply = self.binder.submit_transact(transactions::r#acceptUnionAndReturnString, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_acceptUnionAndReturnString(_arg_u, _aidl_reply) } fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result { let _aidl_data = self.build_parcel_ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ignoreParcelablesAndRepeatInt, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value, _aidl_reply) } fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result { let _aidl_data = self.build_parcel_returnsLengthOfFooArray(_arg_foos)?; let _aidl_reply = self.binder.submit_transact(transactions::r#returnsLengthOfFooArray, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_returnsLengthOfFooArray(_arg_foos, _aidl_reply) } fn r#getInterfaceVersion(&self) -> binder::Result { let _aidl_version = self.cached_version.load(std::sync::atomic::Ordering::Relaxed); if _aidl_version != -1 { return Ok(_aidl_version); } let _aidl_data = self.build_parcel_getInterfaceVersion()?; let _aidl_reply = self.binder.submit_transact(transactions::r#getInterfaceVersion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_getInterfaceVersion(_aidl_reply) } fn r#getInterfaceHash(&self) -> binder::Result { { let _aidl_hash_lock = self.cached_hash.lock().unwrap(); if let Some(ref _aidl_hash) = *_aidl_hash_lock { return Ok(_aidl_hash.clone()); } } let _aidl_data = self.build_parcel_getInterfaceHash()?; let _aidl_reply = self.binder.submit_transact(transactions::r#getInterfaceHash, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_getInterfaceHash(_aidl_reply) } } impl IFooInterfaceAsync

for BpFooInterface { fn r#originalApi<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_originalApi() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#originalApi, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_originalApi(_aidl_reply) } ) } fn r#acceptUnionAndReturnString<'a>(&'a self, _arg_u: &'a crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_acceptUnionAndReturnString(_arg_u) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#acceptUnionAndReturnString, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_acceptUnionAndReturnString(_arg_u, _aidl_reply) } ) } fn r#ignoreParcelablesAndRepeatInt<'a>(&'a self, _arg_inFoo: &'a crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &'a mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &'a mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ignoreParcelablesAndRepeatInt, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value, _aidl_reply) } ) } fn r#returnsLengthOfFooArray<'a>(&'a self, _arg_foos: &'a [crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_returnsLengthOfFooArray(_arg_foos) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#returnsLengthOfFooArray, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_returnsLengthOfFooArray(_arg_foos, _aidl_reply) } ) } fn r#getInterfaceVersion<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { let _aidl_version = self.cached_version.load(std::sync::atomic::Ordering::Relaxed); if _aidl_version != -1 { return Box::pin(std::future::ready(Ok(_aidl_version))); } let _aidl_data = match self.build_parcel_getInterfaceVersion() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#getInterfaceVersion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_getInterfaceVersion(_aidl_reply) } ) } fn r#getInterfaceHash<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { { let _aidl_hash_lock = self.cached_hash.lock().unwrap(); if let Some(ref _aidl_hash) = *_aidl_hash_lock { return Box::pin(std::future::ready(Ok(_aidl_hash.clone()))); } } let _aidl_data = match self.build_parcel_getInterfaceHash() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#getInterfaceHash, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_getInterfaceHash(_aidl_reply) } ) } } impl IFooInterface for binder::binder_impl::Binder { fn r#originalApi(&self) -> binder::Result<()> { self.0.r#originalApi() } fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result { self.0.r#acceptUnionAndReturnString(_arg_u) } fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result { self.0.r#ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value) } fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result { self.0.r#returnsLengthOfFooArray(_arg_foos) } fn r#getInterfaceVersion(&self) -> binder::Result { self.0.r#getInterfaceVersion() } fn r#getInterfaceHash(&self) -> binder::Result { self.0.r#getInterfaceHash() } } fn on_transact(_aidl_service: &dyn IFooInterface, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#originalApi => { let _aidl_return = _aidl_service.r#originalApi(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#acceptUnionAndReturnString => { let _arg_u: crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion = _aidl_data.read()?; let _aidl_return = _aidl_service.r#acceptUnionAndReturnString(&_arg_u); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ignoreParcelablesAndRepeatInt => { let _arg_inFoo: crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo = _aidl_data.read()?; let mut _arg_inoutFoo: crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo = _aidl_data.read()?; let mut _arg_outFoo: crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo = Default::default(); let _arg_value: i32 = _aidl_data.read()?; let _aidl_return = _aidl_service.r#ignoreParcelablesAndRepeatInt(&_arg_inFoo, &mut _arg_inoutFoo, &mut _arg_outFoo, _arg_value); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_inoutFoo)?; _aidl_reply.write(&_arg_outFoo)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#returnsLengthOfFooArray => { let _arg_foos: Vec = _aidl_data.read()?; let _aidl_return = _aidl_service.r#returnsLengthOfFooArray(&_arg_foos); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#getInterfaceVersion => { let _aidl_return = _aidl_service.r#getInterfaceVersion(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#getInterfaceHash => { let _aidl_return = _aidl_service.r#getInterfaceHash(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } pub(crate) mod mangled { pub use super::r#IFooInterface as _7_android_4_aidl_9_versioned_5_tests_13_IFooInterface; } ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-rust-source_gen_android_aidl_ve0100644 0000000 0000000 00000000232 15172120304 033022 xustar000000000 0000000 126 path=tests/golden_output/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/tests/IFooInterface.rs.d 28 mtime=1776853188.5050000 tests/golden_output/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/tests/IF0100644 0000000 0000000 00000000712 15172120304 032712 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/tests/IFooInterface.rs : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/IFooInterface.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V1-rust-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 031722 xustar000000000 0000000 28 mtime=1776853188.5050000 tests/golden_output/aidl-test-versioned-interface-V1-rust-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 026714 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-cpp-source_0100644 0000000 0000000 00000000034 15172120304 026733 xustar000000000 0000000 28 mtime=1776853188.5050000 tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/0040755 0000000 0000000 00000000000 15172120304 024020 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-cpp-source_gen_0100644 0000000 0000000 00000000034 15172120304 027564 xustar000000000 0000000 28 mtime=1776853188.5050000 tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/0040755 0000000 0000000 00000000000 15172120304 024571 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-cpp-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 031264 xustar000000000 0000000 28 mtime=1776853188.5050000 tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 026211 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-cpp-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 032255 xustar000000000 0000000 28 mtime=1776853188.5050000 tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 027122 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-cpp-source_gen_android_aidl_ver0100644 0000000 0000000 00000000034 15172120304 032772 xustar000000000 0000000 28 mtime=1776853188.5050000 tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/versioned/0040755 0000000 0000000 00000000000 15172120304 031120 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-cpp-source_gen_android_aidl_ver0100644 0000000 0000000 00000000034 15172120304 032772 xustar000000000 0000000 28 mtime=1776853188.5050000 tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/versioned/tests/0040755 0000000 0000000 00000000000 15172120304 032262 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-cpp-source_gen_android_aidl_ver0100644 0000000 0000000 00000000223 15172120304 032772 xustar000000000 0000000 119 path=tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/versioned/tests/BazUnion.cpp 28 mtime=1776853188.5050000 tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/versioned/tests/Baz0100644 0000000 0000000 00000004755 15172120304 032731 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl */ #include namespace android { namespace aidl { namespace versioned { namespace tests { ::android::status_t BazUnion::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_tag)) != ::android::OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case intNum: { int32_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case longNum: { int64_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt64(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } } return ::android::BAD_VALUE; } ::android::status_t BazUnion::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(getTag())); if (_aidl_ret_status != ::android::OK) return _aidl_ret_status; switch (getTag()) { case intNum: return _aidl_parcel->writeInt32(get()); case longNum: return _aidl_parcel->writeInt64(get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-cpp-source_gen_android_aidl_ver0100644 0000000 0000000 00000000225 15172120304 032774 xustar000000000 0000000 121 path=tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/versioned/tests/BazUnion.cpp.d 28 mtime=1776853188.5050000 tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/versioned/tests/Baz0100644 0000000 0000000 00000000361 15172120304 032716 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/versioned/tests/BazUnion.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-cpp-source_gen_android_aidl_ver0100644 0000000 0000000 00000000216 15172120304 032774 xustar000000000 0000000 114 path=tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/versioned/tests/Foo.cpp 28 mtime=1776853188.5050000 tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/versioned/tests/Foo0100644 0000000 0000000 00000005114 15172120304 032726 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl */ #include namespace android { namespace aidl { namespace versioned { namespace tests { ::android::status_t Foo::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&intDefault42); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t Foo::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeInt32(intDefault42); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-cpp-source_gen_android_aidl_ver0100644 0000000 0000000 00000000220 15172120304 032767 xustar000000000 0000000 116 path=tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/versioned/tests/Foo.cpp.d 28 mtime=1776853188.5050000 tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/versioned/tests/Foo0100644 0000000 0000000 00000000347 15172120304 032731 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/versioned/tests/Foo.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-cpp-source_gen_android_aidl_ver0100644 0000000 0000000 00000000230 15172120304 032770 xustar000000000 0000000 124 path=tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/versioned/tests/IFooInterface.cpp 28 mtime=1776853188.5050000 tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/versioned/tests/IFo0100644 0000000 0000000 00000041504 15172120304 032663 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/IFooInterface.aidl */ #include #include namespace android { namespace aidl { namespace versioned { namespace tests { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE(FooInterface, "android.aidl.versioned.tests.IFooInterface") } // namespace tests } // namespace versioned } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace versioned { namespace tests { BpFooInterface::BpFooInterface(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } ::android::binder::Status BpFooInterface::originalApi() { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::originalApi::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnFooInterface::TRANSACTION_originalApi, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) [[unlikely]] { return IFooInterface::getDefaultImpl()->originalApi(); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpFooInterface::acceptUnionAndReturnString(const ::android::aidl::versioned::tests::BazUnion& u, ::std::string* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::acceptUnionAndReturnString::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(u); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnFooInterface::TRANSACTION_acceptUnionAndReturnString, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) [[unlikely]] { return IFooInterface::getDefaultImpl()->acceptUnionAndReturnString(u, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readUtf8FromUtf16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpFooInterface::ignoreParcelablesAndRepeatInt(const ::android::aidl::versioned::tests::Foo& inFoo, ::android::aidl::versioned::tests::Foo* inoutFoo, ::android::aidl::versioned::tests::Foo* outFoo, int32_t value, int32_t* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::ignoreParcelablesAndRepeatInt::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(inFoo); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(*inoutFoo); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeInt32(value); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnFooInterface::TRANSACTION_ignoreParcelablesAndRepeatInt, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) [[unlikely]] { return IFooInterface::getDefaultImpl()->ignoreParcelablesAndRepeatInt(inFoo, inoutFoo, outFoo, value, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readInt32(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readParcelable(inoutFoo); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readParcelable(outFoo); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpFooInterface::returnsLengthOfFooArray(const ::std::vector<::android::aidl::versioned::tests::Foo>& foos, int32_t* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::returnsLengthOfFooArray::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelableVector(foos); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnFooInterface::TRANSACTION_returnsLengthOfFooArray, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) [[unlikely]] { return IFooInterface::getDefaultImpl()->returnsLengthOfFooArray(foos, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readInt32(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpFooInterface::newApi() { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::newApi::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnFooInterface::TRANSACTION_newApi, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) [[unlikely]] { return IFooInterface::getDefaultImpl()->newApi(); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } int32_t BpFooInterface::getInterfaceVersion() { if (cached_version_ == -1) { ::android::Parcel data; ::android::Parcel reply; data.writeInterfaceToken(getInterfaceDescriptor()); ::android::status_t err = remote()->transact(BnFooInterface::TRANSACTION_getInterfaceVersion, data, &reply); if (err == ::android::OK) { ::android::binder::Status _aidl_status; err = _aidl_status.readFromParcel(reply); if (err == ::android::OK && _aidl_status.isOk()) { cached_version_ = reply.readInt32(); } } } return cached_version_; } std::string BpFooInterface::getInterfaceHash() { std::lock_guard lockGuard(cached_hash_mutex_); if (cached_hash_ == "-1") { ::android::Parcel data; ::android::Parcel reply; data.writeInterfaceToken(getInterfaceDescriptor()); ::android::status_t err = remote()->transact(BnFooInterface::TRANSACTION_getInterfaceHash, data, &reply); if (err == ::android::OK) { ::android::binder::Status _aidl_status; err = _aidl_status.readFromParcel(reply); if (err == ::android::OK && _aidl_status.isOk()) { reply.readUtf8FromUtf16(&cached_hash_); } } } return cached_hash_; } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace versioned { namespace tests { BnFooInterface::BnFooInterface() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t BnFooInterface::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnFooInterface::TRANSACTION_originalApi: { if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::originalApi::cppServer"); ::android::binder::Status _aidl_status(originalApi()); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; case BnFooInterface::TRANSACTION_acceptUnionAndReturnString: { ::android::aidl::versioned::tests::BazUnion in_u; ::std::string _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::acceptUnionAndReturnString::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_u); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(acceptUnionAndReturnString(in_u, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeUtf8AsUtf16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnFooInterface::TRANSACTION_ignoreParcelablesAndRepeatInt: { ::android::aidl::versioned::tests::Foo in_inFoo; ::android::aidl::versioned::tests::Foo in_inoutFoo; ::android::aidl::versioned::tests::Foo out_outFoo; int32_t in_value; int32_t _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::ignoreParcelablesAndRepeatInt::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_inFoo); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readParcelable(&in_inoutFoo); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readInt32(&in_value); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ignoreParcelablesAndRepeatInt(in_inFoo, &in_inoutFoo, &out_outFoo, in_value, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeInt32(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(in_inoutFoo); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(out_outFoo); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnFooInterface::TRANSACTION_returnsLengthOfFooArray: { ::std::vector<::android::aidl::versioned::tests::Foo> in_foos; int32_t _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::returnsLengthOfFooArray::cppServer"); _aidl_ret_status = _aidl_data.readParcelableVector(&in_foos); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(returnsLengthOfFooArray(in_foos, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeInt32(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnFooInterface::TRANSACTION_newApi: { if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::newApi::cppServer"); ::android::binder::Status _aidl_status(newApi()); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; case BnFooInterface::TRANSACTION_getInterfaceVersion: { _aidl_data.checkInterface(this); _aidl_reply->writeNoException(); _aidl_reply->writeInt32(IFooInterface::VERSION); } break; case BnFooInterface::TRANSACTION_getInterfaceHash: { _aidl_data.checkInterface(this); _aidl_reply->writeNoException(); _aidl_reply->writeUtf8AsUtf16(IFooInterface::HASH); } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } int32_t BnFooInterface::getInterfaceVersion() { return IFooInterface::VERSION; } std::string BnFooInterface::getInterfaceHash() { return IFooInterface::HASH; } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-cpp-source_gen_android_aidl_ver0100644 0000000 0000000 00000000232 15172120304 032772 xustar000000000 0000000 126 path=tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/versioned/tests/IFooInterface.cpp.d 28 mtime=1776853188.5060000 tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/versioned/tests/IFo0100644 0000000 0000000 00000000712 15172120304 032657 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/versioned/tests/IFooInterface.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/IFooInterface.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-cpp-source_gen_include_0100644 0000000 0000000 00000000034 15172120304 031267 xustar000000000 0000000 28 mtime=1776853188.5060000 tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/include/0040755 0000000 0000000 00000000000 15172120304 026214 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-cpp-source_gen_include_android_0100644 0000000 0000000 00000000034 15172120304 032767 xustar000000000 0000000 28 mtime=1776853188.5060000 tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/0040755 0000000 0000000 00000000000 15172120304 027634 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-cpp-source_gen_include_android_0100644 0000000 0000000 00000000034 15172120304 032767 xustar000000000 0000000 28 mtime=1776853188.5060000 tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/0040755 0000000 0000000 00000000000 15172120304 030545 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-cpp-source_gen_include_android_0100644 0000000 0000000 00000000034 15172120304 032767 xustar000000000 0000000 28 mtime=1776853188.5060000 tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/versioned/0040755 0000000 0000000 00000000000 15172120304 032543 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-cpp-source_gen_include_android_0100644 0000000 0000000 00000000217 15172120304 032772 xustar000000000 0000000 115 path=tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/versioned/tests/ 28 mtime=1776853188.5060000 tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/versioned/t0040755 0000000 0000000 00000000000 15172120304 032727 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-cpp-source_gen_include_android_0100644 0000000 0000000 00000000231 15172120304 032766 xustar000000000 0000000 125 path=tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/versioned/tests/BazUnion.h 28 mtime=1776853188.5060000 tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/versioned/t0100644 0000000 0000000 00000012470 15172120304 032732 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace android { namespace aidl { namespace versioned { namespace tests { class BazUnion : public ::android::Parcelable { public: enum class Tag : int32_t { intNum = 0, longNum = 1, }; // Expose tag symbols for legacy code static const inline Tag intNum = Tag::intNum; static const inline Tag longNum = Tag::longNum; template static constexpr bool _not_self = !std::is_same_v>, BazUnion>; BazUnion() : _value(std::in_place_index(intNum)>, int32_t(0)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr BazUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit BazUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static BazUnion make(_Tp&&... _args) { return BazUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static BazUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return BazUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } inline bool operator==(const BazUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const BazUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const BazUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const BazUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const BazUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const BazUnion& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.versioned.tests.BazUnion"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream os; os << "BazUnion{"; switch (getTag()) { case intNum: os << "intNum: " << ::android::internal::ToString(get()); break; case longNum: os << "longNum: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant _value; }; // class BazUnion } // namespace tests } // namespace versioned } // namespace aidl } // namespace android namespace android { namespace aidl { namespace versioned { namespace tests { [[nodiscard]] static inline std::string toString(BazUnion::Tag val) { switch(val) { case BazUnion::Tag::intNum: return "intNum"; case BazUnion::Tag::longNum: return "longNum"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::versioned::tests::BazUnion::Tag, 2> enum_values<::android::aidl::versioned::tests::BazUnion::Tag> = { ::android::aidl::versioned::tests::BazUnion::Tag::intNum, ::android::aidl::versioned::tests::BazUnion::Tag::longNum, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-cpp-source_gen_include_android_0100644 0000000 0000000 00000000233 15172120304 032770 xustar000000000 0000000 127 path=tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/versioned/tests/BnBazUnion.h 28 mtime=1776853188.5060000 tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/versioned/t0100644 0000000 0000000 00000001432 15172120304 032726 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-cpp-source_gen_include_android_0100644 0000000 0000000 00000000226 15172120304 032772 xustar000000000 0000000 122 path=tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/versioned/tests/BnFoo.h 28 mtime=1776853188.5060000 tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/versioned/t0100644 0000000 0000000 00000001420 15172120304 032723 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-cpp-source_gen_include_android_0100644 0000000 0000000 00000000237 15172120304 032774 xustar000000000 0000000 131 path=tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/versioned/tests/BnFooInterface.h 28 mtime=1776853188.5060000 tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/versioned/t0100644 0000000 0000000 00000007516 15172120304 032737 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace versioned { namespace tests { class BnFooInterface : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_originalApi = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_acceptUnionAndReturnString = ::android::IBinder::FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_ignoreParcelablesAndRepeatInt = ::android::IBinder::FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_returnsLengthOfFooArray = ::android::IBinder::FIRST_CALL_TRANSACTION + 3; static constexpr uint32_t TRANSACTION_newApi = ::android::IBinder::FIRST_CALL_TRANSACTION + 4; static constexpr uint32_t TRANSACTION_getInterfaceVersion = ::android::IBinder::FIRST_CALL_TRANSACTION + 16777214; static constexpr uint32_t TRANSACTION_getInterfaceHash = ::android::IBinder::FIRST_CALL_TRANSACTION + 16777213; explicit BnFooInterface(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; int32_t getInterfaceVersion(); std::string getInterfaceHash(); }; // class BnFooInterface class IFooInterfaceDelegator : public BnFooInterface { public: explicit IFooInterfaceDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status originalApi() override { return _aidl_delegate->originalApi(); } ::android::binder::Status acceptUnionAndReturnString(const ::android::aidl::versioned::tests::BazUnion& u, ::std::string* _aidl_return) override { return _aidl_delegate->acceptUnionAndReturnString(u, _aidl_return); } ::android::binder::Status ignoreParcelablesAndRepeatInt(const ::android::aidl::versioned::tests::Foo& inFoo, ::android::aidl::versioned::tests::Foo* inoutFoo, ::android::aidl::versioned::tests::Foo* outFoo, int32_t value, int32_t* _aidl_return) override { return _aidl_delegate->ignoreParcelablesAndRepeatInt(inFoo, inoutFoo, outFoo, value, _aidl_return); } ::android::binder::Status returnsLengthOfFooArray(const ::std::vector<::android::aidl::versioned::tests::Foo>& foos, int32_t* _aidl_return) override { return _aidl_delegate->returnsLengthOfFooArray(foos, _aidl_return); } ::android::binder::Status newApi() override { return _aidl_delegate->newApi(); } int32_t getInterfaceVersion() override { int32_t _delegator_ver = BnFooInterface::getInterfaceVersion(); int32_t _impl_ver = _aidl_delegate->getInterfaceVersion(); return _delegator_ver < _impl_ver ? _delegator_ver : _impl_ver; } std::string getInterfaceHash() override { return _aidl_delegate->getInterfaceHash(); } private: ::android::sp _aidl_delegate; }; // class IFooInterfaceDelegator } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-cpp-source_gen_include_android_0100644 0000000 0000000 00000000233 15172120304 032770 xustar000000000 0000000 127 path=tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/versioned/tests/BpBazUnion.h 28 mtime=1776853188.5060000 tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/versioned/t0100644 0000000 0000000 00000001432 15172120304 032726 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-cpp-source_gen_include_android_0100644 0000000 0000000 00000000226 15172120304 032772 xustar000000000 0000000 122 path=tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/versioned/tests/BpFoo.h 28 mtime=1776853188.5060000 tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/versioned/t0100644 0000000 0000000 00000001420 15172120304 032723 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-cpp-source_gen_include_android_0100644 0000000 0000000 00000000237 15172120304 032774 xustar000000000 0000000 131 path=tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/versioned/tests/BpFooInterface.h 28 mtime=1776853188.5060000 tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/versioned/t0100644 0000000 0000000 00000004142 15172120304 032727 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace versioned { namespace tests { class BpFooInterface : public ::android::BpInterface { public: explicit BpFooInterface(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpFooInterface() = default; ::android::binder::Status originalApi() override; ::android::binder::Status acceptUnionAndReturnString(const ::android::aidl::versioned::tests::BazUnion& u, ::std::string* _aidl_return) override; ::android::binder::Status ignoreParcelablesAndRepeatInt(const ::android::aidl::versioned::tests::Foo& inFoo, ::android::aidl::versioned::tests::Foo* inoutFoo, ::android::aidl::versioned::tests::Foo* outFoo, int32_t value, int32_t* _aidl_return) override; ::android::binder::Status returnsLengthOfFooArray(const ::std::vector<::android::aidl::versioned::tests::Foo>& foos, int32_t* _aidl_return) override; ::android::binder::Status newApi() override; int32_t getInterfaceVersion() override; std::string getInterfaceHash() override; private: int32_t cached_version_ = -1; std::string cached_hash_ = "-1"; std::mutex cached_hash_mutex_; }; // class BpFooInterface } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-cpp-source_gen_include_android_0100644 0000000 0000000 00000000224 15172120304 032770 xustar000000000 0000000 120 path=tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/versioned/tests/Foo.h 28 mtime=1776853188.5060000 tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/versioned/t0100644 0000000 0000000 00000004402 15172120304 032726 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl */ #pragma once #include #include #include #include #include #include namespace android { namespace aidl { namespace versioned { namespace tests { class Foo : public ::android::Parcelable { public: int32_t intDefault42 = 42; inline bool operator==(const Foo& _rhs) const { return std::tie(intDefault42) == std::tie(_rhs.intDefault42); } inline bool operator<(const Foo& _rhs) const { return std::tie(intDefault42) < std::tie(_rhs.intDefault42); } inline bool operator!=(const Foo& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Foo& _rhs) const { return _rhs < *this; } inline bool operator>=(const Foo& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Foo& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.versioned.tests.Foo"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "Foo{"; _aidl_os << "intDefault42: " << ::android::internal::ToString(intDefault42); _aidl_os << "}"; return _aidl_os.str(); } }; // class Foo } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-cpp-source_gen_include_android_0100644 0000000 0000000 00000000236 15172120304 032773 xustar000000000 0000000 130 path=tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/versioned/tests/IFooInterface.h 28 mtime=1776853188.5070000 tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/versioned/t0100644 0000000 0000000 00000007446 15172120304 032741 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include namespace android::aidl::versioned::tests { class Foo; } // namespace android::aidl::versioned::tests namespace android { namespace aidl { namespace versioned { namespace tests { class IFooInterfaceDelegator; class IFooInterface : public ::android::IInterface { public: typedef IFooInterfaceDelegator DefaultDelegator; DECLARE_META_INTERFACE(FooInterface) static inline const int32_t VERSION = 2; static inline const std::string HASH = "da8c4bc94ca7feff0e0a65563a466787698b5891"; virtual ::android::binder::Status originalApi() = 0; virtual ::android::binder::Status acceptUnionAndReturnString(const ::android::aidl::versioned::tests::BazUnion& u, ::std::string* _aidl_return) = 0; virtual ::android::binder::Status ignoreParcelablesAndRepeatInt(const ::android::aidl::versioned::tests::Foo& inFoo, ::android::aidl::versioned::tests::Foo* inoutFoo, ::android::aidl::versioned::tests::Foo* outFoo, int32_t value, int32_t* _aidl_return) = 0; virtual ::android::binder::Status returnsLengthOfFooArray(const ::std::vector<::android::aidl::versioned::tests::Foo>& foos, int32_t* _aidl_return) = 0; virtual ::android::binder::Status newApi() = 0; virtual int32_t getInterfaceVersion() = 0; virtual std::string getInterfaceHash() = 0; }; // class IFooInterface class IFooInterfaceDefault : public IFooInterface { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status originalApi() override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status acceptUnionAndReturnString(const ::android::aidl::versioned::tests::BazUnion& /*u*/, ::std::string* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ignoreParcelablesAndRepeatInt(const ::android::aidl::versioned::tests::Foo& /*inFoo*/, ::android::aidl::versioned::tests::Foo* /*inoutFoo*/, ::android::aidl::versioned::tests::Foo* /*outFoo*/, int32_t /*value*/, int32_t* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status returnsLengthOfFooArray(const ::std::vector<::android::aidl::versioned::tests::Foo>& /*foos*/, int32_t* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status newApi() override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } int32_t getInterfaceVersion() override { return 0; } std::string getInterfaceHash() override { return ""; } }; // class IFooInterfaceDefault } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-cpp-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 031510 xustar000000000 0000000 28 mtime=1776853188.5070000 tests/golden_output/aidl-test-versioned-interface-V2-cpp-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 026502 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-java-source_0100644 0000000 0000000 00000000034 15172120304 027072 xustar000000000 0000000 28 mtime=1776853188.5070000 tests/golden_output/aidl-test-versioned-interface-V2-java-source/0040755 0000000 0000000 00000000000 15172120304 024157 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-java-source_gen_0100644 0000000 0000000 00000000034 15172120304 027723 xustar000000000 0000000 28 mtime=1776853188.5070000 tests/golden_output/aidl-test-versioned-interface-V2-java-source/gen/0040755 0000000 0000000 00000000000 15172120304 024730 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-java-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 031423 xustar000000000 0000000 28 mtime=1776853188.5070000 tests/golden_output/aidl-test-versioned-interface-V2-java-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 026350 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-java-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 032414 xustar000000000 0000000 28 mtime=1776853188.5070000 tests/golden_output/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 027261 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-java-source_gen_android_aidl_ve0100644 0000000 0000000 00000000034 15172120304 032747 xustar000000000 0000000 28 mtime=1776853188.5070000 tests/golden_output/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/0040755 0000000 0000000 00000000000 15172120304 031257 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-java-source_gen_android_aidl_ve0100644 0000000 0000000 00000000034 15172120304 032747 xustar000000000 0000000 28 mtime=1776853188.5070000 tests/golden_output/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/tests/0040755 0000000 0000000 00000000000 15172120304 032421 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-java-source_gen_android_aidl_ve0100644 0000000 0000000 00000000225 15172120304 032751 xustar000000000 0000000 121 path=tests/golden_output/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/tests/BazUnion.java 28 mtime=1776853188.5070000 tests/golden_output/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/tests/Ba0100644 0000000 0000000 00000007154 15172120304 032672 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --rpc --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/tests/BazUnion.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-java-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl */ package android.aidl.versioned.tests; public final class BazUnion implements android.os.Parcelable { // tags for union fields public final static int intNum = 0; // int intNum; public final static int longNum = 1; // long longNum; private int _tag; private Object _value; public BazUnion() { int _value = 0; this._tag = intNum; this._value = _value; } private BazUnion(android.os.Parcel _aidl_parcel) { readFromParcel(_aidl_parcel); } private BazUnion(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public int getTag() { return _tag; } // int intNum; public static BazUnion intNum(int _value) { return new BazUnion(intNum, _value); } public int getIntNum() { _assertTag(intNum); return (int) _value; } public void setIntNum(int _value) { _set(intNum, _value); } // long longNum; public static BazUnion longNum(long _value) { return new BazUnion(longNum, _value); } public long getLongNum() { _assertTag(longNum); return (long) _value; } public void setLongNum(long _value) { _set(longNum, _value); } public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public BazUnion createFromParcel(android.os.Parcel _aidl_source) { return new BazUnion(_aidl_source); } @Override public BazUnion[] newArray(int _aidl_size) { return new BazUnion[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { _aidl_parcel.writeInt(_tag); switch (_tag) { case intNum: _aidl_parcel.writeInt(getIntNum()); break; case longNum: _aidl_parcel.writeLong(getLongNum()); break; } } public void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_tag; _aidl_tag = _aidl_parcel.readInt(); switch (_aidl_tag) { case intNum: { int _aidl_value; _aidl_value = _aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } case longNum: { long _aidl_value; _aidl_value = _aidl_parcel.readLong(); _set(_aidl_tag, _aidl_value); return; } } throw new IllegalArgumentException("union: unknown tag: " + _aidl_tag); } @Override public int describeContents() { int _mask = 0; switch (getTag()) { } return _mask; } private void _assertTag(int tag) { if (getTag() != tag) { throw new IllegalStateException("bad access: " + _tagString(tag) + ", " + _tagString(getTag()) + " is available."); } } private String _tagString(int _tag) { switch (_tag) { case intNum: return "intNum"; case longNum: return "longNum"; } throw new IllegalStateException("unknown field: " + _tag); } private void _set(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public static @interface Tag { public static final int intNum = 0; public static final int longNum = 1; } } ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-java-source_gen_android_aidl_ve0100644 0000000 0000000 00000000227 15172120304 032753 xustar000000000 0000000 123 path=tests/golden_output/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/tests/BazUnion.java.d 28 mtime=1776853188.5070000 tests/golden_output/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/tests/Ba0100644 0000000 0000000 00000000363 15172120304 032665 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/tests/BazUnion.java : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-java-source_gen_android_aidl_ve0100644 0000000 0000000 00000000220 15172120304 032744 xustar000000000 0000000 116 path=tests/golden_output/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/tests/Foo.java 28 mtime=1776853188.5070000 tests/golden_output/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/tests/Fo0100644 0000000 0000000 00000004501 15172120304 032705 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --rpc --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/tests/Foo.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-java-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl */ package android.aidl.versioned.tests; public class Foo implements android.os.Parcelable { public int intDefault42 = 42; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public Foo createFromParcel(android.os.Parcel _aidl_source) { Foo _aidl_out = new Foo(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public Foo[] newArray(int _aidl_size) { return new Foo[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(intDefault42); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; intDefault42 = _aidl_parcel.readInt(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } } ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-java-source_gen_android_aidl_ve0100644 0000000 0000000 00000000222 15172120304 032746 xustar000000000 0000000 118 path=tests/golden_output/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/tests/Foo.java.d 28 mtime=1776853188.5070000 tests/golden_output/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/tests/Fo0100644 0000000 0000000 00000000351 15172120304 032704 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/tests/Foo.java : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-java-source_gen_android_aidl_ve0100644 0000000 0000000 00000000232 15172120304 032747 xustar000000000 0000000 126 path=tests/golden_output/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/tests/IFooInterface.java 28 mtime=1776853188.5070000 tests/golden_output/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/tests/IF0100644 0000000 0000000 00000033005 15172120304 032640 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --rpc --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/tests/IFooInterface.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-java-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/IFooInterface.aidl */ package android.aidl.versioned.tests; public interface IFooInterface extends android.os.IInterface { /** * The version of this interface that the caller is built against. * This might be different from what {@link #getInterfaceVersion() * getInterfaceVersion} returns as that is the version of the interface * that the remote object is implementing. */ public static final int VERSION = 2; public static final String HASH = "da8c4bc94ca7feff0e0a65563a466787698b5891"; /** Default implementation for IFooInterface. */ public static class Default implements android.aidl.versioned.tests.IFooInterface { @Override public void originalApi() throws android.os.RemoteException { } @Override public java.lang.String acceptUnionAndReturnString(android.aidl.versioned.tests.BazUnion u) throws android.os.RemoteException { return null; } @Override public int ignoreParcelablesAndRepeatInt(android.aidl.versioned.tests.Foo inFoo, android.aidl.versioned.tests.Foo inoutFoo, android.aidl.versioned.tests.Foo outFoo, int value) throws android.os.RemoteException { return 0; } @Override public int returnsLengthOfFooArray(android.aidl.versioned.tests.Foo[] foos) throws android.os.RemoteException { return 0; } @Override public void newApi() throws android.os.RemoteException { } @Override public int getInterfaceVersion() { return 0; } @Override public String getInterfaceHash() { return ""; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.versioned.tests.IFooInterface { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.versioned.tests.IFooInterface interface, * generating a proxy if needed. */ public static android.aidl.versioned.tests.IFooInterface asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.versioned.tests.IFooInterface))) { return ((android.aidl.versioned.tests.IFooInterface)iin); } return new android.aidl.versioned.tests.IFooInterface.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } else if (code == TRANSACTION_getInterfaceVersion) { reply.writeNoException(); reply.writeInt(getInterfaceVersion()); return true; } else if (code == TRANSACTION_getInterfaceHash) { reply.writeNoException(); reply.writeString(getInterfaceHash()); return true; } switch (code) { case TRANSACTION_originalApi: { this.originalApi(); reply.writeNoException(); break; } case TRANSACTION_acceptUnionAndReturnString: { android.aidl.versioned.tests.BazUnion _arg0; _arg0 = data.readTypedObject(android.aidl.versioned.tests.BazUnion.CREATOR); data.enforceNoDataAvail(); java.lang.String _result = this.acceptUnionAndReturnString(_arg0); reply.writeNoException(); reply.writeString(_result); break; } case TRANSACTION_ignoreParcelablesAndRepeatInt: { android.aidl.versioned.tests.Foo _arg0; _arg0 = data.readTypedObject(android.aidl.versioned.tests.Foo.CREATOR); android.aidl.versioned.tests.Foo _arg1; _arg1 = data.readTypedObject(android.aidl.versioned.tests.Foo.CREATOR); android.aidl.versioned.tests.Foo _arg2; _arg2 = new android.aidl.versioned.tests.Foo(); int _arg3; _arg3 = data.readInt(); data.enforceNoDataAvail(); int _result = this.ignoreParcelablesAndRepeatInt(_arg0, _arg1, _arg2, _arg3); reply.writeNoException(); reply.writeInt(_result); reply.writeTypedObject(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); reply.writeTypedObject(_arg2, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_returnsLengthOfFooArray: { android.aidl.versioned.tests.Foo[] _arg0; _arg0 = data.createTypedArray(android.aidl.versioned.tests.Foo.CREATOR); data.enforceNoDataAvail(); int _result = this.returnsLengthOfFooArray(_arg0); reply.writeNoException(); reply.writeInt(_result); break; } case TRANSACTION_newApi: { this.newApi(); reply.writeNoException(); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.versioned.tests.IFooInterface { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } private int mCachedVersion = -1; private String mCachedHash = "-1"; @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public void originalApi() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_originalApi, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method originalApi is unimplemented."); } _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } @Override public java.lang.String acceptUnionAndReturnString(android.aidl.versioned.tests.BazUnion u) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.lang.String _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(u, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_acceptUnionAndReturnString, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method acceptUnionAndReturnString is unimplemented."); } _reply.readException(); _result = _reply.readString(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int ignoreParcelablesAndRepeatInt(android.aidl.versioned.tests.Foo inFoo, android.aidl.versioned.tests.Foo inoutFoo, android.aidl.versioned.tests.Foo outFoo, int value) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); int _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(inFoo, 0); _data.writeTypedObject(inoutFoo, 0); _data.writeInt(value); boolean _status = mRemote.transact(Stub.TRANSACTION_ignoreParcelablesAndRepeatInt, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method ignoreParcelablesAndRepeatInt is unimplemented."); } _reply.readException(); _result = _reply.readInt(); if ((0!=_reply.readInt())) { inoutFoo.readFromParcel(_reply); } if ((0!=_reply.readInt())) { outFoo.readFromParcel(_reply); } } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int returnsLengthOfFooArray(android.aidl.versioned.tests.Foo[] foos) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); int _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedArray(foos, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_returnsLengthOfFooArray, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method returnsLengthOfFooArray is unimplemented."); } _reply.readException(); _result = _reply.readInt(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public void newApi() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_newApi, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method newApi is unimplemented."); } _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } @Override public int getInterfaceVersion() throws android.os.RemoteException { if (mCachedVersion == -1) { android.os.Parcel data = android.os.Parcel.obtain(asBinder()); android.os.Parcel reply = android.os.Parcel.obtain(); try { data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getInterfaceVersion, data, reply, 0); reply.readException(); mCachedVersion = reply.readInt(); } finally { reply.recycle(); data.recycle(); } } return mCachedVersion; } @Override public synchronized String getInterfaceHash() throws android.os.RemoteException { if ("-1".equals(mCachedHash)) { android.os.Parcel data = android.os.Parcel.obtain(asBinder()); android.os.Parcel reply = android.os.Parcel.obtain(); try { data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getInterfaceHash, data, reply, 0); reply.readException(); mCachedHash = reply.readString(); } finally { reply.recycle(); data.recycle(); } } return mCachedHash; } } static final int TRANSACTION_originalApi = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); static final int TRANSACTION_acceptUnionAndReturnString = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1); static final int TRANSACTION_ignoreParcelablesAndRepeatInt = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2); static final int TRANSACTION_returnsLengthOfFooArray = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3); static final int TRANSACTION_newApi = (android.os.IBinder.FIRST_CALL_TRANSACTION + 4); static final int TRANSACTION_getInterfaceVersion = (android.os.IBinder.FIRST_CALL_TRANSACTION + 16777214); static final int TRANSACTION_getInterfaceHash = (android.os.IBinder.FIRST_CALL_TRANSACTION + 16777213); } /** @hide */ public static final java.lang.String DESCRIPTOR = "android$aidl$versioned$tests$IFooInterface".replace('$', '.'); public void originalApi() throws android.os.RemoteException; public java.lang.String acceptUnionAndReturnString(android.aidl.versioned.tests.BazUnion u) throws android.os.RemoteException; public int ignoreParcelablesAndRepeatInt(android.aidl.versioned.tests.Foo inFoo, android.aidl.versioned.tests.Foo inoutFoo, android.aidl.versioned.tests.Foo outFoo, int value) throws android.os.RemoteException; public int returnsLengthOfFooArray(android.aidl.versioned.tests.Foo[] foos) throws android.os.RemoteException; public void newApi() throws android.os.RemoteException; public int getInterfaceVersion() throws android.os.RemoteException; public String getInterfaceHash() throws android.os.RemoteException; } ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-java-source_gen_android_aidl_ve0100644 0000000 0000000 00000000234 15172120304 032751 xustar000000000 0000000 128 path=tests/golden_output/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/tests/IFooInterface.java.d 28 mtime=1776853188.5080000 tests/golden_output/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/tests/IF0100644 0000000 0000000 00000000714 15172120304 032641 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/tests/IFooInterface.java : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/IFooInterface.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-java-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 031647 xustar000000000 0000000 28 mtime=1776853188.5080000 tests/golden_output/aidl-test-versioned-interface-V2-java-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 026641 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-ndk-source_0100644 0000000 0000000 00000000034 15172120304 026725 xustar000000000 0000000 28 mtime=1776853188.5080000 tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/0040755 0000000 0000000 00000000000 15172120304 024012 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-ndk-source_gen_0100644 0000000 0000000 00000000034 15172120304 027556 xustar000000000 0000000 28 mtime=1776853188.5080000 tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/0040755 0000000 0000000 00000000000 15172120304 024563 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-ndk-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 031256 xustar000000000 0000000 28 mtime=1776853188.5080000 tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 026203 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-ndk-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 032247 xustar000000000 0000000 28 mtime=1776853188.5080000 tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 027114 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-ndk-source_gen_android_aidl_ver0100644 0000000 0000000 00000000034 15172120304 032764 xustar000000000 0000000 28 mtime=1776853188.5080000 tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/versioned/0040755 0000000 0000000 00000000000 15172120304 031112 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-ndk-source_gen_android_aidl_ver0100644 0000000 0000000 00000000034 15172120304 032764 xustar000000000 0000000 28 mtime=1776853188.5080000 tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/versioned/tests/0040755 0000000 0000000 00000000000 15172120304 032254 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-ndk-source_gen_android_aidl_ver0100644 0000000 0000000 00000000223 15172120304 032764 xustar000000000 0000000 119 path=tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/versioned/tests/BazUnion.cpp 28 mtime=1776853188.5080000 tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/versioned/tests/Baz0100644 0000000 0000000 00000005171 15172120304 032714 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl */ #include "aidl/android/aidl/versioned/tests/BazUnion.h" #include namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { const char* BazUnion::descriptor = "android.aidl.versioned.tests.BazUnion"; binder_status_t BazUnion::readFromParcel(const AParcel* _parcel) { binder_status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_tag)) != STATUS_OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case intNum: { int32_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case longNum: { int64_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } } return STATUS_BAD_VALUE; } binder_status_t BazUnion::writeToParcel(AParcel* _parcel) const { binder_status_t _aidl_ret_status = ::ndk::AParcel_writeData(_parcel, static_cast(getTag())); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; switch (getTag()) { case intNum: return ::ndk::AParcel_writeData(_parcel, get()); case longNum: return ::ndk::AParcel_writeData(_parcel, get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-ndk-source_gen_android_aidl_ver0100644 0000000 0000000 00000000225 15172120304 032766 xustar000000000 0000000 121 path=tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/versioned/tests/BazUnion.cpp.d 28 mtime=1776853188.5080000 tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/versioned/tests/Baz0100644 0000000 0000000 00000000361 15172120304 032710 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/versioned/tests/BazUnion.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-ndk-source_gen_android_aidl_ver0100644 0000000 0000000 00000000216 15172120304 032766 xustar000000000 0000000 114 path=tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/versioned/tests/Foo.cpp 28 mtime=1776853188.5080000 tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/versioned/tests/Foo0100644 0000000 0000000 00000005301 15172120304 032716 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl */ #include "aidl/android/aidl/versioned/tests/Foo.h" #include namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { const char* Foo::descriptor = "android.aidl.versioned.tests.Foo"; binder_status_t Foo::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &intDefault42); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t Foo::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, intDefault42); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-ndk-source_gen_android_aidl_ver0100644 0000000 0000000 00000000220 15172120304 032761 xustar000000000 0000000 116 path=tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/versioned/tests/Foo.cpp.d 28 mtime=1776853188.5080000 tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/versioned/tests/Foo0100644 0000000 0000000 00000000347 15172120304 032723 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/versioned/tests/Foo.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-ndk-source_gen_android_aidl_ver0100644 0000000 0000000 00000000230 15172120304 032762 xustar000000000 0000000 124 path=tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/versioned/tests/IFooInterface.cpp 28 mtime=1776853188.5080000 tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/versioned/tests/IFo0100644 0000000 0000000 00000053573 15172120304 032666 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/IFooInterface.aidl */ #include "aidl/android/aidl/versioned/tests/IFooInterface.h" #include #include #include namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { static binder_status_t _aidl_android_aidl_versioned_tests_IFooInterface_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*originalApi*/): { ::ndk::ScopedAStatus _aidl_status = _aidl_impl->originalApi(); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } case (FIRST_CALL_TRANSACTION + 1 /*acceptUnionAndReturnString*/): { ::aidl::android::aidl::versioned::tests::BazUnion in_u; std::string _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_u); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->acceptUnionAndReturnString(in_u, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 2 /*ignoreParcelablesAndRepeatInt*/): { ::aidl::android::aidl::versioned::tests::Foo in_inFoo; ::aidl::android::aidl::versioned::tests::Foo in_inoutFoo; ::aidl::android::aidl::versioned::tests::Foo out_outFoo; int32_t in_value; int32_t _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_inFoo); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_inoutFoo); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_value); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ignoreParcelablesAndRepeatInt(in_inFoo, &in_inoutFoo, &out_outFoo, in_value, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, in_inoutFoo); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_outFoo); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 3 /*returnsLengthOfFooArray*/): { std::vector<::aidl::android::aidl::versioned::tests::Foo> in_foos; int32_t _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_foos); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->returnsLengthOfFooArray(in_foos, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 4 /*newApi*/): { ::ndk::ScopedAStatus _aidl_status = _aidl_impl->newApi(); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } case (FIRST_CALL_TRANSACTION + 16777214 /*getInterfaceVersion*/): { int32_t _aidl_return; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->getInterfaceVersion(&_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 16777213 /*getInterfaceHash*/): { std::string _aidl_return; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->getInterfaceHash(&_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_versioned_tests_IFooInterface_clazz = ::ndk::ICInterface::defineClass(IFooInterface::descriptor, _aidl_android_aidl_versioned_tests_IFooInterface_onTransact); BpFooInterface::BpFooInterface(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} BpFooInterface::~BpFooInterface() {} ::ndk::ScopedAStatus BpFooInterface::originalApi() { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*originalApi*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->originalApi(); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpFooInterface::acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& in_u, std::string* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_u); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 1 /*acceptUnionAndReturnString*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->acceptUnionAndReturnString(in_u, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpFooInterface::ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& in_inFoo, ::aidl::android::aidl::versioned::tests::Foo* in_inoutFoo, ::aidl::android::aidl::versioned::tests::Foo* out_outFoo, int32_t in_value, int32_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_inFoo); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), *in_inoutFoo); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_value); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 2 /*ignoreParcelablesAndRepeatInt*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->ignoreParcelablesAndRepeatInt(in_inFoo, in_inoutFoo, out_outFoo, in_value, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), in_inoutFoo); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_outFoo); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpFooInterface::returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& in_foos, int32_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_foos); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 3 /*returnsLengthOfFooArray*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->returnsLengthOfFooArray(in_foos, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpFooInterface::newApi() { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 4 /*newApi*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->newApi(); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpFooInterface::getInterfaceVersion(int32_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; if (_aidl_cached_version != -1) { *_aidl_return = _aidl_cached_version; _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); return _aidl_status; } ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 16777214 /*getInterfaceVersion*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->getInterfaceVersion(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_cached_version = *_aidl_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpFooInterface::getInterfaceHash(std::string* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; const std::lock_guard lock(_aidl_cached_hash_mutex); if (_aidl_cached_hash != "-1") { *_aidl_return = _aidl_cached_hash; _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); return _aidl_status; } ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 16777213 /*getInterfaceHash*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->getInterfaceHash(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_cached_hash = *_aidl_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } // Source for BnFooInterface BnFooInterface::BnFooInterface() {} BnFooInterface::~BnFooInterface() {} ::ndk::SpAIBinder BnFooInterface::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_versioned_tests_IFooInterface_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } ::ndk::ScopedAStatus BnFooInterface::getInterfaceVersion(int32_t* _aidl_return) { *_aidl_return = IFooInterface::version; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::ScopedAStatus BnFooInterface::getInterfaceHash(std::string* _aidl_return) { *_aidl_return = IFooInterface::hash; return ::ndk::ScopedAStatus(AStatus_newOk()); } // Source for IFooInterface const char* IFooInterface::descriptor = "android.aidl.versioned.tests.IFooInterface"; IFooInterface::IFooInterface() {} IFooInterface::~IFooInterface() {} std::shared_ptr IFooInterface::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_versioned_tests_IFooInterface_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t IFooInterface::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t IFooInterface::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = IFooInterface::fromBinder(binder); return STATUS_OK; } bool IFooInterface::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!IFooInterface::default_impl); if (impl) { IFooInterface::default_impl = impl; return true; } return false; } const std::shared_ptr& IFooInterface::getDefaultImpl() { return IFooInterface::default_impl; } std::shared_ptr IFooInterface::default_impl = nullptr; ::ndk::ScopedAStatus IFooInterfaceDefault::originalApi() { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus IFooInterfaceDefault::acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& /*in_u*/, std::string* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus IFooInterfaceDefault::ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& /*in_inFoo*/, ::aidl::android::aidl::versioned::tests::Foo* /*in_inoutFoo*/, ::aidl::android::aidl::versioned::tests::Foo* /*out_outFoo*/, int32_t /*in_value*/, int32_t* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus IFooInterfaceDefault::returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& /*in_foos*/, int32_t* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus IFooInterfaceDefault::newApi() { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus IFooInterfaceDefault::getInterfaceVersion(int32_t* _aidl_return) { *_aidl_return = 0; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::ScopedAStatus IFooInterfaceDefault::getInterfaceHash(std::string* _aidl_return) { *_aidl_return = ""; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::SpAIBinder IFooInterfaceDefault::asBinder() { return ::ndk::SpAIBinder(); } bool IFooInterfaceDefault::isRemote() { return false; } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-ndk-source_gen_android_aidl_ver0100644 0000000 0000000 00000000232 15172120304 032764 xustar000000000 0000000 126 path=tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/versioned/tests/IFooInterface.cpp.d 28 mtime=1776853188.5090000 tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/versioned/tests/IFo0100644 0000000 0000000 00000000712 15172120304 032651 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/versioned/tests/IFooInterface.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/IFooInterface.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-ndk-source_gen_include_0100644 0000000 0000000 00000000034 15172120304 031261 xustar000000000 0000000 28 mtime=1776853188.5090000 tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/include/0040755 0000000 0000000 00000000000 15172120304 026206 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-ndk-source_gen_include_aidl_0100644 0000000 0000000 00000000034 15172120304 032252 xustar000000000 0000000 28 mtime=1776853188.5090000 tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/0040755 0000000 0000000 00000000000 15172120304 027117 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000034 15172120304 032735 xustar000000000 0000000 28 mtime=1776853188.5090000 tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/0040755 0000000 0000000 00000000000 15172120304 030537 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000034 15172120304 032735 xustar000000000 0000000 28 mtime=1776853188.5090000 tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl/0040755 0000000 0000000 00000000000 15172120304 031450 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000216 15172120304 032737 xustar000000000 0000000 114 path=tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl/versioned/ 28 mtime=1776853188.5090000 tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl/versio0040755 0000000 0000000 00000000000 15172120304 032700 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000224 15172120304 032736 xustar000000000 0000000 120 path=tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl/versioned/tests/ 28 mtime=1776853188.5090000 tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl/versio0040755 0000000 0000000 00000000000 15172120304 032700 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000236 15172120304 032741 xustar000000000 0000000 130 path=tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BazUnion.h 28 mtime=1776853188.5090000 tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl/versio0100644 0000000 0000000 00000012672 15172120304 032707 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { class BazUnion { public: typedef std::false_type fixed_size; static const char* descriptor; enum class Tag : int32_t { intNum = 0, longNum = 1, }; // Expose tag symbols for legacy code static const inline Tag intNum = Tag::intNum; static const inline Tag longNum = Tag::longNum; template static constexpr bool _not_self = !std::is_same_v>, BazUnion>; BazUnion() : _value(std::in_place_index(intNum)>, int32_t(0)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr BazUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit BazUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static BazUnion make(_Tp&&... _args) { return BazUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static BazUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return BazUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } binder_status_t readFromParcel(const AParcel* _parcel); binder_status_t writeToParcel(AParcel* _parcel) const; inline bool operator==(const BazUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const BazUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const BazUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const BazUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const BazUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const BazUnion& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream os; os << "BazUnion{"; switch (getTag()) { case intNum: os << "intNum: " << ::android::internal::ToString(get()); break; case longNum: os << "longNum: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant _value; }; } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { [[nodiscard]] static inline std::string toString(BazUnion::Tag val) { switch(val) { case BazUnion::Tag::intNum: return "intNum"; case BazUnion::Tag::longNum: return "longNum"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::versioned::tests::BazUnion::Tag::intNum, aidl::android::aidl::versioned::tests::BazUnion::Tag::longNum, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000240 15172120304 032734 xustar000000000 0000000 132 path=tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BnBazUnion.h 28 mtime=1776853188.5100000 tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl/versio0100644 0000000 0000000 00000001432 15172120304 032677 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000233 15172120304 032736 xustar000000000 0000000 127 path=tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BnFoo.h 28 mtime=1776853188.5100000 tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl/versio0100644 0000000 0000000 00000001420 15172120304 032674 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000244 15172120304 032740 xustar000000000 0000000 136 path=tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BnFooInterface.h 28 mtime=1776853188.5100000 tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl/versio0100644 0000000 0000000 00000006100 15172120304 032674 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include "aidl/android/aidl/versioned/tests/IFooInterface.h" #include #include #ifndef __BIONIC__ #ifndef __assert2 #define __assert2(a,b,c,d) ((void)0) #endif #endif namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { class BnFooInterface : public ::ndk::BnCInterface { public: BnFooInterface(); virtual ~BnFooInterface(); ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) final; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) final; protected: ::ndk::SpAIBinder createBinder() override; private: }; class IFooInterfaceDelegator : public BnFooInterface { public: explicit IFooInterfaceDelegator(const std::shared_ptr &impl) : _impl(impl) { int32_t _impl_ver = 0; if (!impl->getInterfaceVersion(&_impl_ver).isOk()) {; __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Delegator failed to get version of the implementation."); } if (_impl_ver != IFooInterface::version) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Mismatched versions of delegator and implementation is not allowed."); } } ::ndk::ScopedAStatus originalApi() override { return _impl->originalApi(); } ::ndk::ScopedAStatus acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& in_u, std::string* _aidl_return) override { return _impl->acceptUnionAndReturnString(in_u, _aidl_return); } ::ndk::ScopedAStatus ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& in_inFoo, ::aidl::android::aidl::versioned::tests::Foo* in_inoutFoo, ::aidl::android::aidl::versioned::tests::Foo* out_outFoo, int32_t in_value, int32_t* _aidl_return) override { return _impl->ignoreParcelablesAndRepeatInt(in_inFoo, in_inoutFoo, out_outFoo, in_value, _aidl_return); } ::ndk::ScopedAStatus returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& in_foos, int32_t* _aidl_return) override { return _impl->returnsLengthOfFooArray(in_foos, _aidl_return); } ::ndk::ScopedAStatus newApi() override { return _impl->newApi(); } protected: private: std::shared_ptr _impl; }; } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000240 15172120304 032734 xustar000000000 0000000 132 path=tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BpBazUnion.h 28 mtime=1776853188.5100000 tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl/versio0100644 0000000 0000000 00000001432 15172120304 032677 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000233 15172120304 032736 xustar000000000 0000000 127 path=tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BpFoo.h 28 mtime=1776853188.5100000 tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl/versio0100644 0000000 0000000 00000001420 15172120304 032674 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000244 15172120304 032740 xustar000000000 0000000 136 path=tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BpFooInterface.h 28 mtime=1776853188.5100000 tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl/versio0100644 0000000 0000000 00000004177 15172120304 032710 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include "aidl/android/aidl/versioned/tests/IFooInterface.h" #include namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { class BpFooInterface : public ::ndk::BpCInterface { public: explicit BpFooInterface(const ::ndk::SpAIBinder& binder); virtual ~BpFooInterface(); ::ndk::ScopedAStatus originalApi() override; ::ndk::ScopedAStatus acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& in_u, std::string* _aidl_return) override; ::ndk::ScopedAStatus ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& in_inFoo, ::aidl::android::aidl::versioned::tests::Foo* in_inoutFoo, ::aidl::android::aidl::versioned::tests::Foo* out_outFoo, int32_t in_value, int32_t* _aidl_return) override; ::ndk::ScopedAStatus returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& in_foos, int32_t* _aidl_return) override; ::ndk::ScopedAStatus newApi() override; ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) override; int32_t _aidl_cached_version = -1; std::string _aidl_cached_hash = "-1"; std::mutex _aidl_cached_hash_mutex; }; } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000231 15172120304 032734 xustar000000000 0000000 125 path=tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl/versioned/tests/Foo.h 28 mtime=1776853188.5100000 tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl/versio0100644 0000000 0000000 00000004527 15172120304 032707 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl */ #pragma once #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { class Foo { public: typedef std::false_type fixed_size; static const char* descriptor; int32_t intDefault42 = 42; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const Foo& _rhs) const { return std::tie(intDefault42) == std::tie(_rhs.intDefault42); } inline bool operator<(const Foo& _rhs) const { return std::tie(intDefault42) < std::tie(_rhs.intDefault42); } inline bool operator!=(const Foo& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Foo& _rhs) const { return _rhs < *this; } inline bool operator>=(const Foo& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Foo& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "Foo{"; _aidl_os << "intDefault42: " << ::android::internal::ToString(intDefault42); _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000243 15172120304 032737 xustar000000000 0000000 135 path=tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl/versioned/tests/IFooInterface.h 28 mtime=1776853188.5110000 tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl/versio0100644 0000000 0000000 00000010676 15172120304 032711 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl::android::aidl::versioned::tests { class Foo; } // namespace aidl::android::aidl::versioned::tests namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { class IFooInterfaceDelegator; class IFooInterface : public ::ndk::ICInterface { public: typedef IFooInterfaceDelegator DefaultDelegator; static const char* descriptor; IFooInterface(); virtual ~IFooInterface(); static inline const int32_t version = 2; static inline const std::string hash = "da8c4bc94ca7feff0e0a65563a466787698b5891"; static constexpr uint32_t TRANSACTION_originalApi = FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_acceptUnionAndReturnString = FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_ignoreParcelablesAndRepeatInt = FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_returnsLengthOfFooArray = FIRST_CALL_TRANSACTION + 3; static constexpr uint32_t TRANSACTION_newApi = FIRST_CALL_TRANSACTION + 4; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus originalApi() = 0; virtual ::ndk::ScopedAStatus acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& in_u, std::string* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& in_inFoo, ::aidl::android::aidl::versioned::tests::Foo* in_inoutFoo, ::aidl::android::aidl::versioned::tests::Foo* out_outFoo, int32_t in_value, int32_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& in_foos, int32_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus newApi() = 0; virtual ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) = 0; private: static std::shared_ptr default_impl; }; class IFooInterfaceDefault : public IFooInterface { public: ::ndk::ScopedAStatus originalApi() override; ::ndk::ScopedAStatus acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& in_u, std::string* _aidl_return) override; ::ndk::ScopedAStatus ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& in_inFoo, ::aidl::android::aidl::versioned::tests::Foo* in_inoutFoo, ::aidl::android::aidl::versioned::tests::Foo* out_outFoo, int32_t in_value, int32_t* _aidl_return) override; ::ndk::ScopedAStatus returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& in_foos, int32_t* _aidl_return) override; ::ndk::ScopedAStatus newApi() override; ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-ndk-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 031502 xustar000000000 0000000 28 mtime=1776853188.5110000 tests/golden_output/aidl-test-versioned-interface-V2-ndk-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 026474 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-rust-source_0100644 0000000 0000000 00000000034 15172120304 027146 xustar000000000 0000000 28 mtime=1776853188.5110000 tests/golden_output/aidl-test-versioned-interface-V2-rust-source/0040755 0000000 0000000 00000000000 15172120304 024233 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-rust-source_gen_0100644 0000000 0000000 00000000034 15172120304 027777 xustar000000000 0000000 28 mtime=1776853188.5110000 tests/golden_output/aidl-test-versioned-interface-V2-rust-source/gen/0040755 0000000 0000000 00000000000 15172120304 025004 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-rust-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 031477 xustar000000000 0000000 28 mtime=1776853188.5110000 tests/golden_output/aidl-test-versioned-interface-V2-rust-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 026424 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-rust-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 032470 xustar000000000 0000000 28 mtime=1776853188.5110000 tests/golden_output/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 027335 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-rust-source_gen_android_aidl_ve0100644 0000000 0000000 00000000034 15172120304 033023 xustar000000000 0000000 28 mtime=1776853188.5110000 tests/golden_output/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/0040755 0000000 0000000 00000000000 15172120304 031333 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-rust-source_gen_android_aidl_ve0100644 0000000 0000000 00000000034 15172120304 033023 xustar000000000 0000000 28 mtime=1776853188.5110000 tests/golden_output/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/tests/0040755 0000000 0000000 00000000000 15172120304 032475 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-rust-source_gen_android_aidl_ve0100644 0000000 0000000 00000000223 15172120304 033023 xustar000000000 0000000 119 path=tests/golden_output/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/tests/BazUnion.rs 28 mtime=1776853188.5110000 tests/golden_output/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/tests/Ba0100644 0000000 0000000 00000004412 15172120304 032740 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/tests/BazUnion.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-rust-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub enum r#BazUnion { IntNum(i32), LongNum(i64), } impl Default for r#BazUnion { fn default() -> Self { Self::IntNum(0) } } impl binder::Parcelable for r#BazUnion { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { match self { Self::IntNum(v) => { parcel.write(&0i32)?; parcel.write(v) } Self::LongNum(v) => { parcel.write(&1i32)?; parcel.write(v) } } } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { let tag: i32 = parcel.read()?; match tag { 0 => { let value: i32 = parcel.read()?; *self = Self::IntNum(value); Ok(()) } 1 => { let value: i64 = parcel.read()?; *self = Self::LongNum(value); Ok(()) } _ => { Err(binder::StatusCode::BAD_VALUE) } } } } binder::impl_serialize_for_parcelable!(r#BazUnion); binder::impl_deserialize_for_parcelable!(r#BazUnion); impl binder::binder_impl::ParcelableMetadata for r#BazUnion { fn get_descriptor() -> &'static str { "android.aidl.versioned.tests.BazUnion" } } pub mod r#Tag { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#Tag : [i32; 2] { r#intNum = 0, r#longNum = 1, } } } pub(crate) mod mangled { pub use super::r#BazUnion as _7_android_4_aidl_9_versioned_5_tests_8_BazUnion; pub use super::r#Tag::r#Tag as _7_android_4_aidl_9_versioned_5_tests_8_BazUnion_3_Tag; } ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-rust-source_gen_android_aidl_ve0100644 0000000 0000000 00000000225 15172120304 033025 xustar000000000 0000000 121 path=tests/golden_output/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/tests/BazUnion.rs.d 28 mtime=1776853188.5110000 tests/golden_output/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/tests/Ba0100644 0000000 0000000 00000000361 15172120304 032737 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/tests/BazUnion.rs : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-rust-source_gen_android_aidl_ve0100644 0000000 0000000 00000000216 15172120304 033025 xustar000000000 0000000 114 path=tests/golden_output/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/tests/Foo.rs 28 mtime=1776853188.5110000 tests/golden_output/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/tests/Fo0100644 0000000 0000000 00000003251 15172120304 032762 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/tests/Foo.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-rust-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub struct r#Foo { pub r#intDefault42: i32, } impl Default for r#Foo { fn default() -> Self { Self { r#intDefault42: 42, } } } impl binder::Parcelable for r#Foo { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#intDefault42)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#intDefault42 = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#Foo); binder::impl_deserialize_for_parcelable!(r#Foo); impl binder::binder_impl::ParcelableMetadata for r#Foo { fn get_descriptor() -> &'static str { "android.aidl.versioned.tests.Foo" } } pub(crate) mod mangled { pub use super::r#Foo as _7_android_4_aidl_9_versioned_5_tests_3_Foo; } ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-rust-source_gen_android_aidl_ve0100644 0000000 0000000 00000000220 15172120304 033020 xustar000000000 0000000 116 path=tests/golden_output/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/tests/Foo.rs.d 28 mtime=1776853188.5110000 tests/golden_output/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/tests/Fo0100644 0000000 0000000 00000000347 15172120304 032765 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/tests/Foo.rs : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-rust-source_gen_android_aidl_ve0100644 0000000 0000000 00000000230 15172120304 033021 xustar000000000 0000000 124 path=tests/golden_output/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/tests/IFooInterface.rs 28 mtime=1776853188.5110000 tests/golden_output/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/tests/IF0100644 0000000 0000000 00000067453 15172120304 032732 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/tests/IFooInterface.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-rust-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/IFooInterface.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { IFooInterface["android.aidl.versioned.tests.IFooInterface"] { native: BnFooInterface(on_transact), proxy: BpFooInterface { cached_version: std::sync::atomic::AtomicI32 = std::sync::atomic::AtomicI32::new(-1), cached_hash: std::sync::Mutex> = std::sync::Mutex::new(None) }, async: IFooInterfaceAsync, } } pub trait IFooInterface: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.versioned.tests.IFooInterface" } fn r#originalApi(&self) -> binder::Result<()>; fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result; fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result; fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result; fn r#newApi(&self) -> binder::Result<()>; fn r#getInterfaceVersion(&self) -> binder::Result { Ok(VERSION) } fn r#getInterfaceHash(&self) -> binder::Result { Ok(HASH.into()) } fn getDefaultImpl() -> IFooInterfaceDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: IFooInterfaceDefaultRef) -> IFooInterfaceDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait IFooInterfaceAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.versioned.tests.IFooInterface" } fn r#originalApi<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result<()>>; fn r#acceptUnionAndReturnString<'a>(&'a self, _arg_u: &'a crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::BoxFuture<'a, binder::Result>; fn r#ignoreParcelablesAndRepeatInt<'a>(&'a self, _arg_inFoo: &'a crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &'a mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &'a mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::BoxFuture<'a, binder::Result>; fn r#returnsLengthOfFooArray<'a>(&'a self, _arg_foos: &'a [crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::BoxFuture<'a, binder::Result>; fn r#newApi<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result<()>>; fn r#getInterfaceVersion<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { Box::pin(async move { Ok(VERSION) }) } fn r#getInterfaceHash<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { Box::pin(async move { Ok(HASH.into()) }) } } #[::async_trait::async_trait] pub trait IFooInterfaceAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.versioned.tests.IFooInterface" } async fn r#originalApi(&self) -> binder::Result<()>; async fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result; async fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result; async fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result; async fn r#newApi(&self) -> binder::Result<()>; } impl BnFooInterface { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: IFooInterfaceAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl IFooInterface for Wrapper where T: IFooInterfaceAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#originalApi(&self) -> binder::Result<()> { self._rt.block_on(self._inner.r#originalApi()) } fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result { self._rt.block_on(self._inner.r#acceptUnionAndReturnString(_arg_u)) } fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result { self._rt.block_on(self._inner.r#ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value)) } fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result { self._rt.block_on(self._inner.r#returnsLengthOfFooArray(_arg_foos)) } fn r#newApi(&self) -> binder::Result<()> { self._rt.block_on(self._inner.r#newApi()) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait IFooInterfaceDefault: Send + Sync { fn r#originalApi(&self) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#newApi(&self) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#originalApi: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; pub const r#acceptUnionAndReturnString: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 1; pub const r#ignoreParcelablesAndRepeatInt: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 2; pub const r#returnsLengthOfFooArray: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 3; pub const r#newApi: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 4; pub const r#getInterfaceVersion: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 16777214; pub const r#getInterfaceHash: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 16777213; } pub type IFooInterfaceDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); pub const VERSION: i32 = 2; pub const HASH: &str = "da8c4bc94ca7feff0e0a65563a466787698b5891"; impl BpFooInterface { fn build_parcel_originalApi(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_originalApi(&self, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#originalApi(); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } Ok(()) } fn build_parcel_acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_u)?; Ok(aidl_data) } fn read_response_acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#acceptUnionAndReturnString(_arg_u); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: String = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_inFoo)?; aidl_data.write(_arg_inoutFoo)?; aidl_data.write(&_arg_value)?; Ok(aidl_data) } fn read_response_ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: i32 = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_inoutFoo)?; _aidl_reply.read_onto(_arg_outFoo)?; Ok(_aidl_return) } fn build_parcel_returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_foos)?; Ok(aidl_data) } fn read_response_returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo], _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#returnsLengthOfFooArray(_arg_foos); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: i32 = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_newApi(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_newApi(&self, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#newApi(); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } Ok(()) } fn build_parcel_getInterfaceVersion(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_getInterfaceVersion(&self, _aidl_reply: std::result::Result) -> binder::Result { let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: i32 = _aidl_reply.read()?; self.cached_version.store(_aidl_return, std::sync::atomic::Ordering::Relaxed); Ok(_aidl_return) } fn build_parcel_getInterfaceHash(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_getInterfaceHash(&self, _aidl_reply: std::result::Result) -> binder::Result { let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: String = _aidl_reply.read()?; *self.cached_hash.lock().unwrap() = Some(_aidl_return.clone()); Ok(_aidl_return) } } impl IFooInterface for BpFooInterface { fn r#originalApi(&self) -> binder::Result<()> { let _aidl_data = self.build_parcel_originalApi()?; let _aidl_reply = self.binder.submit_transact(transactions::r#originalApi, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_originalApi(_aidl_reply) } fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result { let _aidl_data = self.build_parcel_acceptUnionAndReturnString(_arg_u)?; let _aidl_reply = self.binder.submit_transact(transactions::r#acceptUnionAndReturnString, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_acceptUnionAndReturnString(_arg_u, _aidl_reply) } fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result { let _aidl_data = self.build_parcel_ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ignoreParcelablesAndRepeatInt, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value, _aidl_reply) } fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result { let _aidl_data = self.build_parcel_returnsLengthOfFooArray(_arg_foos)?; let _aidl_reply = self.binder.submit_transact(transactions::r#returnsLengthOfFooArray, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_returnsLengthOfFooArray(_arg_foos, _aidl_reply) } fn r#newApi(&self) -> binder::Result<()> { let _aidl_data = self.build_parcel_newApi()?; let _aidl_reply = self.binder.submit_transact(transactions::r#newApi, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_newApi(_aidl_reply) } fn r#getInterfaceVersion(&self) -> binder::Result { let _aidl_version = self.cached_version.load(std::sync::atomic::Ordering::Relaxed); if _aidl_version != -1 { return Ok(_aidl_version); } let _aidl_data = self.build_parcel_getInterfaceVersion()?; let _aidl_reply = self.binder.submit_transact(transactions::r#getInterfaceVersion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_getInterfaceVersion(_aidl_reply) } fn r#getInterfaceHash(&self) -> binder::Result { { let _aidl_hash_lock = self.cached_hash.lock().unwrap(); if let Some(ref _aidl_hash) = *_aidl_hash_lock { return Ok(_aidl_hash.clone()); } } let _aidl_data = self.build_parcel_getInterfaceHash()?; let _aidl_reply = self.binder.submit_transact(transactions::r#getInterfaceHash, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_getInterfaceHash(_aidl_reply) } } impl IFooInterfaceAsync

for BpFooInterface { fn r#originalApi<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_originalApi() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#originalApi, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_originalApi(_aidl_reply) } ) } fn r#acceptUnionAndReturnString<'a>(&'a self, _arg_u: &'a crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_acceptUnionAndReturnString(_arg_u) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#acceptUnionAndReturnString, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_acceptUnionAndReturnString(_arg_u, _aidl_reply) } ) } fn r#ignoreParcelablesAndRepeatInt<'a>(&'a self, _arg_inFoo: &'a crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &'a mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &'a mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ignoreParcelablesAndRepeatInt, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value, _aidl_reply) } ) } fn r#returnsLengthOfFooArray<'a>(&'a self, _arg_foos: &'a [crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_returnsLengthOfFooArray(_arg_foos) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#returnsLengthOfFooArray, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_returnsLengthOfFooArray(_arg_foos, _aidl_reply) } ) } fn r#newApi<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_newApi() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#newApi, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_newApi(_aidl_reply) } ) } fn r#getInterfaceVersion<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { let _aidl_version = self.cached_version.load(std::sync::atomic::Ordering::Relaxed); if _aidl_version != -1 { return Box::pin(std::future::ready(Ok(_aidl_version))); } let _aidl_data = match self.build_parcel_getInterfaceVersion() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#getInterfaceVersion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_getInterfaceVersion(_aidl_reply) } ) } fn r#getInterfaceHash<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { { let _aidl_hash_lock = self.cached_hash.lock().unwrap(); if let Some(ref _aidl_hash) = *_aidl_hash_lock { return Box::pin(std::future::ready(Ok(_aidl_hash.clone()))); } } let _aidl_data = match self.build_parcel_getInterfaceHash() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#getInterfaceHash, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_getInterfaceHash(_aidl_reply) } ) } } impl IFooInterface for binder::binder_impl::Binder { fn r#originalApi(&self) -> binder::Result<()> { self.0.r#originalApi() } fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result { self.0.r#acceptUnionAndReturnString(_arg_u) } fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result { self.0.r#ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value) } fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result { self.0.r#returnsLengthOfFooArray(_arg_foos) } fn r#newApi(&self) -> binder::Result<()> { self.0.r#newApi() } fn r#getInterfaceVersion(&self) -> binder::Result { self.0.r#getInterfaceVersion() } fn r#getInterfaceHash(&self) -> binder::Result { self.0.r#getInterfaceHash() } } fn on_transact(_aidl_service: &dyn IFooInterface, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#originalApi => { let _aidl_return = _aidl_service.r#originalApi(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#acceptUnionAndReturnString => { let _arg_u: crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion = _aidl_data.read()?; let _aidl_return = _aidl_service.r#acceptUnionAndReturnString(&_arg_u); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ignoreParcelablesAndRepeatInt => { let _arg_inFoo: crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo = _aidl_data.read()?; let mut _arg_inoutFoo: crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo = _aidl_data.read()?; let mut _arg_outFoo: crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo = Default::default(); let _arg_value: i32 = _aidl_data.read()?; let _aidl_return = _aidl_service.r#ignoreParcelablesAndRepeatInt(&_arg_inFoo, &mut _arg_inoutFoo, &mut _arg_outFoo, _arg_value); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_inoutFoo)?; _aidl_reply.write(&_arg_outFoo)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#returnsLengthOfFooArray => { let _arg_foos: Vec = _aidl_data.read()?; let _aidl_return = _aidl_service.r#returnsLengthOfFooArray(&_arg_foos); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#newApi => { let _aidl_return = _aidl_service.r#newApi(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#getInterfaceVersion => { let _aidl_return = _aidl_service.r#getInterfaceVersion(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#getInterfaceHash => { let _aidl_return = _aidl_service.r#getInterfaceHash(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } pub(crate) mod mangled { pub use super::r#IFooInterface as _7_android_4_aidl_9_versioned_5_tests_13_IFooInterface; } ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-rust-source_gen_android_aidl_ve0100644 0000000 0000000 00000000232 15172120304 033023 xustar000000000 0000000 126 path=tests/golden_output/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/tests/IFooInterface.rs.d 28 mtime=1776853188.5120000 tests/golden_output/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/tests/IF0100644 0000000 0000000 00000000712 15172120304 032713 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/tests/IFooInterface.rs : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/IFooInterface.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V2-rust-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 031723 xustar000000000 0000000 28 mtime=1776853188.5120000 tests/golden_output/aidl-test-versioned-interface-V2-rust-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 026715 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-cpp-source_0100644 0000000 0000000 00000000034 15172120304 026734 xustar000000000 0000000 28 mtime=1776853188.5120000 tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/0040755 0000000 0000000 00000000000 15172120304 024021 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-cpp-source_gen_0100644 0000000 0000000 00000000034 15172120304 027565 xustar000000000 0000000 28 mtime=1776853188.5120000 tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/0040755 0000000 0000000 00000000000 15172120304 024572 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-cpp-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 031265 xustar000000000 0000000 28 mtime=1776853188.5120000 tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 026212 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-cpp-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 032256 xustar000000000 0000000 28 mtime=1776853188.5120000 tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 027123 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-cpp-source_gen_android_aidl_ver0100644 0000000 0000000 00000000034 15172120304 032773 xustar000000000 0000000 28 mtime=1776853188.5120000 tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/versioned/0040755 0000000 0000000 00000000000 15172120304 031121 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-cpp-source_gen_android_aidl_ver0100644 0000000 0000000 00000000034 15172120304 032773 xustar000000000 0000000 28 mtime=1776853188.5120000 tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/versioned/tests/0040755 0000000 0000000 00000000000 15172120304 032263 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-cpp-source_gen_android_aidl_ver0100644 0000000 0000000 00000000223 15172120304 032773 xustar000000000 0000000 119 path=tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/versioned/tests/BazUnion.cpp 28 mtime=1776853188.5120000 tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/versioned/tests/Baz0100644 0000000 0000000 00000004755 15172120304 032732 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl */ #include namespace android { namespace aidl { namespace versioned { namespace tests { ::android::status_t BazUnion::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_tag)) != ::android::OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case intNum: { int32_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case longNum: { int64_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt64(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } } return ::android::BAD_VALUE; } ::android::status_t BazUnion::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(getTag())); if (_aidl_ret_status != ::android::OK) return _aidl_ret_status; switch (getTag()) { case intNum: return _aidl_parcel->writeInt32(get()); case longNum: return _aidl_parcel->writeInt64(get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-cpp-source_gen_android_aidl_ver0100644 0000000 0000000 00000000225 15172120304 032775 xustar000000000 0000000 121 path=tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/versioned/tests/BazUnion.cpp.d 28 mtime=1776853188.5120000 tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/versioned/tests/Baz0100644 0000000 0000000 00000000361 15172120304 032717 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/versioned/tests/BazUnion.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-cpp-source_gen_android_aidl_ver0100644 0000000 0000000 00000000216 15172120304 032775 xustar000000000 0000000 114 path=tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/versioned/tests/Foo.cpp 28 mtime=1776853188.5120000 tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/versioned/tests/Foo0100644 0000000 0000000 00000005114 15172120304 032727 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl */ #include namespace android { namespace aidl { namespace versioned { namespace tests { ::android::status_t Foo::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&intDefault42); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t Foo::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeInt32(intDefault42); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-cpp-source_gen_android_aidl_ver0100644 0000000 0000000 00000000220 15172120304 032770 xustar000000000 0000000 116 path=tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/versioned/tests/Foo.cpp.d 28 mtime=1776853188.5120000 tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/versioned/tests/Foo0100644 0000000 0000000 00000000347 15172120304 032732 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/versioned/tests/Foo.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-cpp-source_gen_android_aidl_ver0100644 0000000 0000000 00000000230 15172120304 032771 xustar000000000 0000000 124 path=tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/versioned/tests/IFooInterface.cpp 28 mtime=1776853188.5120000 tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/versioned/tests/IFo0100644 0000000 0000000 00000041504 15172120304 032664 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/IFooInterface.aidl */ #include #include namespace android { namespace aidl { namespace versioned { namespace tests { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE(FooInterface, "android.aidl.versioned.tests.IFooInterface") } // namespace tests } // namespace versioned } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace versioned { namespace tests { BpFooInterface::BpFooInterface(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } ::android::binder::Status BpFooInterface::originalApi() { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::originalApi::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnFooInterface::TRANSACTION_originalApi, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) [[unlikely]] { return IFooInterface::getDefaultImpl()->originalApi(); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpFooInterface::acceptUnionAndReturnString(const ::android::aidl::versioned::tests::BazUnion& u, ::std::string* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::acceptUnionAndReturnString::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(u); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnFooInterface::TRANSACTION_acceptUnionAndReturnString, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) [[unlikely]] { return IFooInterface::getDefaultImpl()->acceptUnionAndReturnString(u, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readUtf8FromUtf16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpFooInterface::ignoreParcelablesAndRepeatInt(const ::android::aidl::versioned::tests::Foo& inFoo, ::android::aidl::versioned::tests::Foo* inoutFoo, ::android::aidl::versioned::tests::Foo* outFoo, int32_t value, int32_t* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::ignoreParcelablesAndRepeatInt::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(inFoo); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(*inoutFoo); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeInt32(value); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnFooInterface::TRANSACTION_ignoreParcelablesAndRepeatInt, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) [[unlikely]] { return IFooInterface::getDefaultImpl()->ignoreParcelablesAndRepeatInt(inFoo, inoutFoo, outFoo, value, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readInt32(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readParcelable(inoutFoo); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readParcelable(outFoo); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpFooInterface::returnsLengthOfFooArray(const ::std::vector<::android::aidl::versioned::tests::Foo>& foos, int32_t* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::returnsLengthOfFooArray::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelableVector(foos); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnFooInterface::TRANSACTION_returnsLengthOfFooArray, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) [[unlikely]] { return IFooInterface::getDefaultImpl()->returnsLengthOfFooArray(foos, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readInt32(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpFooInterface::newApi() { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::newApi::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnFooInterface::TRANSACTION_newApi, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) [[unlikely]] { return IFooInterface::getDefaultImpl()->newApi(); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } int32_t BpFooInterface::getInterfaceVersion() { if (cached_version_ == -1) { ::android::Parcel data; ::android::Parcel reply; data.writeInterfaceToken(getInterfaceDescriptor()); ::android::status_t err = remote()->transact(BnFooInterface::TRANSACTION_getInterfaceVersion, data, &reply); if (err == ::android::OK) { ::android::binder::Status _aidl_status; err = _aidl_status.readFromParcel(reply); if (err == ::android::OK && _aidl_status.isOk()) { cached_version_ = reply.readInt32(); } } } return cached_version_; } std::string BpFooInterface::getInterfaceHash() { std::lock_guard lockGuard(cached_hash_mutex_); if (cached_hash_ == "-1") { ::android::Parcel data; ::android::Parcel reply; data.writeInterfaceToken(getInterfaceDescriptor()); ::android::status_t err = remote()->transact(BnFooInterface::TRANSACTION_getInterfaceHash, data, &reply); if (err == ::android::OK) { ::android::binder::Status _aidl_status; err = _aidl_status.readFromParcel(reply); if (err == ::android::OK && _aidl_status.isOk()) { reply.readUtf8FromUtf16(&cached_hash_); } } } return cached_hash_; } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace versioned { namespace tests { BnFooInterface::BnFooInterface() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t BnFooInterface::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnFooInterface::TRANSACTION_originalApi: { if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::originalApi::cppServer"); ::android::binder::Status _aidl_status(originalApi()); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; case BnFooInterface::TRANSACTION_acceptUnionAndReturnString: { ::android::aidl::versioned::tests::BazUnion in_u; ::std::string _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::acceptUnionAndReturnString::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_u); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(acceptUnionAndReturnString(in_u, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeUtf8AsUtf16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnFooInterface::TRANSACTION_ignoreParcelablesAndRepeatInt: { ::android::aidl::versioned::tests::Foo in_inFoo; ::android::aidl::versioned::tests::Foo in_inoutFoo; ::android::aidl::versioned::tests::Foo out_outFoo; int32_t in_value; int32_t _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::ignoreParcelablesAndRepeatInt::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_inFoo); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readParcelable(&in_inoutFoo); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readInt32(&in_value); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ignoreParcelablesAndRepeatInt(in_inFoo, &in_inoutFoo, &out_outFoo, in_value, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeInt32(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(in_inoutFoo); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(out_outFoo); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnFooInterface::TRANSACTION_returnsLengthOfFooArray: { ::std::vector<::android::aidl::versioned::tests::Foo> in_foos; int32_t _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::returnsLengthOfFooArray::cppServer"); _aidl_ret_status = _aidl_data.readParcelableVector(&in_foos); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(returnsLengthOfFooArray(in_foos, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeInt32(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnFooInterface::TRANSACTION_newApi: { if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::newApi::cppServer"); ::android::binder::Status _aidl_status(newApi()); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; case BnFooInterface::TRANSACTION_getInterfaceVersion: { _aidl_data.checkInterface(this); _aidl_reply->writeNoException(); _aidl_reply->writeInt32(IFooInterface::VERSION); } break; case BnFooInterface::TRANSACTION_getInterfaceHash: { _aidl_data.checkInterface(this); _aidl_reply->writeNoException(); _aidl_reply->writeUtf8AsUtf16(IFooInterface::HASH); } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } int32_t BnFooInterface::getInterfaceVersion() { return IFooInterface::VERSION; } std::string BnFooInterface::getInterfaceHash() { return IFooInterface::HASH; } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-cpp-source_gen_android_aidl_ver0100644 0000000 0000000 00000000232 15172120304 032773 xustar000000000 0000000 126 path=tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/versioned/tests/IFooInterface.cpp.d 28 mtime=1776853188.5120000 tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/versioned/tests/IFo0100644 0000000 0000000 00000000712 15172120304 032660 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/versioned/tests/IFooInterface.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/IFooInterface.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-cpp-source_gen_include_0100644 0000000 0000000 00000000034 15172120304 031270 xustar000000000 0000000 28 mtime=1776853188.5120000 tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/include/0040755 0000000 0000000 00000000000 15172120304 026215 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-cpp-source_gen_include_android_0100644 0000000 0000000 00000000034 15172120304 032770 xustar000000000 0000000 28 mtime=1776853188.5120000 tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/0040755 0000000 0000000 00000000000 15172120304 027635 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-cpp-source_gen_include_android_0100644 0000000 0000000 00000000034 15172120304 032770 xustar000000000 0000000 28 mtime=1776853188.5120000 tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/0040755 0000000 0000000 00000000000 15172120304 030546 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-cpp-source_gen_include_android_0100644 0000000 0000000 00000000034 15172120304 032770 xustar000000000 0000000 28 mtime=1776853188.5120000 tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/versioned/0040755 0000000 0000000 00000000000 15172120304 032544 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-cpp-source_gen_include_android_0100644 0000000 0000000 00000000217 15172120304 032773 xustar000000000 0000000 115 path=tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/versioned/tests/ 28 mtime=1776853188.5130000 tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/versioned/t0040755 0000000 0000000 00000000000 15172120304 032730 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-cpp-source_gen_include_android_0100644 0000000 0000000 00000000231 15172120304 032767 xustar000000000 0000000 125 path=tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/versioned/tests/BazUnion.h 28 mtime=1776853188.5130000 tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/versioned/t0100644 0000000 0000000 00000012470 15172120304 032733 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace android { namespace aidl { namespace versioned { namespace tests { class BazUnion : public ::android::Parcelable { public: enum class Tag : int32_t { intNum = 0, longNum = 1, }; // Expose tag symbols for legacy code static const inline Tag intNum = Tag::intNum; static const inline Tag longNum = Tag::longNum; template static constexpr bool _not_self = !std::is_same_v>, BazUnion>; BazUnion() : _value(std::in_place_index(intNum)>, int32_t(0)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr BazUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit BazUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static BazUnion make(_Tp&&... _args) { return BazUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static BazUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return BazUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } inline bool operator==(const BazUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const BazUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const BazUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const BazUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const BazUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const BazUnion& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.versioned.tests.BazUnion"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream os; os << "BazUnion{"; switch (getTag()) { case intNum: os << "intNum: " << ::android::internal::ToString(get()); break; case longNum: os << "longNum: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant _value; }; // class BazUnion } // namespace tests } // namespace versioned } // namespace aidl } // namespace android namespace android { namespace aidl { namespace versioned { namespace tests { [[nodiscard]] static inline std::string toString(BazUnion::Tag val) { switch(val) { case BazUnion::Tag::intNum: return "intNum"; case BazUnion::Tag::longNum: return "longNum"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::versioned::tests::BazUnion::Tag, 2> enum_values<::android::aidl::versioned::tests::BazUnion::Tag> = { ::android::aidl::versioned::tests::BazUnion::Tag::intNum, ::android::aidl::versioned::tests::BazUnion::Tag::longNum, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-cpp-source_gen_include_android_0100644 0000000 0000000 00000000233 15172120304 032771 xustar000000000 0000000 127 path=tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/versioned/tests/BnBazUnion.h 28 mtime=1776853188.5130000 tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/versioned/t0100644 0000000 0000000 00000001432 15172120304 032727 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-cpp-source_gen_include_android_0100644 0000000 0000000 00000000226 15172120304 032773 xustar000000000 0000000 122 path=tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/versioned/tests/BnFoo.h 28 mtime=1776853188.5130000 tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/versioned/t0100644 0000000 0000000 00000001420 15172120304 032724 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-cpp-source_gen_include_android_0100644 0000000 0000000 00000000237 15172120304 032775 xustar000000000 0000000 131 path=tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/versioned/tests/BnFooInterface.h 28 mtime=1776853188.5130000 tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/versioned/t0100644 0000000 0000000 00000007516 15172120304 032740 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace versioned { namespace tests { class BnFooInterface : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_originalApi = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_acceptUnionAndReturnString = ::android::IBinder::FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_ignoreParcelablesAndRepeatInt = ::android::IBinder::FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_returnsLengthOfFooArray = ::android::IBinder::FIRST_CALL_TRANSACTION + 3; static constexpr uint32_t TRANSACTION_newApi = ::android::IBinder::FIRST_CALL_TRANSACTION + 4; static constexpr uint32_t TRANSACTION_getInterfaceVersion = ::android::IBinder::FIRST_CALL_TRANSACTION + 16777214; static constexpr uint32_t TRANSACTION_getInterfaceHash = ::android::IBinder::FIRST_CALL_TRANSACTION + 16777213; explicit BnFooInterface(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; int32_t getInterfaceVersion(); std::string getInterfaceHash(); }; // class BnFooInterface class IFooInterfaceDelegator : public BnFooInterface { public: explicit IFooInterfaceDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status originalApi() override { return _aidl_delegate->originalApi(); } ::android::binder::Status acceptUnionAndReturnString(const ::android::aidl::versioned::tests::BazUnion& u, ::std::string* _aidl_return) override { return _aidl_delegate->acceptUnionAndReturnString(u, _aidl_return); } ::android::binder::Status ignoreParcelablesAndRepeatInt(const ::android::aidl::versioned::tests::Foo& inFoo, ::android::aidl::versioned::tests::Foo* inoutFoo, ::android::aidl::versioned::tests::Foo* outFoo, int32_t value, int32_t* _aidl_return) override { return _aidl_delegate->ignoreParcelablesAndRepeatInt(inFoo, inoutFoo, outFoo, value, _aidl_return); } ::android::binder::Status returnsLengthOfFooArray(const ::std::vector<::android::aidl::versioned::tests::Foo>& foos, int32_t* _aidl_return) override { return _aidl_delegate->returnsLengthOfFooArray(foos, _aidl_return); } ::android::binder::Status newApi() override { return _aidl_delegate->newApi(); } int32_t getInterfaceVersion() override { int32_t _delegator_ver = BnFooInterface::getInterfaceVersion(); int32_t _impl_ver = _aidl_delegate->getInterfaceVersion(); return _delegator_ver < _impl_ver ? _delegator_ver : _impl_ver; } std::string getInterfaceHash() override { return _aidl_delegate->getInterfaceHash(); } private: ::android::sp _aidl_delegate; }; // class IFooInterfaceDelegator } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-cpp-source_gen_include_android_0100644 0000000 0000000 00000000233 15172120304 032771 xustar000000000 0000000 127 path=tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/versioned/tests/BpBazUnion.h 28 mtime=1776853188.5130000 tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/versioned/t0100644 0000000 0000000 00000001432 15172120304 032727 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-cpp-source_gen_include_android_0100644 0000000 0000000 00000000226 15172120304 032773 xustar000000000 0000000 122 path=tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/versioned/tests/BpFoo.h 28 mtime=1776853188.5130000 tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/versioned/t0100644 0000000 0000000 00000001420 15172120304 032724 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-cpp-source_gen_include_android_0100644 0000000 0000000 00000000237 15172120304 032775 xustar000000000 0000000 131 path=tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/versioned/tests/BpFooInterface.h 28 mtime=1776853188.5130000 tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/versioned/t0100644 0000000 0000000 00000004142 15172120304 032730 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace versioned { namespace tests { class BpFooInterface : public ::android::BpInterface { public: explicit BpFooInterface(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpFooInterface() = default; ::android::binder::Status originalApi() override; ::android::binder::Status acceptUnionAndReturnString(const ::android::aidl::versioned::tests::BazUnion& u, ::std::string* _aidl_return) override; ::android::binder::Status ignoreParcelablesAndRepeatInt(const ::android::aidl::versioned::tests::Foo& inFoo, ::android::aidl::versioned::tests::Foo* inoutFoo, ::android::aidl::versioned::tests::Foo* outFoo, int32_t value, int32_t* _aidl_return) override; ::android::binder::Status returnsLengthOfFooArray(const ::std::vector<::android::aidl::versioned::tests::Foo>& foos, int32_t* _aidl_return) override; ::android::binder::Status newApi() override; int32_t getInterfaceVersion() override; std::string getInterfaceHash() override; private: int32_t cached_version_ = -1; std::string cached_hash_ = "-1"; std::mutex cached_hash_mutex_; }; // class BpFooInterface } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-cpp-source_gen_include_android_0100644 0000000 0000000 00000000224 15172120304 032771 xustar000000000 0000000 120 path=tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/versioned/tests/Foo.h 28 mtime=1776853188.5130000 tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/versioned/t0100644 0000000 0000000 00000004402 15172120304 032727 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl */ #pragma once #include #include #include #include #include #include namespace android { namespace aidl { namespace versioned { namespace tests { class Foo : public ::android::Parcelable { public: int32_t intDefault42 = 42; inline bool operator==(const Foo& _rhs) const { return std::tie(intDefault42) == std::tie(_rhs.intDefault42); } inline bool operator<(const Foo& _rhs) const { return std::tie(intDefault42) < std::tie(_rhs.intDefault42); } inline bool operator!=(const Foo& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Foo& _rhs) const { return _rhs < *this; } inline bool operator>=(const Foo& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Foo& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.versioned.tests.Foo"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "Foo{"; _aidl_os << "intDefault42: " << ::android::internal::ToString(intDefault42); _aidl_os << "}"; return _aidl_os.str(); } }; // class Foo } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-cpp-source_gen_include_android_0100644 0000000 0000000 00000000236 15172120304 032774 xustar000000000 0000000 130 path=tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/versioned/tests/IFooInterface.h 28 mtime=1776853188.5130000 tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/versioned/t0100644 0000000 0000000 00000007446 15172120304 032742 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include namespace android::aidl::versioned::tests { class Foo; } // namespace android::aidl::versioned::tests namespace android { namespace aidl { namespace versioned { namespace tests { class IFooInterfaceDelegator; class IFooInterface : public ::android::IInterface { public: typedef IFooInterfaceDelegator DefaultDelegator; DECLARE_META_INTERFACE(FooInterface) static inline const int32_t VERSION = 3; static inline const std::string HASH = "70d76c61eb0c82288e924862c10b910d1b7d8cf8"; virtual ::android::binder::Status originalApi() = 0; virtual ::android::binder::Status acceptUnionAndReturnString(const ::android::aidl::versioned::tests::BazUnion& u, ::std::string* _aidl_return) = 0; virtual ::android::binder::Status ignoreParcelablesAndRepeatInt(const ::android::aidl::versioned::tests::Foo& inFoo, ::android::aidl::versioned::tests::Foo* inoutFoo, ::android::aidl::versioned::tests::Foo* outFoo, int32_t value, int32_t* _aidl_return) = 0; virtual ::android::binder::Status returnsLengthOfFooArray(const ::std::vector<::android::aidl::versioned::tests::Foo>& foos, int32_t* _aidl_return) = 0; virtual ::android::binder::Status newApi() = 0; virtual int32_t getInterfaceVersion() = 0; virtual std::string getInterfaceHash() = 0; }; // class IFooInterface class IFooInterfaceDefault : public IFooInterface { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status originalApi() override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status acceptUnionAndReturnString(const ::android::aidl::versioned::tests::BazUnion& /*u*/, ::std::string* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ignoreParcelablesAndRepeatInt(const ::android::aidl::versioned::tests::Foo& /*inFoo*/, ::android::aidl::versioned::tests::Foo* /*inoutFoo*/, ::android::aidl::versioned::tests::Foo* /*outFoo*/, int32_t /*value*/, int32_t* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status returnsLengthOfFooArray(const ::std::vector<::android::aidl::versioned::tests::Foo>& /*foos*/, int32_t* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status newApi() override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } int32_t getInterfaceVersion() override { return 0; } std::string getInterfaceHash() override { return ""; } }; // class IFooInterfaceDefault } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-cpp-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 031511 xustar000000000 0000000 28 mtime=1776853188.5130000 tests/golden_output/aidl-test-versioned-interface-V3-cpp-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 026503 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-java-source_0100644 0000000 0000000 00000000034 15172120304 027073 xustar000000000 0000000 28 mtime=1776853188.5130000 tests/golden_output/aidl-test-versioned-interface-V3-java-source/0040755 0000000 0000000 00000000000 15172120304 024160 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-java-source_gen_0100644 0000000 0000000 00000000034 15172120304 027724 xustar000000000 0000000 28 mtime=1776853188.5130000 tests/golden_output/aidl-test-versioned-interface-V3-java-source/gen/0040755 0000000 0000000 00000000000 15172120304 024731 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-java-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 031424 xustar000000000 0000000 28 mtime=1776853188.5130000 tests/golden_output/aidl-test-versioned-interface-V3-java-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 026351 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-java-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 032415 xustar000000000 0000000 28 mtime=1776853188.5130000 tests/golden_output/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 027262 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-java-source_gen_android_aidl_ve0100644 0000000 0000000 00000000034 15172120304 032750 xustar000000000 0000000 28 mtime=1776853188.5130000 tests/golden_output/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/0040755 0000000 0000000 00000000000 15172120304 031260 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-java-source_gen_android_aidl_ve0100644 0000000 0000000 00000000034 15172120304 032750 xustar000000000 0000000 28 mtime=1776853188.5130000 tests/golden_output/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/tests/0040755 0000000 0000000 00000000000 15172120304 032422 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-java-source_gen_android_aidl_ve0100644 0000000 0000000 00000000225 15172120304 032752 xustar000000000 0000000 121 path=tests/golden_output/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/tests/BazUnion.java 28 mtime=1776853188.5140000 tests/golden_output/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/tests/Ba0100644 0000000 0000000 00000007154 15172120304 032673 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --rpc --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/tests/BazUnion.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-java-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl */ package android.aidl.versioned.tests; public final class BazUnion implements android.os.Parcelable { // tags for union fields public final static int intNum = 0; // int intNum; public final static int longNum = 1; // long longNum; private int _tag; private Object _value; public BazUnion() { int _value = 0; this._tag = intNum; this._value = _value; } private BazUnion(android.os.Parcel _aidl_parcel) { readFromParcel(_aidl_parcel); } private BazUnion(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public int getTag() { return _tag; } // int intNum; public static BazUnion intNum(int _value) { return new BazUnion(intNum, _value); } public int getIntNum() { _assertTag(intNum); return (int) _value; } public void setIntNum(int _value) { _set(intNum, _value); } // long longNum; public static BazUnion longNum(long _value) { return new BazUnion(longNum, _value); } public long getLongNum() { _assertTag(longNum); return (long) _value; } public void setLongNum(long _value) { _set(longNum, _value); } public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public BazUnion createFromParcel(android.os.Parcel _aidl_source) { return new BazUnion(_aidl_source); } @Override public BazUnion[] newArray(int _aidl_size) { return new BazUnion[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { _aidl_parcel.writeInt(_tag); switch (_tag) { case intNum: _aidl_parcel.writeInt(getIntNum()); break; case longNum: _aidl_parcel.writeLong(getLongNum()); break; } } public void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_tag; _aidl_tag = _aidl_parcel.readInt(); switch (_aidl_tag) { case intNum: { int _aidl_value; _aidl_value = _aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } case longNum: { long _aidl_value; _aidl_value = _aidl_parcel.readLong(); _set(_aidl_tag, _aidl_value); return; } } throw new IllegalArgumentException("union: unknown tag: " + _aidl_tag); } @Override public int describeContents() { int _mask = 0; switch (getTag()) { } return _mask; } private void _assertTag(int tag) { if (getTag() != tag) { throw new IllegalStateException("bad access: " + _tagString(tag) + ", " + _tagString(getTag()) + " is available."); } } private String _tagString(int _tag) { switch (_tag) { case intNum: return "intNum"; case longNum: return "longNum"; } throw new IllegalStateException("unknown field: " + _tag); } private void _set(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public static @interface Tag { public static final int intNum = 0; public static final int longNum = 1; } } ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-java-source_gen_android_aidl_ve0100644 0000000 0000000 00000000227 15172120304 032754 xustar000000000 0000000 123 path=tests/golden_output/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/tests/BazUnion.java.d 28 mtime=1776853188.5140000 tests/golden_output/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/tests/Ba0100644 0000000 0000000 00000000363 15172120304 032666 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/tests/BazUnion.java : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-java-source_gen_android_aidl_ve0100644 0000000 0000000 00000000220 15172120304 032745 xustar000000000 0000000 116 path=tests/golden_output/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/tests/Foo.java 28 mtime=1776853188.5140000 tests/golden_output/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/tests/Fo0100644 0000000 0000000 00000004566 15172120304 032721 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --rpc --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/tests/Foo.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-java-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl */ package android.aidl.versioned.tests; @android.annotation.SuppressLint(value = {"NewApi"}) public class Foo implements android.os.Parcelable { public int intDefault42 = 42; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public Foo createFromParcel(android.os.Parcel _aidl_source) { Foo _aidl_out = new Foo(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public Foo[] newArray(int _aidl_size) { return new Foo[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(intDefault42); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; intDefault42 = _aidl_parcel.readInt(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } } ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-java-source_gen_android_aidl_ve0100644 0000000 0000000 00000000222 15172120304 032747 xustar000000000 0000000 118 path=tests/golden_output/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/tests/Foo.java.d 28 mtime=1776853188.5140000 tests/golden_output/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/tests/Fo0100644 0000000 0000000 00000000351 15172120304 032705 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/tests/Foo.java : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-java-source_gen_android_aidl_ve0100644 0000000 0000000 00000000232 15172120304 032750 xustar000000000 0000000 126 path=tests/golden_output/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/tests/IFooInterface.java 28 mtime=1776853188.5140000 tests/golden_output/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/tests/IF0100644 0000000 0000000 00000036024 15172120304 032645 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --rpc --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/tests/IFooInterface.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-java-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/IFooInterface.aidl */ package android.aidl.versioned.tests; public interface IFooInterface extends android.os.IInterface { /** * The version of this interface that the caller is built against. * This might be different from what {@link #getInterfaceVersion() * getInterfaceVersion} returns as that is the version of the interface * that the remote object is implementing. */ public static final int VERSION = 3; public static final String HASH = "70d76c61eb0c82288e924862c10b910d1b7d8cf8"; /** Default implementation for IFooInterface. */ public static class Default implements android.aidl.versioned.tests.IFooInterface { @Override public void originalApi() throws android.os.RemoteException { } @Override public java.lang.String acceptUnionAndReturnString(android.aidl.versioned.tests.BazUnion u) throws android.os.RemoteException { return null; } @Override public int ignoreParcelablesAndRepeatInt(android.aidl.versioned.tests.Foo inFoo, android.aidl.versioned.tests.Foo inoutFoo, android.aidl.versioned.tests.Foo outFoo, int value) throws android.os.RemoteException { return 0; } @Override public int returnsLengthOfFooArray(android.aidl.versioned.tests.Foo[] foos) throws android.os.RemoteException { return 0; } @Override public void newApi() throws android.os.RemoteException { } @Override public int getInterfaceVersion() { return 0; } @Override public String getInterfaceHash() { return ""; } @Override public android.os.IBinder asBinder() { return null; } } /** Delegator implementation for IFooInterface. */ public static class Delegator extends android.aidl.versioned.tests.IFooInterface.Stub { public Delegator(android.aidl.versioned.tests.IFooInterface impl) { this.mImpl = impl; } @Override public String getInterfaceHash() throws android.os.RemoteException { return mImpl.getInterfaceHash(); } @Override public int getInterfaceVersion() throws android.os.RemoteException { int implVer = mImpl.getInterfaceVersion(); return VERSION < implVer ? VERSION : implVer; } @Override public void originalApi() throws android.os.RemoteException { mImpl.originalApi(); } @Override public java.lang.String acceptUnionAndReturnString(android.aidl.versioned.tests.BazUnion u) throws android.os.RemoteException { return mImpl.acceptUnionAndReturnString(u); } @Override public int ignoreParcelablesAndRepeatInt(android.aidl.versioned.tests.Foo inFoo, android.aidl.versioned.tests.Foo inoutFoo, android.aidl.versioned.tests.Foo outFoo, int value) throws android.os.RemoteException { return mImpl.ignoreParcelablesAndRepeatInt(inFoo,inoutFoo,outFoo,value); } @Override public int returnsLengthOfFooArray(android.aidl.versioned.tests.Foo[] foos) throws android.os.RemoteException { return mImpl.returnsLengthOfFooArray(foos); } @Override public void newApi() throws android.os.RemoteException { mImpl.newApi(); } android.aidl.versioned.tests.IFooInterface mImpl; } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.versioned.tests.IFooInterface { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.versioned.tests.IFooInterface interface, * generating a proxy if needed. */ public static android.aidl.versioned.tests.IFooInterface asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.versioned.tests.IFooInterface))) { return ((android.aidl.versioned.tests.IFooInterface)iin); } return new android.aidl.versioned.tests.IFooInterface.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } else if (code == TRANSACTION_getInterfaceVersion) { reply.writeNoException(); reply.writeInt(getInterfaceVersion()); return true; } else if (code == TRANSACTION_getInterfaceHash) { reply.writeNoException(); reply.writeString(getInterfaceHash()); return true; } switch (code) { case TRANSACTION_originalApi: { this.originalApi(); reply.writeNoException(); break; } case TRANSACTION_acceptUnionAndReturnString: { android.aidl.versioned.tests.BazUnion _arg0; _arg0 = data.readTypedObject(android.aidl.versioned.tests.BazUnion.CREATOR); data.enforceNoDataAvail(); java.lang.String _result = this.acceptUnionAndReturnString(_arg0); reply.writeNoException(); reply.writeString(_result); break; } case TRANSACTION_ignoreParcelablesAndRepeatInt: { android.aidl.versioned.tests.Foo _arg0; _arg0 = data.readTypedObject(android.aidl.versioned.tests.Foo.CREATOR); android.aidl.versioned.tests.Foo _arg1; _arg1 = data.readTypedObject(android.aidl.versioned.tests.Foo.CREATOR); android.aidl.versioned.tests.Foo _arg2; _arg2 = new android.aidl.versioned.tests.Foo(); int _arg3; _arg3 = data.readInt(); data.enforceNoDataAvail(); int _result = this.ignoreParcelablesAndRepeatInt(_arg0, _arg1, _arg2, _arg3); reply.writeNoException(); reply.writeInt(_result); reply.writeTypedObject(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); reply.writeTypedObject(_arg2, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_returnsLengthOfFooArray: { android.aidl.versioned.tests.Foo[] _arg0; _arg0 = data.createTypedArray(android.aidl.versioned.tests.Foo.CREATOR); data.enforceNoDataAvail(); int _result = this.returnsLengthOfFooArray(_arg0); reply.writeNoException(); reply.writeInt(_result); break; } case TRANSACTION_newApi: { this.newApi(); reply.writeNoException(); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.versioned.tests.IFooInterface { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } private int mCachedVersion = -1; private String mCachedHash = "-1"; @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public void originalApi() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_originalApi, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method originalApi is unimplemented."); } _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } @Override public java.lang.String acceptUnionAndReturnString(android.aidl.versioned.tests.BazUnion u) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.lang.String _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(u, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_acceptUnionAndReturnString, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method acceptUnionAndReturnString is unimplemented."); } _reply.readException(); _result = _reply.readString(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int ignoreParcelablesAndRepeatInt(android.aidl.versioned.tests.Foo inFoo, android.aidl.versioned.tests.Foo inoutFoo, android.aidl.versioned.tests.Foo outFoo, int value) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); int _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(inFoo, 0); _data.writeTypedObject(inoutFoo, 0); _data.writeInt(value); boolean _status = mRemote.transact(Stub.TRANSACTION_ignoreParcelablesAndRepeatInt, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method ignoreParcelablesAndRepeatInt is unimplemented."); } _reply.readException(); _result = _reply.readInt(); if ((0!=_reply.readInt())) { inoutFoo.readFromParcel(_reply); } if ((0!=_reply.readInt())) { outFoo.readFromParcel(_reply); } } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int returnsLengthOfFooArray(android.aidl.versioned.tests.Foo[] foos) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); int _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedArray(foos, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_returnsLengthOfFooArray, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method returnsLengthOfFooArray is unimplemented."); } _reply.readException(); _result = _reply.readInt(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public void newApi() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_newApi, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method newApi is unimplemented."); } _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } @Override public int getInterfaceVersion() throws android.os.RemoteException { if (mCachedVersion == -1) { android.os.Parcel data = android.os.Parcel.obtain(asBinder()); android.os.Parcel reply = android.os.Parcel.obtain(); try { data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getInterfaceVersion, data, reply, 0); reply.readException(); mCachedVersion = reply.readInt(); } finally { reply.recycle(); data.recycle(); } } return mCachedVersion; } @Override public synchronized String getInterfaceHash() throws android.os.RemoteException { if ("-1".equals(mCachedHash)) { android.os.Parcel data = android.os.Parcel.obtain(asBinder()); android.os.Parcel reply = android.os.Parcel.obtain(); try { data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getInterfaceHash, data, reply, 0); reply.readException(); mCachedHash = reply.readString(); } finally { reply.recycle(); data.recycle(); } } return mCachedHash; } } static final int TRANSACTION_originalApi = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); static final int TRANSACTION_acceptUnionAndReturnString = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1); static final int TRANSACTION_ignoreParcelablesAndRepeatInt = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2); static final int TRANSACTION_returnsLengthOfFooArray = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3); static final int TRANSACTION_newApi = (android.os.IBinder.FIRST_CALL_TRANSACTION + 4); static final int TRANSACTION_getInterfaceVersion = (android.os.IBinder.FIRST_CALL_TRANSACTION + 16777214); static final int TRANSACTION_getInterfaceHash = (android.os.IBinder.FIRST_CALL_TRANSACTION + 16777213); } /** @hide */ public static final java.lang.String DESCRIPTOR = "android$aidl$versioned$tests$IFooInterface".replace('$', '.'); public void originalApi() throws android.os.RemoteException; public java.lang.String acceptUnionAndReturnString(android.aidl.versioned.tests.BazUnion u) throws android.os.RemoteException; public int ignoreParcelablesAndRepeatInt(android.aidl.versioned.tests.Foo inFoo, android.aidl.versioned.tests.Foo inoutFoo, android.aidl.versioned.tests.Foo outFoo, int value) throws android.os.RemoteException; public int returnsLengthOfFooArray(android.aidl.versioned.tests.Foo[] foos) throws android.os.RemoteException; public void newApi() throws android.os.RemoteException; public int getInterfaceVersion() throws android.os.RemoteException; public String getInterfaceHash() throws android.os.RemoteException; } ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-java-source_gen_android_aidl_ve0100644 0000000 0000000 00000000234 15172120304 032752 xustar000000000 0000000 128 path=tests/golden_output/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/tests/IFooInterface.java.d 28 mtime=1776853188.5140000 tests/golden_output/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/tests/IF0100644 0000000 0000000 00000000714 15172120304 032642 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/tests/IFooInterface.java : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/IFooInterface.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-java-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 031650 xustar000000000 0000000 28 mtime=1776853188.5140000 tests/golden_output/aidl-test-versioned-interface-V3-java-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 026642 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-ndk-source_0100644 0000000 0000000 00000000034 15172120304 026726 xustar000000000 0000000 28 mtime=1776853188.5140000 tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/0040755 0000000 0000000 00000000000 15172120304 024013 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-ndk-source_gen_0100644 0000000 0000000 00000000034 15172120304 027557 xustar000000000 0000000 28 mtime=1776853188.5140000 tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/0040755 0000000 0000000 00000000000 15172120304 024564 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-ndk-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 031257 xustar000000000 0000000 28 mtime=1776853188.5140000 tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 026204 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-ndk-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 032250 xustar000000000 0000000 28 mtime=1776853188.5140000 tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 027115 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-ndk-source_gen_android_aidl_ver0100644 0000000 0000000 00000000034 15172120304 032765 xustar000000000 0000000 28 mtime=1776853188.5140000 tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/versioned/0040755 0000000 0000000 00000000000 15172120304 031113 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-ndk-source_gen_android_aidl_ver0100644 0000000 0000000 00000000034 15172120304 032765 xustar000000000 0000000 28 mtime=1776853188.5140000 tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/versioned/tests/0040755 0000000 0000000 00000000000 15172120304 032255 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-ndk-source_gen_android_aidl_ver0100644 0000000 0000000 00000000223 15172120304 032765 xustar000000000 0000000 119 path=tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/versioned/tests/BazUnion.cpp 28 mtime=1776853188.5150000 tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/versioned/tests/Baz0100644 0000000 0000000 00000005171 15172120304 032715 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl */ #include "aidl/android/aidl/versioned/tests/BazUnion.h" #include namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { const char* BazUnion::descriptor = "android.aidl.versioned.tests.BazUnion"; binder_status_t BazUnion::readFromParcel(const AParcel* _parcel) { binder_status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_tag)) != STATUS_OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case intNum: { int32_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case longNum: { int64_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } } return STATUS_BAD_VALUE; } binder_status_t BazUnion::writeToParcel(AParcel* _parcel) const { binder_status_t _aidl_ret_status = ::ndk::AParcel_writeData(_parcel, static_cast(getTag())); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; switch (getTag()) { case intNum: return ::ndk::AParcel_writeData(_parcel, get()); case longNum: return ::ndk::AParcel_writeData(_parcel, get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-ndk-source_gen_android_aidl_ver0100644 0000000 0000000 00000000225 15172120304 032767 xustar000000000 0000000 121 path=tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/versioned/tests/BazUnion.cpp.d 28 mtime=1776853188.5150000 tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/versioned/tests/Baz0100644 0000000 0000000 00000000361 15172120304 032711 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/versioned/tests/BazUnion.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-ndk-source_gen_android_aidl_ver0100644 0000000 0000000 00000000216 15172120304 032767 xustar000000000 0000000 114 path=tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/versioned/tests/Foo.cpp 28 mtime=1776853188.5150000 tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/versioned/tests/Foo0100644 0000000 0000000 00000005301 15172120304 032717 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl */ #include "aidl/android/aidl/versioned/tests/Foo.h" #include namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { const char* Foo::descriptor = "android.aidl.versioned.tests.Foo"; binder_status_t Foo::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &intDefault42); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t Foo::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, intDefault42); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-ndk-source_gen_android_aidl_ver0100644 0000000 0000000 00000000220 15172120304 032762 xustar000000000 0000000 116 path=tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/versioned/tests/Foo.cpp.d 28 mtime=1776853188.5150000 tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/versioned/tests/Foo0100644 0000000 0000000 00000000347 15172120304 032724 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/versioned/tests/Foo.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-ndk-source_gen_android_aidl_ver0100644 0000000 0000000 00000000230 15172120304 032763 xustar000000000 0000000 124 path=tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/versioned/tests/IFooInterface.cpp 28 mtime=1776853188.5150000 tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/versioned/tests/IFo0100644 0000000 0000000 00000053573 15172120304 032667 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/IFooInterface.aidl */ #include "aidl/android/aidl/versioned/tests/IFooInterface.h" #include #include #include namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { static binder_status_t _aidl_android_aidl_versioned_tests_IFooInterface_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*originalApi*/): { ::ndk::ScopedAStatus _aidl_status = _aidl_impl->originalApi(); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } case (FIRST_CALL_TRANSACTION + 1 /*acceptUnionAndReturnString*/): { ::aidl::android::aidl::versioned::tests::BazUnion in_u; std::string _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_u); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->acceptUnionAndReturnString(in_u, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 2 /*ignoreParcelablesAndRepeatInt*/): { ::aidl::android::aidl::versioned::tests::Foo in_inFoo; ::aidl::android::aidl::versioned::tests::Foo in_inoutFoo; ::aidl::android::aidl::versioned::tests::Foo out_outFoo; int32_t in_value; int32_t _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_inFoo); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_inoutFoo); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_value); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ignoreParcelablesAndRepeatInt(in_inFoo, &in_inoutFoo, &out_outFoo, in_value, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, in_inoutFoo); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_outFoo); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 3 /*returnsLengthOfFooArray*/): { std::vector<::aidl::android::aidl::versioned::tests::Foo> in_foos; int32_t _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_foos); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->returnsLengthOfFooArray(in_foos, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 4 /*newApi*/): { ::ndk::ScopedAStatus _aidl_status = _aidl_impl->newApi(); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } case (FIRST_CALL_TRANSACTION + 16777214 /*getInterfaceVersion*/): { int32_t _aidl_return; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->getInterfaceVersion(&_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 16777213 /*getInterfaceHash*/): { std::string _aidl_return; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->getInterfaceHash(&_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_versioned_tests_IFooInterface_clazz = ::ndk::ICInterface::defineClass(IFooInterface::descriptor, _aidl_android_aidl_versioned_tests_IFooInterface_onTransact); BpFooInterface::BpFooInterface(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} BpFooInterface::~BpFooInterface() {} ::ndk::ScopedAStatus BpFooInterface::originalApi() { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*originalApi*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->originalApi(); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpFooInterface::acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& in_u, std::string* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_u); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 1 /*acceptUnionAndReturnString*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->acceptUnionAndReturnString(in_u, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpFooInterface::ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& in_inFoo, ::aidl::android::aidl::versioned::tests::Foo* in_inoutFoo, ::aidl::android::aidl::versioned::tests::Foo* out_outFoo, int32_t in_value, int32_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_inFoo); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), *in_inoutFoo); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_value); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 2 /*ignoreParcelablesAndRepeatInt*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->ignoreParcelablesAndRepeatInt(in_inFoo, in_inoutFoo, out_outFoo, in_value, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), in_inoutFoo); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_outFoo); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpFooInterface::returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& in_foos, int32_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_foos); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 3 /*returnsLengthOfFooArray*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->returnsLengthOfFooArray(in_foos, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpFooInterface::newApi() { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 4 /*newApi*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->newApi(); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpFooInterface::getInterfaceVersion(int32_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; if (_aidl_cached_version != -1) { *_aidl_return = _aidl_cached_version; _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); return _aidl_status; } ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 16777214 /*getInterfaceVersion*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->getInterfaceVersion(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_cached_version = *_aidl_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpFooInterface::getInterfaceHash(std::string* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; const std::lock_guard lock(_aidl_cached_hash_mutex); if (_aidl_cached_hash != "-1") { *_aidl_return = _aidl_cached_hash; _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); return _aidl_status; } ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 16777213 /*getInterfaceHash*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->getInterfaceHash(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_cached_hash = *_aidl_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } // Source for BnFooInterface BnFooInterface::BnFooInterface() {} BnFooInterface::~BnFooInterface() {} ::ndk::SpAIBinder BnFooInterface::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_versioned_tests_IFooInterface_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } ::ndk::ScopedAStatus BnFooInterface::getInterfaceVersion(int32_t* _aidl_return) { *_aidl_return = IFooInterface::version; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::ScopedAStatus BnFooInterface::getInterfaceHash(std::string* _aidl_return) { *_aidl_return = IFooInterface::hash; return ::ndk::ScopedAStatus(AStatus_newOk()); } // Source for IFooInterface const char* IFooInterface::descriptor = "android.aidl.versioned.tests.IFooInterface"; IFooInterface::IFooInterface() {} IFooInterface::~IFooInterface() {} std::shared_ptr IFooInterface::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_versioned_tests_IFooInterface_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t IFooInterface::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t IFooInterface::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = IFooInterface::fromBinder(binder); return STATUS_OK; } bool IFooInterface::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!IFooInterface::default_impl); if (impl) { IFooInterface::default_impl = impl; return true; } return false; } const std::shared_ptr& IFooInterface::getDefaultImpl() { return IFooInterface::default_impl; } std::shared_ptr IFooInterface::default_impl = nullptr; ::ndk::ScopedAStatus IFooInterfaceDefault::originalApi() { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus IFooInterfaceDefault::acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& /*in_u*/, std::string* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus IFooInterfaceDefault::ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& /*in_inFoo*/, ::aidl::android::aidl::versioned::tests::Foo* /*in_inoutFoo*/, ::aidl::android::aidl::versioned::tests::Foo* /*out_outFoo*/, int32_t /*in_value*/, int32_t* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus IFooInterfaceDefault::returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& /*in_foos*/, int32_t* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus IFooInterfaceDefault::newApi() { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus IFooInterfaceDefault::getInterfaceVersion(int32_t* _aidl_return) { *_aidl_return = 0; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::ScopedAStatus IFooInterfaceDefault::getInterfaceHash(std::string* _aidl_return) { *_aidl_return = ""; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::SpAIBinder IFooInterfaceDefault::asBinder() { return ::ndk::SpAIBinder(); } bool IFooInterfaceDefault::isRemote() { return false; } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-ndk-source_gen_android_aidl_ver0100644 0000000 0000000 00000000232 15172120304 032765 xustar000000000 0000000 126 path=tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/versioned/tests/IFooInterface.cpp.d 28 mtime=1776853188.5160000 tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/versioned/tests/IFo0100644 0000000 0000000 00000000712 15172120304 032652 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/versioned/tests/IFooInterface.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/IFooInterface.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-ndk-source_gen_include_0100644 0000000 0000000 00000000034 15172120304 031262 xustar000000000 0000000 28 mtime=1776853188.5160000 tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/include/0040755 0000000 0000000 00000000000 15172120304 026207 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-ndk-source_gen_include_aidl_0100644 0000000 0000000 00000000034 15172120304 032253 xustar000000000 0000000 28 mtime=1776853188.5160000 tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/0040755 0000000 0000000 00000000000 15172120304 027120 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000034 15172120304 032736 xustar000000000 0000000 28 mtime=1776853188.5160000 tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/0040755 0000000 0000000 00000000000 15172120304 030540 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000034 15172120304 032736 xustar000000000 0000000 28 mtime=1776853188.5160000 tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl/0040755 0000000 0000000 00000000000 15172120304 031451 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000216 15172120304 032740 xustar000000000 0000000 114 path=tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl/versioned/ 28 mtime=1776853188.5160000 tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl/versio0040755 0000000 0000000 00000000000 15172120304 032701 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000224 15172120304 032737 xustar000000000 0000000 120 path=tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl/versioned/tests/ 28 mtime=1776853188.5160000 tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl/versio0040755 0000000 0000000 00000000000 15172120304 032701 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000236 15172120304 032742 xustar000000000 0000000 130 path=tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BazUnion.h 28 mtime=1776853188.5160000 tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl/versio0100644 0000000 0000000 00000012672 15172120304 032710 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { class BazUnion { public: typedef std::false_type fixed_size; static const char* descriptor; enum class Tag : int32_t { intNum = 0, longNum = 1, }; // Expose tag symbols for legacy code static const inline Tag intNum = Tag::intNum; static const inline Tag longNum = Tag::longNum; template static constexpr bool _not_self = !std::is_same_v>, BazUnion>; BazUnion() : _value(std::in_place_index(intNum)>, int32_t(0)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr BazUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit BazUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static BazUnion make(_Tp&&... _args) { return BazUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static BazUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return BazUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } binder_status_t readFromParcel(const AParcel* _parcel); binder_status_t writeToParcel(AParcel* _parcel) const; inline bool operator==(const BazUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const BazUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const BazUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const BazUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const BazUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const BazUnion& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream os; os << "BazUnion{"; switch (getTag()) { case intNum: os << "intNum: " << ::android::internal::ToString(get()); break; case longNum: os << "longNum: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant _value; }; } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { [[nodiscard]] static inline std::string toString(BazUnion::Tag val) { switch(val) { case BazUnion::Tag::intNum: return "intNum"; case BazUnion::Tag::longNum: return "longNum"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::versioned::tests::BazUnion::Tag::intNum, aidl::android::aidl::versioned::tests::BazUnion::Tag::longNum, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000240 15172120304 032735 xustar000000000 0000000 132 path=tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BnBazUnion.h 28 mtime=1776853188.5160000 tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl/versio0100644 0000000 0000000 00000001432 15172120304 032700 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000233 15172120304 032737 xustar000000000 0000000 127 path=tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BnFoo.h 28 mtime=1776853188.5160000 tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl/versio0100644 0000000 0000000 00000001420 15172120304 032675 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000244 15172120304 032741 xustar000000000 0000000 136 path=tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BnFooInterface.h 28 mtime=1776853188.5160000 tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl/versio0100644 0000000 0000000 00000006100 15172120304 032675 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include "aidl/android/aidl/versioned/tests/IFooInterface.h" #include #include #ifndef __BIONIC__ #ifndef __assert2 #define __assert2(a,b,c,d) ((void)0) #endif #endif namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { class BnFooInterface : public ::ndk::BnCInterface { public: BnFooInterface(); virtual ~BnFooInterface(); ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) final; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) final; protected: ::ndk::SpAIBinder createBinder() override; private: }; class IFooInterfaceDelegator : public BnFooInterface { public: explicit IFooInterfaceDelegator(const std::shared_ptr &impl) : _impl(impl) { int32_t _impl_ver = 0; if (!impl->getInterfaceVersion(&_impl_ver).isOk()) {; __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Delegator failed to get version of the implementation."); } if (_impl_ver != IFooInterface::version) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Mismatched versions of delegator and implementation is not allowed."); } } ::ndk::ScopedAStatus originalApi() override { return _impl->originalApi(); } ::ndk::ScopedAStatus acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& in_u, std::string* _aidl_return) override { return _impl->acceptUnionAndReturnString(in_u, _aidl_return); } ::ndk::ScopedAStatus ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& in_inFoo, ::aidl::android::aidl::versioned::tests::Foo* in_inoutFoo, ::aidl::android::aidl::versioned::tests::Foo* out_outFoo, int32_t in_value, int32_t* _aidl_return) override { return _impl->ignoreParcelablesAndRepeatInt(in_inFoo, in_inoutFoo, out_outFoo, in_value, _aidl_return); } ::ndk::ScopedAStatus returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& in_foos, int32_t* _aidl_return) override { return _impl->returnsLengthOfFooArray(in_foos, _aidl_return); } ::ndk::ScopedAStatus newApi() override { return _impl->newApi(); } protected: private: std::shared_ptr _impl; }; } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000240 15172120304 032735 xustar000000000 0000000 132 path=tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BpBazUnion.h 28 mtime=1776853188.5160000 tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl/versio0100644 0000000 0000000 00000001432 15172120304 032700 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000233 15172120304 032737 xustar000000000 0000000 127 path=tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BpFoo.h 28 mtime=1776853188.5160000 tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl/versio0100644 0000000 0000000 00000001420 15172120304 032675 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000244 15172120304 032741 xustar000000000 0000000 136 path=tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BpFooInterface.h 28 mtime=1776853188.5160000 tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl/versio0100644 0000000 0000000 00000004177 15172120304 032711 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include "aidl/android/aidl/versioned/tests/IFooInterface.h" #include namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { class BpFooInterface : public ::ndk::BpCInterface { public: explicit BpFooInterface(const ::ndk::SpAIBinder& binder); virtual ~BpFooInterface(); ::ndk::ScopedAStatus originalApi() override; ::ndk::ScopedAStatus acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& in_u, std::string* _aidl_return) override; ::ndk::ScopedAStatus ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& in_inFoo, ::aidl::android::aidl::versioned::tests::Foo* in_inoutFoo, ::aidl::android::aidl::versioned::tests::Foo* out_outFoo, int32_t in_value, int32_t* _aidl_return) override; ::ndk::ScopedAStatus returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& in_foos, int32_t* _aidl_return) override; ::ndk::ScopedAStatus newApi() override; ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) override; int32_t _aidl_cached_version = -1; std::string _aidl_cached_hash = "-1"; std::mutex _aidl_cached_hash_mutex; }; } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000231 15172120304 032735 xustar000000000 0000000 125 path=tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl/versioned/tests/Foo.h 28 mtime=1776853188.5170000 tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl/versio0100644 0000000 0000000 00000004527 15172120304 032710 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl */ #pragma once #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { class Foo { public: typedef std::false_type fixed_size; static const char* descriptor; int32_t intDefault42 = 42; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const Foo& _rhs) const { return std::tie(intDefault42) == std::tie(_rhs.intDefault42); } inline bool operator<(const Foo& _rhs) const { return std::tie(intDefault42) < std::tie(_rhs.intDefault42); } inline bool operator!=(const Foo& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Foo& _rhs) const { return _rhs < *this; } inline bool operator>=(const Foo& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Foo& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "Foo{"; _aidl_os << "intDefault42: " << ::android::internal::ToString(intDefault42); _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-ndk-source_gen_include_aidl_and0100644 0000000 0000000 00000000243 15172120304 032740 xustar000000000 0000000 135 path=tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl/versioned/tests/IFooInterface.h 28 mtime=1776853188.5170000 tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl/versio0100644 0000000 0000000 00000010676 15172120304 032712 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl::android::aidl::versioned::tests { class Foo; } // namespace aidl::android::aidl::versioned::tests namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { class IFooInterfaceDelegator; class IFooInterface : public ::ndk::ICInterface { public: typedef IFooInterfaceDelegator DefaultDelegator; static const char* descriptor; IFooInterface(); virtual ~IFooInterface(); static inline const int32_t version = 3; static inline const std::string hash = "70d76c61eb0c82288e924862c10b910d1b7d8cf8"; static constexpr uint32_t TRANSACTION_originalApi = FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_acceptUnionAndReturnString = FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_ignoreParcelablesAndRepeatInt = FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_returnsLengthOfFooArray = FIRST_CALL_TRANSACTION + 3; static constexpr uint32_t TRANSACTION_newApi = FIRST_CALL_TRANSACTION + 4; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus originalApi() = 0; virtual ::ndk::ScopedAStatus acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& in_u, std::string* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& in_inFoo, ::aidl::android::aidl::versioned::tests::Foo* in_inoutFoo, ::aidl::android::aidl::versioned::tests::Foo* out_outFoo, int32_t in_value, int32_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& in_foos, int32_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus newApi() = 0; virtual ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) = 0; private: static std::shared_ptr default_impl; }; class IFooInterfaceDefault : public IFooInterface { public: ::ndk::ScopedAStatus originalApi() override; ::ndk::ScopedAStatus acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& in_u, std::string* _aidl_return) override; ::ndk::ScopedAStatus ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& in_inFoo, ::aidl::android::aidl::versioned::tests::Foo* in_inoutFoo, ::aidl::android::aidl::versioned::tests::Foo* out_outFoo, int32_t in_value, int32_t* _aidl_return) override; ::ndk::ScopedAStatus returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& in_foos, int32_t* _aidl_return) override; ::ndk::ScopedAStatus newApi() override; ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-ndk-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 031503 xustar000000000 0000000 28 mtime=1776853188.5170000 tests/golden_output/aidl-test-versioned-interface-V3-ndk-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 026475 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-rust-source_0100644 0000000 0000000 00000000034 15172120304 027147 xustar000000000 0000000 28 mtime=1776853188.5170000 tests/golden_output/aidl-test-versioned-interface-V3-rust-source/0040755 0000000 0000000 00000000000 15172120304 024234 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-rust-source_gen_0100644 0000000 0000000 00000000034 15172120304 030000 xustar000000000 0000000 28 mtime=1776853188.5170000 tests/golden_output/aidl-test-versioned-interface-V3-rust-source/gen/0040755 0000000 0000000 00000000000 15172120304 025005 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-rust-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 031500 xustar000000000 0000000 28 mtime=1776853188.5170000 tests/golden_output/aidl-test-versioned-interface-V3-rust-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 026425 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-rust-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 032471 xustar000000000 0000000 28 mtime=1776853188.5170000 tests/golden_output/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 027336 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-rust-source_gen_android_aidl_ve0100644 0000000 0000000 00000000034 15172120304 033024 xustar000000000 0000000 28 mtime=1776853188.5170000 tests/golden_output/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/0040755 0000000 0000000 00000000000 15172120304 031334 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-rust-source_gen_android_aidl_ve0100644 0000000 0000000 00000000034 15172120304 033024 xustar000000000 0000000 28 mtime=1776853188.5170000 tests/golden_output/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/tests/0040755 0000000 0000000 00000000000 15172120304 032476 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-rust-source_gen_android_aidl_ve0100644 0000000 0000000 00000000223 15172120304 033024 xustar000000000 0000000 119 path=tests/golden_output/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/tests/BazUnion.rs 28 mtime=1776853188.5170000 tests/golden_output/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/tests/Ba0100644 0000000 0000000 00000004412 15172120304 032741 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/tests/BazUnion.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-rust-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub enum r#BazUnion { IntNum(i32), LongNum(i64), } impl Default for r#BazUnion { fn default() -> Self { Self::IntNum(0) } } impl binder::Parcelable for r#BazUnion { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { match self { Self::IntNum(v) => { parcel.write(&0i32)?; parcel.write(v) } Self::LongNum(v) => { parcel.write(&1i32)?; parcel.write(v) } } } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { let tag: i32 = parcel.read()?; match tag { 0 => { let value: i32 = parcel.read()?; *self = Self::IntNum(value); Ok(()) } 1 => { let value: i64 = parcel.read()?; *self = Self::LongNum(value); Ok(()) } _ => { Err(binder::StatusCode::BAD_VALUE) } } } } binder::impl_serialize_for_parcelable!(r#BazUnion); binder::impl_deserialize_for_parcelable!(r#BazUnion); impl binder::binder_impl::ParcelableMetadata for r#BazUnion { fn get_descriptor() -> &'static str { "android.aidl.versioned.tests.BazUnion" } } pub mod r#Tag { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#Tag : [i32; 2] { r#intNum = 0, r#longNum = 1, } } } pub(crate) mod mangled { pub use super::r#BazUnion as _7_android_4_aidl_9_versioned_5_tests_8_BazUnion; pub use super::r#Tag::r#Tag as _7_android_4_aidl_9_versioned_5_tests_8_BazUnion_3_Tag; } ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-rust-source_gen_android_aidl_ve0100644 0000000 0000000 00000000225 15172120304 033026 xustar000000000 0000000 121 path=tests/golden_output/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/tests/BazUnion.rs.d 28 mtime=1776853188.5170000 tests/golden_output/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/tests/Ba0100644 0000000 0000000 00000000361 15172120304 032740 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/tests/BazUnion.rs : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-rust-source_gen_android_aidl_ve0100644 0000000 0000000 00000000216 15172120304 033026 xustar000000000 0000000 114 path=tests/golden_output/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/tests/Foo.rs 28 mtime=1776853188.5170000 tests/golden_output/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/tests/Fo0100644 0000000 0000000 00000003251 15172120304 032763 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/tests/Foo.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-rust-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub struct r#Foo { pub r#intDefault42: i32, } impl Default for r#Foo { fn default() -> Self { Self { r#intDefault42: 42, } } } impl binder::Parcelable for r#Foo { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#intDefault42)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#intDefault42 = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#Foo); binder::impl_deserialize_for_parcelable!(r#Foo); impl binder::binder_impl::ParcelableMetadata for r#Foo { fn get_descriptor() -> &'static str { "android.aidl.versioned.tests.Foo" } } pub(crate) mod mangled { pub use super::r#Foo as _7_android_4_aidl_9_versioned_5_tests_3_Foo; } ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-rust-source_gen_android_aidl_ve0100644 0000000 0000000 00000000220 15172120304 033021 xustar000000000 0000000 116 path=tests/golden_output/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/tests/Foo.rs.d 28 mtime=1776853188.5170000 tests/golden_output/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/tests/Fo0100644 0000000 0000000 00000000347 15172120304 032766 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/tests/Foo.rs : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-rust-source_gen_android_aidl_ve0100644 0000000 0000000 00000000230 15172120304 033022 xustar000000000 0000000 124 path=tests/golden_output/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/tests/IFooInterface.rs 28 mtime=1776853188.5170000 tests/golden_output/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/tests/IF0100644 0000000 0000000 00000067453 15172120304 032733 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/tests/IFooInterface.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-rust-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/IFooInterface.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { IFooInterface["android.aidl.versioned.tests.IFooInterface"] { native: BnFooInterface(on_transact), proxy: BpFooInterface { cached_version: std::sync::atomic::AtomicI32 = std::sync::atomic::AtomicI32::new(-1), cached_hash: std::sync::Mutex> = std::sync::Mutex::new(None) }, async: IFooInterfaceAsync, } } pub trait IFooInterface: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.versioned.tests.IFooInterface" } fn r#originalApi(&self) -> binder::Result<()>; fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result; fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result; fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result; fn r#newApi(&self) -> binder::Result<()>; fn r#getInterfaceVersion(&self) -> binder::Result { Ok(VERSION) } fn r#getInterfaceHash(&self) -> binder::Result { Ok(HASH.into()) } fn getDefaultImpl() -> IFooInterfaceDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: IFooInterfaceDefaultRef) -> IFooInterfaceDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait IFooInterfaceAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.versioned.tests.IFooInterface" } fn r#originalApi<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result<()>>; fn r#acceptUnionAndReturnString<'a>(&'a self, _arg_u: &'a crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::BoxFuture<'a, binder::Result>; fn r#ignoreParcelablesAndRepeatInt<'a>(&'a self, _arg_inFoo: &'a crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &'a mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &'a mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::BoxFuture<'a, binder::Result>; fn r#returnsLengthOfFooArray<'a>(&'a self, _arg_foos: &'a [crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::BoxFuture<'a, binder::Result>; fn r#newApi<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result<()>>; fn r#getInterfaceVersion<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { Box::pin(async move { Ok(VERSION) }) } fn r#getInterfaceHash<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { Box::pin(async move { Ok(HASH.into()) }) } } #[::async_trait::async_trait] pub trait IFooInterfaceAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.versioned.tests.IFooInterface" } async fn r#originalApi(&self) -> binder::Result<()>; async fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result; async fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result; async fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result; async fn r#newApi(&self) -> binder::Result<()>; } impl BnFooInterface { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: IFooInterfaceAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl IFooInterface for Wrapper where T: IFooInterfaceAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#originalApi(&self) -> binder::Result<()> { self._rt.block_on(self._inner.r#originalApi()) } fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result { self._rt.block_on(self._inner.r#acceptUnionAndReturnString(_arg_u)) } fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result { self._rt.block_on(self._inner.r#ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value)) } fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result { self._rt.block_on(self._inner.r#returnsLengthOfFooArray(_arg_foos)) } fn r#newApi(&self) -> binder::Result<()> { self._rt.block_on(self._inner.r#newApi()) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait IFooInterfaceDefault: Send + Sync { fn r#originalApi(&self) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#newApi(&self) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#originalApi: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; pub const r#acceptUnionAndReturnString: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 1; pub const r#ignoreParcelablesAndRepeatInt: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 2; pub const r#returnsLengthOfFooArray: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 3; pub const r#newApi: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 4; pub const r#getInterfaceVersion: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 16777214; pub const r#getInterfaceHash: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 16777213; } pub type IFooInterfaceDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); pub const VERSION: i32 = 3; pub const HASH: &str = "70d76c61eb0c82288e924862c10b910d1b7d8cf8"; impl BpFooInterface { fn build_parcel_originalApi(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_originalApi(&self, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#originalApi(); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } Ok(()) } fn build_parcel_acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_u)?; Ok(aidl_data) } fn read_response_acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#acceptUnionAndReturnString(_arg_u); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: String = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_inFoo)?; aidl_data.write(_arg_inoutFoo)?; aidl_data.write(&_arg_value)?; Ok(aidl_data) } fn read_response_ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: i32 = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_inoutFoo)?; _aidl_reply.read_onto(_arg_outFoo)?; Ok(_aidl_return) } fn build_parcel_returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_foos)?; Ok(aidl_data) } fn read_response_returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo], _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#returnsLengthOfFooArray(_arg_foos); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: i32 = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_newApi(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_newApi(&self, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#newApi(); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } Ok(()) } fn build_parcel_getInterfaceVersion(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_getInterfaceVersion(&self, _aidl_reply: std::result::Result) -> binder::Result { let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: i32 = _aidl_reply.read()?; self.cached_version.store(_aidl_return, std::sync::atomic::Ordering::Relaxed); Ok(_aidl_return) } fn build_parcel_getInterfaceHash(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_getInterfaceHash(&self, _aidl_reply: std::result::Result) -> binder::Result { let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: String = _aidl_reply.read()?; *self.cached_hash.lock().unwrap() = Some(_aidl_return.clone()); Ok(_aidl_return) } } impl IFooInterface for BpFooInterface { fn r#originalApi(&self) -> binder::Result<()> { let _aidl_data = self.build_parcel_originalApi()?; let _aidl_reply = self.binder.submit_transact(transactions::r#originalApi, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_originalApi(_aidl_reply) } fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result { let _aidl_data = self.build_parcel_acceptUnionAndReturnString(_arg_u)?; let _aidl_reply = self.binder.submit_transact(transactions::r#acceptUnionAndReturnString, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_acceptUnionAndReturnString(_arg_u, _aidl_reply) } fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result { let _aidl_data = self.build_parcel_ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ignoreParcelablesAndRepeatInt, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value, _aidl_reply) } fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result { let _aidl_data = self.build_parcel_returnsLengthOfFooArray(_arg_foos)?; let _aidl_reply = self.binder.submit_transact(transactions::r#returnsLengthOfFooArray, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_returnsLengthOfFooArray(_arg_foos, _aidl_reply) } fn r#newApi(&self) -> binder::Result<()> { let _aidl_data = self.build_parcel_newApi()?; let _aidl_reply = self.binder.submit_transact(transactions::r#newApi, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_newApi(_aidl_reply) } fn r#getInterfaceVersion(&self) -> binder::Result { let _aidl_version = self.cached_version.load(std::sync::atomic::Ordering::Relaxed); if _aidl_version != -1 { return Ok(_aidl_version); } let _aidl_data = self.build_parcel_getInterfaceVersion()?; let _aidl_reply = self.binder.submit_transact(transactions::r#getInterfaceVersion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_getInterfaceVersion(_aidl_reply) } fn r#getInterfaceHash(&self) -> binder::Result { { let _aidl_hash_lock = self.cached_hash.lock().unwrap(); if let Some(ref _aidl_hash) = *_aidl_hash_lock { return Ok(_aidl_hash.clone()); } } let _aidl_data = self.build_parcel_getInterfaceHash()?; let _aidl_reply = self.binder.submit_transact(transactions::r#getInterfaceHash, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_getInterfaceHash(_aidl_reply) } } impl IFooInterfaceAsync

for BpFooInterface { fn r#originalApi<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_originalApi() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#originalApi, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_originalApi(_aidl_reply) } ) } fn r#acceptUnionAndReturnString<'a>(&'a self, _arg_u: &'a crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_acceptUnionAndReturnString(_arg_u) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#acceptUnionAndReturnString, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_acceptUnionAndReturnString(_arg_u, _aidl_reply) } ) } fn r#ignoreParcelablesAndRepeatInt<'a>(&'a self, _arg_inFoo: &'a crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &'a mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &'a mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ignoreParcelablesAndRepeatInt, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value, _aidl_reply) } ) } fn r#returnsLengthOfFooArray<'a>(&'a self, _arg_foos: &'a [crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_returnsLengthOfFooArray(_arg_foos) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#returnsLengthOfFooArray, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_returnsLengthOfFooArray(_arg_foos, _aidl_reply) } ) } fn r#newApi<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_newApi() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#newApi, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_newApi(_aidl_reply) } ) } fn r#getInterfaceVersion<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { let _aidl_version = self.cached_version.load(std::sync::atomic::Ordering::Relaxed); if _aidl_version != -1 { return Box::pin(std::future::ready(Ok(_aidl_version))); } let _aidl_data = match self.build_parcel_getInterfaceVersion() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#getInterfaceVersion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_getInterfaceVersion(_aidl_reply) } ) } fn r#getInterfaceHash<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { { let _aidl_hash_lock = self.cached_hash.lock().unwrap(); if let Some(ref _aidl_hash) = *_aidl_hash_lock { return Box::pin(std::future::ready(Ok(_aidl_hash.clone()))); } } let _aidl_data = match self.build_parcel_getInterfaceHash() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#getInterfaceHash, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_getInterfaceHash(_aidl_reply) } ) } } impl IFooInterface for binder::binder_impl::Binder { fn r#originalApi(&self) -> binder::Result<()> { self.0.r#originalApi() } fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result { self.0.r#acceptUnionAndReturnString(_arg_u) } fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result { self.0.r#ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value) } fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result { self.0.r#returnsLengthOfFooArray(_arg_foos) } fn r#newApi(&self) -> binder::Result<()> { self.0.r#newApi() } fn r#getInterfaceVersion(&self) -> binder::Result { self.0.r#getInterfaceVersion() } fn r#getInterfaceHash(&self) -> binder::Result { self.0.r#getInterfaceHash() } } fn on_transact(_aidl_service: &dyn IFooInterface, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#originalApi => { let _aidl_return = _aidl_service.r#originalApi(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#acceptUnionAndReturnString => { let _arg_u: crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion = _aidl_data.read()?; let _aidl_return = _aidl_service.r#acceptUnionAndReturnString(&_arg_u); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ignoreParcelablesAndRepeatInt => { let _arg_inFoo: crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo = _aidl_data.read()?; let mut _arg_inoutFoo: crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo = _aidl_data.read()?; let mut _arg_outFoo: crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo = Default::default(); let _arg_value: i32 = _aidl_data.read()?; let _aidl_return = _aidl_service.r#ignoreParcelablesAndRepeatInt(&_arg_inFoo, &mut _arg_inoutFoo, &mut _arg_outFoo, _arg_value); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_inoutFoo)?; _aidl_reply.write(&_arg_outFoo)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#returnsLengthOfFooArray => { let _arg_foos: Vec = _aidl_data.read()?; let _aidl_return = _aidl_service.r#returnsLengthOfFooArray(&_arg_foos); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#newApi => { let _aidl_return = _aidl_service.r#newApi(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#getInterfaceVersion => { let _aidl_return = _aidl_service.r#getInterfaceVersion(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#getInterfaceHash => { let _aidl_return = _aidl_service.r#getInterfaceHash(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } pub(crate) mod mangled { pub use super::r#IFooInterface as _7_android_4_aidl_9_versioned_5_tests_13_IFooInterface; } ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-rust-source_gen_android_aidl_ve0100644 0000000 0000000 00000000232 15172120304 033024 xustar000000000 0000000 126 path=tests/golden_output/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/tests/IFooInterface.rs.d 28 mtime=1776853188.5180000 tests/golden_output/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/tests/IF0100644 0000000 0000000 00000000712 15172120304 032714 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/tests/IFooInterface.rs : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/IFooInterface.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_aidl-test-versioned-interface-V3-rust-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 031724 xustar000000000 0000000 28 mtime=1776853188.5180000 tests/golden_output/aidl-test-versioned-interface-V3-rust-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 026716 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-cpp-source_0100644 0000000 0000000 00000000034 15172120304 026452 xustar000000000 0000000 28 mtime=1776853188.5180000 tests/golden_output/aidl_test_loggable_interface-cpp-source/0040755 0000000 0000000 00000000000 15172120304 023537 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-cpp-source_gen_0100644 0000000 0000000 00000000034 15172120304 027303 xustar000000000 0000000 28 mtime=1776853188.5180000 tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/0040755 0000000 0000000 00000000000 15172120304 024310 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-cpp-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 031003 xustar000000000 0000000 28 mtime=1776853188.5180000 tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 025730 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-cpp-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 031774 xustar000000000 0000000 28 mtime=1776853188.5180000 tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 026641 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-cpp-source_gen_android_aidl_loggabl0100644 0000000 0000000 00000000034 15172120304 033324 xustar000000000 0000000 28 mtime=1776853188.5180000 tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/0040755 0000000 0000000 00000000000 15172120304 030415 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-cpp-source_gen_android_aidl_loggabl0100644 0000000 0000000 00000000034 15172120304 033324 xustar000000000 0000000 28 mtime=1776853188.5180000 tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/Data.cpp0100644 0000000 0000000 00000007546 15172120304 032003 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging/android/aidl/loggable/Data.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Data.aidl */ #include namespace android { namespace aidl { namespace loggable { ::android::status_t Data::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&num); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readUtf8FromUtf16(&str); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelable(&nestedUnion); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readByte(reinterpret_cast(&nestedEnum)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t Data::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeInt32(num); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeUtf8AsUtf16(str); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelable(nestedUnion); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeByte(static_cast(nestedEnum)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace loggable } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-cpp-source_gen_android_aidl_loggabl0100644 0000000 0000000 00000000034 15172120304 033324 xustar000000000 0000000 28 mtime=1776853188.5180000 tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/Data.cpp.d0100644 0000000 0000000 00000000455 15172120304 032215 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/Data.cpp : \ system/tools/aidl/tests/android/aidl/loggable/Data.aidl \ system/tools/aidl/tests/android/aidl/loggable/Enum.aidl \ system/tools/aidl/tests/android/aidl/loggable/Union.aidl ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-cpp-source_gen_android_aidl_loggabl0100644 0000000 0000000 00000000034 15172120304 033324 xustar000000000 0000000 28 mtime=1776853188.5180000 tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/Enum.cpp0100644 0000000 0000000 00000001272 15172120304 032024 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging/android/aidl/loggable/Enum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Enum.aidl */ // This file is intentionally left blank as placeholder for enum declaration. ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-cpp-source_gen_android_aidl_loggabl0100644 0000000 0000000 00000000034 15172120304 033324 xustar000000000 0000000 28 mtime=1776853188.5180000 tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/Enum.cpp.d0100644 0000000 0000000 00000000264 15172120304 032246 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/Enum.cpp : \ system/tools/aidl/tests/android/aidl/loggable/Enum.aidl ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-cpp-source_gen_android_aidl_loggabl0100644 0000000 0000000 00000000222 15172120304 033323 xustar000000000 0000000 118 path=tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/ILoggableInterface.cpp 28 mtime=1776853188.5180000 tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/ILoggableInter0100644 0000000 0000000 00000074524 15172120304 033200 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging/android/aidl/loggable/ILoggableInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/ILoggableInterface.aidl */ #include #include namespace android { namespace aidl { namespace loggable { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE(LoggableInterface, "android.aidl.loggable.ILoggableInterface") } // namespace loggable } // namespace aidl } // namespace android #include #include #include #include #include namespace android { namespace aidl { namespace loggable { BpLoggableInterface::BpLoggableInterface(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } std::function BpLoggableInterface::logFunc; ::android::binder::Status BpLoggableInterface::LogThis(bool boolValue, ::std::vector* boolArray, int8_t byteValue, ::std::vector* byteArray, char16_t charValue, ::std::vector* charArray, int32_t intValue, ::std::vector* intArray, int64_t longValue, ::std::vector* longArray, float floatValue, ::std::vector* floatArray, double doubleValue, ::std::vector* doubleArray, const ::android::String16& stringValue, ::std::vector<::android::String16>* stringArray, ::std::vector<::android::String16>* listValue, const ::android::aidl::loggable::Data& dataValue, const ::android::sp<::android::IBinder>& binderValue, ::std::optional<::android::os::ParcelFileDescriptor>* pfdValue, ::std::vector<::android::os::ParcelFileDescriptor>* pfdArray, ::std::vector<::android::String16>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ILoggableInterface::LogThis::cppClient"); BpLoggableInterface::TransactionLog _transaction_log; if (BpLoggableInterface::logFunc != nullptr) { _transaction_log.input_args.emplace_back("boolValue", ::android::internal::ToString(boolValue)); _transaction_log.input_args.emplace_back("boolArray", ::android::internal::ToString(*boolArray)); _transaction_log.input_args.emplace_back("byteValue", ::android::internal::ToString(byteValue)); _transaction_log.input_args.emplace_back("byteArray", ::android::internal::ToString(*byteArray)); _transaction_log.input_args.emplace_back("charValue", ::android::internal::ToString(charValue)); _transaction_log.input_args.emplace_back("charArray", ::android::internal::ToString(*charArray)); _transaction_log.input_args.emplace_back("intValue", ::android::internal::ToString(intValue)); _transaction_log.input_args.emplace_back("intArray", ::android::internal::ToString(*intArray)); _transaction_log.input_args.emplace_back("longValue", ::android::internal::ToString(longValue)); _transaction_log.input_args.emplace_back("longArray", ::android::internal::ToString(*longArray)); _transaction_log.input_args.emplace_back("floatValue", ::android::internal::ToString(floatValue)); _transaction_log.input_args.emplace_back("floatArray", ::android::internal::ToString(*floatArray)); _transaction_log.input_args.emplace_back("doubleValue", ::android::internal::ToString(doubleValue)); _transaction_log.input_args.emplace_back("doubleArray", ::android::internal::ToString(*doubleArray)); _transaction_log.input_args.emplace_back("stringValue", ::android::internal::ToString(stringValue)); _transaction_log.input_args.emplace_back("stringArray", ::android::internal::ToString(*stringArray)); _transaction_log.input_args.emplace_back("listValue", ::android::internal::ToString(*listValue)); _transaction_log.input_args.emplace_back("dataValue", ::android::internal::ToString(dataValue)); _transaction_log.input_args.emplace_back("binderValue", ::android::internal::ToString(binderValue)); _transaction_log.input_args.emplace_back("pfdValue", ::android::internal::ToString(*pfdValue)); _transaction_log.input_args.emplace_back("pfdArray", ::android::internal::ToString(*pfdArray)); } auto _log_start = std::chrono::steady_clock::now(); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeBool(boolValue); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeBoolVector(*boolArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeByte(byteValue); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeByteVector(*byteArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeChar(charValue); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeCharVector(*charArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeInt32(intValue); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeInt32Vector(*intArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeInt64(longValue); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeInt64Vector(*longArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeFloat(floatValue); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeFloatVector(*floatArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeDouble(doubleValue); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeDoubleVector(*doubleArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeString16(stringValue); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeString16Vector(*stringArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeString16Vector(*listValue); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(dataValue); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinder(binderValue); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeNullableParcelable(*pfdValue); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelableVector(*pfdArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnLoggableInterface::TRANSACTION_LogThis, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ILoggableInterface::getDefaultImpl()) [[unlikely]] { return ILoggableInterface::getDefaultImpl()->LogThis(boolValue, boolArray, byteValue, byteArray, charValue, charArray, intValue, intArray, longValue, longArray, floatValue, floatArray, doubleValue, doubleArray, stringValue, stringArray, listValue, dataValue, binderValue, pfdValue, pfdArray, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readString16Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readBoolVector(boolArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readByteVector(byteArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readCharVector(charArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readInt32Vector(intArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readInt64Vector(longArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readFloatVector(floatArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readDoubleVector(doubleArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readString16Vector(stringArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readString16Vector(listValue); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readParcelable(pfdValue); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readParcelableVector(pfdArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (BpLoggableInterface::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.loggable.ILoggableInterface"; _transaction_log.method_name = "LogThis"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.output_args.emplace_back("boolArray", ::android::internal::ToString(*boolArray)); _transaction_log.output_args.emplace_back("byteArray", ::android::internal::ToString(*byteArray)); _transaction_log.output_args.emplace_back("charArray", ::android::internal::ToString(*charArray)); _transaction_log.output_args.emplace_back("intArray", ::android::internal::ToString(*intArray)); _transaction_log.output_args.emplace_back("longArray", ::android::internal::ToString(*longArray)); _transaction_log.output_args.emplace_back("floatArray", ::android::internal::ToString(*floatArray)); _transaction_log.output_args.emplace_back("doubleArray", ::android::internal::ToString(*doubleArray)); _transaction_log.output_args.emplace_back("stringArray", ::android::internal::ToString(*stringArray)); _transaction_log.output_args.emplace_back("listValue", ::android::internal::ToString(*listValue)); _transaction_log.output_args.emplace_back("pfdValue", ::android::internal::ToString(*pfdValue)); _transaction_log.output_args.emplace_back("pfdArray", ::android::internal::ToString(*pfdArray)); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpLoggableInterface::logFunc(_transaction_log); } return _aidl_status; } } // namespace loggable } // namespace aidl } // namespace android #include #include #include #include #include namespace android { namespace aidl { namespace loggable { BnLoggableInterface::BnLoggableInterface() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t BnLoggableInterface::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnLoggableInterface::TRANSACTION_LogThis: { bool in_boolValue; ::std::vector in_boolArray; int8_t in_byteValue; ::std::vector in_byteArray; char16_t in_charValue; ::std::vector in_charArray; int32_t in_intValue; ::std::vector in_intArray; int64_t in_longValue; ::std::vector in_longArray; float in_floatValue; ::std::vector in_floatArray; double in_doubleValue; ::std::vector in_doubleArray; ::android::String16 in_stringValue; ::std::vector<::android::String16> in_stringArray; ::std::vector<::android::String16> in_listValue; ::android::aidl::loggable::Data in_dataValue; ::android::sp<::android::IBinder> in_binderValue; ::std::optional<::android::os::ParcelFileDescriptor> in_pfdValue; ::std::vector<::android::os::ParcelFileDescriptor> in_pfdArray; ::std::vector<::android::String16> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ILoggableInterface::LogThis::cppServer"); _aidl_ret_status = _aidl_data.readBool(&in_boolValue); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readBoolVector(&in_boolArray); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readByte(&in_byteValue); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readByteVector(&in_byteArray); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readChar(&in_charValue); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readCharVector(&in_charArray); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readInt32(&in_intValue); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readInt32Vector(&in_intArray); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readInt64(&in_longValue); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readInt64Vector(&in_longArray); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readFloat(&in_floatValue); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readFloatVector(&in_floatArray); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readDouble(&in_doubleValue); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readDoubleVector(&in_doubleArray); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readString16(&in_stringValue); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readString16Vector(&in_stringArray); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readString16Vector(&in_listValue); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readParcelable(&in_dataValue); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readNullableStrongBinder(&in_binderValue); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readParcelable(&in_pfdValue); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readParcelableVector(&in_pfdArray); if (((_aidl_ret_status) != (::android::OK))) { break; } BnLoggableInterface::TransactionLog _transaction_log; if (BnLoggableInterface::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_boolValue", ::android::internal::ToString(in_boolValue)); _transaction_log.input_args.emplace_back("in_boolArray", ::android::internal::ToString(in_boolArray)); _transaction_log.input_args.emplace_back("in_byteValue", ::android::internal::ToString(in_byteValue)); _transaction_log.input_args.emplace_back("in_byteArray", ::android::internal::ToString(in_byteArray)); _transaction_log.input_args.emplace_back("in_charValue", ::android::internal::ToString(in_charValue)); _transaction_log.input_args.emplace_back("in_charArray", ::android::internal::ToString(in_charArray)); _transaction_log.input_args.emplace_back("in_intValue", ::android::internal::ToString(in_intValue)); _transaction_log.input_args.emplace_back("in_intArray", ::android::internal::ToString(in_intArray)); _transaction_log.input_args.emplace_back("in_longValue", ::android::internal::ToString(in_longValue)); _transaction_log.input_args.emplace_back("in_longArray", ::android::internal::ToString(in_longArray)); _transaction_log.input_args.emplace_back("in_floatValue", ::android::internal::ToString(in_floatValue)); _transaction_log.input_args.emplace_back("in_floatArray", ::android::internal::ToString(in_floatArray)); _transaction_log.input_args.emplace_back("in_doubleValue", ::android::internal::ToString(in_doubleValue)); _transaction_log.input_args.emplace_back("in_doubleArray", ::android::internal::ToString(in_doubleArray)); _transaction_log.input_args.emplace_back("in_stringValue", ::android::internal::ToString(in_stringValue)); _transaction_log.input_args.emplace_back("in_stringArray", ::android::internal::ToString(in_stringArray)); _transaction_log.input_args.emplace_back("in_listValue", ::android::internal::ToString(in_listValue)); _transaction_log.input_args.emplace_back("in_dataValue", ::android::internal::ToString(in_dataValue)); _transaction_log.input_args.emplace_back("in_binderValue", ::android::internal::ToString(in_binderValue)); _transaction_log.input_args.emplace_back("in_pfdValue", ::android::internal::ToString(in_pfdValue)); _transaction_log.input_args.emplace_back("in_pfdArray", ::android::internal::ToString(in_pfdArray)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(LogThis(in_boolValue, &in_boolArray, in_byteValue, &in_byteArray, in_charValue, &in_charArray, in_intValue, &in_intArray, in_longValue, &in_longArray, in_floatValue, &in_floatArray, in_doubleValue, &in_doubleArray, in_stringValue, &in_stringArray, &in_listValue, in_dataValue, in_binderValue, &in_pfdValue, &in_pfdArray, &_aidl_return)); if (BnLoggableInterface::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.loggable.ILoggableInterface"; _transaction_log.method_name = "LogThis"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.output_args.emplace_back("in_boolArray", ::android::internal::ToString(in_boolArray)); _transaction_log.output_args.emplace_back("in_byteArray", ::android::internal::ToString(in_byteArray)); _transaction_log.output_args.emplace_back("in_charArray", ::android::internal::ToString(in_charArray)); _transaction_log.output_args.emplace_back("in_intArray", ::android::internal::ToString(in_intArray)); _transaction_log.output_args.emplace_back("in_longArray", ::android::internal::ToString(in_longArray)); _transaction_log.output_args.emplace_back("in_floatArray", ::android::internal::ToString(in_floatArray)); _transaction_log.output_args.emplace_back("in_doubleArray", ::android::internal::ToString(in_doubleArray)); _transaction_log.output_args.emplace_back("in_stringArray", ::android::internal::ToString(in_stringArray)); _transaction_log.output_args.emplace_back("in_listValue", ::android::internal::ToString(in_listValue)); _transaction_log.output_args.emplace_back("in_pfdValue", ::android::internal::ToString(in_pfdValue)); _transaction_log.output_args.emplace_back("in_pfdArray", ::android::internal::ToString(in_pfdArray)); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnLoggableInterface::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeString16Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeBoolVector(in_boolArray); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeByteVector(in_byteArray); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeCharVector(in_charArray); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeInt32Vector(in_intArray); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeInt64Vector(in_longArray); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeFloatVector(in_floatArray); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeDoubleVector(in_doubleArray); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeString16Vector(in_stringArray); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeString16Vector(in_listValue); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeNullableParcelable(in_pfdValue); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeParcelableVector(in_pfdArray); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } std::function BnLoggableInterface::logFunc; } // namespace loggable } // namespace aidl } // namespace android #include #include namespace android { namespace aidl { namespace loggable { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_NESTED_INTERFACE(ILoggableInterface, Sub, "android.aidl.loggable.ILoggableInterface.ISub") } // namespace loggable } // namespace aidl } // namespace android #include #include #include #include #include namespace android { namespace aidl { namespace loggable { ILoggableInterface::BpSub::BpSub(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } std::function ILoggableInterface::BpSub::logFunc; ::android::binder::Status ILoggableInterface::BpSub::Log(int32_t value) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ISub::Log::cppClient"); ILoggableInterface::BpSub::TransactionLog _transaction_log; if (ILoggableInterface::BpSub::logFunc != nullptr) { _transaction_log.input_args.emplace_back("value", ::android::internal::ToString(value)); } auto _log_start = std::chrono::steady_clock::now(); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeInt32(value); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(ILoggableInterface::BnSub::TRANSACTION_Log, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ISub::getDefaultImpl()) [[unlikely]] { return ISub::getDefaultImpl()->Log(value); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (ILoggableInterface::BpSub::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.loggable.ILoggableInterface.ISub"; _transaction_log.method_name = "Log"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); ILoggableInterface::BpSub::logFunc(_transaction_log); } return _aidl_status; } } // namespace loggable } // namespace aidl } // namespace android #include #include #include #include #include namespace android { namespace aidl { namespace loggable { ILoggableInterface::BnSub::BnSub() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t ILoggableInterface::BnSub::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnSub::TRANSACTION_Log: { int32_t in_value; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ISub::Log::cppServer"); _aidl_ret_status = _aidl_data.readInt32(&in_value); if (((_aidl_ret_status) != (::android::OK))) { break; } ILoggableInterface::BnSub::TransactionLog _transaction_log; if (ILoggableInterface::BnSub::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_value", ::android::internal::ToString(in_value)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(Log(in_value)); if (ILoggableInterface::BnSub::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.loggable.ILoggableInterface.ISub"; _transaction_log.method_name = "Log"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); ILoggableInterface::BnSub::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } std::function ILoggableInterface::BnSub::logFunc; } // namespace loggable } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-cpp-source_gen_android_aidl_loggabl0100644 0000000 0000000 00000000224 15172120304 033325 xustar000000000 0000000 120 path=tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/ILoggableInterface.cpp.d 28 mtime=1776853188.5190000 tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/ILoggableInter0100644 0000000 0000000 00000000605 15172120304 033165 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/ILoggableInterface.cpp : \ system/tools/aidl/tests/android/aidl/loggable/ILoggableInterface.aidl \ system/tools/aidl/tests/android/aidl/loggable/Data.aidl \ system/tools/aidl/tests/android/aidl/loggable/Union.aidl \ system/tools/aidl/tests/android/aidl/loggable/Enum.aidl ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-cpp-source_gen_android_aidl_loggabl0100644 0000000 0000000 00000000034 15172120304 033324 xustar000000000 0000000 28 mtime=1776853188.5200000 tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/Union.cpp0100644 0000000 0000000 00000004471 15172120304 032214 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging/android/aidl/loggable/Union.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Union.aidl */ #include namespace android { namespace aidl { namespace loggable { ::android::status_t Union::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_tag)) != ::android::OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case num: { int32_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case str: { ::std::string _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readUtf8FromUtf16(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::std::string>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } } return ::android::BAD_VALUE; } ::android::status_t Union::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(getTag())); if (_aidl_ret_status != ::android::OK) return _aidl_ret_status; switch (getTag()) { case num: return _aidl_parcel->writeInt32(get()); case str: return _aidl_parcel->writeUtf8AsUtf16(get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace loggable } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-cpp-source_gen_android_aidl_loggabl0100644 0000000 0000000 00000000034 15172120304 033324 xustar000000000 0000000 28 mtime=1776853188.5200000 tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/Union.cpp.d0100644 0000000 0000000 00000000266 15172120304 032434 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/Union.cpp : \ system/tools/aidl/tests/android/aidl/loggable/Union.aidl ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-cpp-source_gen_include_0100644 0000000 0000000 00000000034 15172120304 031006 xustar000000000 0000000 28 mtime=1776853188.5200000 tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/include/0040755 0000000 0000000 00000000000 15172120304 025733 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-cpp-source_gen_include_android_0100644 0000000 0000000 00000000034 15172120304 032506 xustar000000000 0000000 28 mtime=1776853188.5200000 tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/include/android/0040755 0000000 0000000 00000000000 15172120304 027353 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-cpp-source_gen_include_android_aidl0100644 0000000 0000000 00000000034 15172120304 033340 xustar000000000 0000000 28 mtime=1776853188.5200000 tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/0040755 0000000 0000000 00000000000 15172120304 030264 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-cpp-source_gen_include_android_aidl0100644 0000000 0000000 00000000034 15172120304 033340 xustar000000000 0000000 28 mtime=1776853188.5200000 tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/0040755 0000000 0000000 00000000000 15172120304 032040 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-cpp-source_gen_include_android_aidl0100644 0000000 0000000 00000000214 15172120304 033340 xustar000000000 0000000 112 path=tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/BnData.h 28 mtime=1776853188.5200000 tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/BnData0100644 0000000 0000000 00000001247 15172120304 033115 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging/android/aidl/loggable/Data.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Data.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-cpp-source_gen_include_android_aidl0100644 0000000 0000000 00000000214 15172120304 033340 xustar000000000 0000000 112 path=tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/BnEnum.h 28 mtime=1776853188.5200000 tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/BnEnum0100644 0000000 0000000 00000001241 15172120304 033142 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging/android/aidl/loggable/Enum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Enum.aidl */ #error TODO(b/111362593) enums do not have bn classes./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-cpp-source_gen_include_android_aidl0100644 0000000 0000000 00000000231 15172120304 033337 xustar000000000 0000000 125 path=tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/BnLoggableInterface.h 28 mtime=1776853188.5200000 tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/BnLogg0100644 0000000 0000000 00000006654 15172120304 033143 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging/android/aidl/loggable/ILoggableInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/ILoggableInterface.aidl */ #pragma once #include #include #include #include #include #include #include namespace android { namespace aidl { namespace loggable { class BnLoggableInterface : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_LogThis = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; explicit BnLoggableInterface(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; }; // class BnLoggableInterface class ILoggableInterfaceDelegator : public BnLoggableInterface { public: explicit ILoggableInterfaceDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status LogThis(bool boolValue, ::std::vector* boolArray, int8_t byteValue, ::std::vector* byteArray, char16_t charValue, ::std::vector* charArray, int32_t intValue, ::std::vector* intArray, int64_t longValue, ::std::vector* longArray, float floatValue, ::std::vector* floatArray, double doubleValue, ::std::vector* doubleArray, const ::android::String16& stringValue, ::std::vector<::android::String16>* stringArray, ::std::vector<::android::String16>* listValue, const ::android::aidl::loggable::Data& dataValue, const ::android::sp<::android::IBinder>& binderValue, ::std::optional<::android::os::ParcelFileDescriptor>* pfdValue, ::std::vector<::android::os::ParcelFileDescriptor>* pfdArray, ::std::vector<::android::String16>* _aidl_return) override { return _aidl_delegate->LogThis(boolValue, boolArray, byteValue, byteArray, charValue, charArray, intValue, intArray, longValue, longArray, floatValue, floatArray, doubleValue, doubleArray, stringValue, stringArray, listValue, dataValue, binderValue, pfdValue, pfdArray, _aidl_return); } private: ::android::sp _aidl_delegate; }; // class ILoggableInterfaceDelegator } // namespace loggable } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-cpp-source_gen_include_android_aidl0100644 0000000 0000000 00000000215 15172120304 033341 xustar000000000 0000000 113 path=tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/BnUnion.h 28 mtime=1776853188.5210000 tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/BnUnio0100644 0000000 0000000 00000001251 15172120304 033151 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging/android/aidl/loggable/Union.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Union.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-cpp-source_gen_include_android_aidl0100644 0000000 0000000 00000000214 15172120304 033340 xustar000000000 0000000 112 path=tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/BpData.h 28 mtime=1776853188.5210000 tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/BpData0100644 0000000 0000000 00000001247 15172120304 033117 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging/android/aidl/loggable/Data.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Data.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-cpp-source_gen_include_android_aidl0100644 0000000 0000000 00000000214 15172120304 033340 xustar000000000 0000000 112 path=tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/BpEnum.h 28 mtime=1776853188.5210000 tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/BpEnum0100644 0000000 0000000 00000001241 15172120304 033144 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging/android/aidl/loggable/Enum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Enum.aidl */ #error TODO(b/111362593) enums do not have bp classes./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-cpp-source_gen_include_android_aidl0100644 0000000 0000000 00000000231 15172120304 033337 xustar000000000 0000000 125 path=tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/BpLoggableInterface.h 28 mtime=1776853188.5210000 tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/BpLogg0100644 0000000 0000000 00000005051 15172120304 033133 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging/android/aidl/loggable/ILoggableInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/ILoggableInterface.aidl */ #pragma once #include #include #include #include #include #include namespace android { namespace aidl { namespace loggable { class BpLoggableInterface : public ::android::BpInterface { public: explicit BpLoggableInterface(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpLoggableInterface() = default; ::android::binder::Status LogThis(bool boolValue, ::std::vector* boolArray, int8_t byteValue, ::std::vector* byteArray, char16_t charValue, ::std::vector* charArray, int32_t intValue, ::std::vector* intArray, int64_t longValue, ::std::vector* longArray, float floatValue, ::std::vector* floatArray, double doubleValue, ::std::vector* doubleArray, const ::android::String16& stringValue, ::std::vector<::android::String16>* stringArray, ::std::vector<::android::String16>* listValue, const ::android::aidl::loggable::Data& dataValue, const ::android::sp<::android::IBinder>& binderValue, ::std::optional<::android::os::ParcelFileDescriptor>* pfdValue, ::std::vector<::android::os::ParcelFileDescriptor>* pfdArray, ::std::vector<::android::String16>* _aidl_return) override; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; }; // class BpLoggableInterface } // namespace loggable } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-cpp-source_gen_include_android_aidl0100644 0000000 0000000 00000000215 15172120304 033341 xustar000000000 0000000 113 path=tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/BpUnion.h 28 mtime=1776853188.5210000 tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/BpUnio0100644 0000000 0000000 00000001251 15172120304 033153 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging/android/aidl/loggable/Union.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Union.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-cpp-source_gen_include_android_aidl0100644 0000000 0000000 00000000212 15172120304 033336 xustar000000000 0000000 110 path=tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/Data.h 28 mtime=1776853188.5210000 tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/Data.h0100644 0000000 0000000 00000005246 15172120304 033066 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging/android/aidl/loggable/Data.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Data.aidl */ #pragma once #include #include #include #include #include #include #include #include #include namespace android { namespace aidl { namespace loggable { class Data : public ::android::Parcelable { public: int32_t num = 0; ::std::string str; ::android::aidl::loggable::Union nestedUnion; ::android::aidl::loggable::Enum nestedEnum = ::android::aidl::loggable::Enum::FOO; inline bool operator==(const Data& _rhs) const { return std::tie(num, str, nestedUnion, nestedEnum) == std::tie(_rhs.num, _rhs.str, _rhs.nestedUnion, _rhs.nestedEnum); } inline bool operator<(const Data& _rhs) const { return std::tie(num, str, nestedUnion, nestedEnum) < std::tie(_rhs.num, _rhs.str, _rhs.nestedUnion, _rhs.nestedEnum); } inline bool operator!=(const Data& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Data& _rhs) const { return _rhs < *this; } inline bool operator>=(const Data& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Data& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.loggable.Data"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "Data{"; _aidl_os << "num: " << ::android::internal::ToString(num); _aidl_os << ", str: " << ::android::internal::ToString(str); _aidl_os << ", nestedUnion: " << ::android::internal::ToString(nestedUnion); _aidl_os << ", nestedEnum: " << ::android::internal::ToString(nestedEnum); _aidl_os << "}"; return _aidl_os.str(); } }; // class Data } // namespace loggable } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-cpp-source_gen_include_android_aidl0100644 0000000 0000000 00000000212 15172120304 033336 xustar000000000 0000000 110 path=tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/Enum.h 28 mtime=1776853188.5210000 tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/Enum.h0100644 0000000 0000000 00000003037 15172120304 033115 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging/android/aidl/loggable/Enum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Enum.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace loggable { enum class Enum : int8_t { FOO = 42, }; } // namespace loggable } // namespace aidl } // namespace android namespace android { namespace aidl { namespace loggable { [[nodiscard]] static inline std::string toString(Enum val) { switch(val) { case Enum::FOO: return "FOO"; default: return std::to_string(static_cast(val)); } } } // namespace loggable } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::loggable::Enum, 1> enum_values<::android::aidl::loggable::Enum> = { ::android::aidl::loggable::Enum::FOO, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-cpp-source_gen_include_android_aidl0100644 0000000 0000000 00000000230 15172120304 033336 xustar000000000 0000000 124 path=tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/ILoggableInterface.h 28 mtime=1776853188.5210000 tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/ILogga0100644 0000000 0000000 00000014057 15172120304 033131 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging/android/aidl/loggable/ILoggableInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/ILoggableInterface.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace android::aidl::loggable { class Data; } // namespace android::aidl::loggable namespace android { namespace aidl { namespace loggable { class ILoggableInterfaceDelegator; class ILoggableInterface : public ::android::IInterface { public: typedef ILoggableInterfaceDelegator DefaultDelegator; DECLARE_META_INTERFACE(LoggableInterface) class ISubDelegator; class ISub : public ::android::IInterface { public: typedef ISubDelegator DefaultDelegator; DECLARE_META_INTERFACE(Sub) virtual ::android::binder::Status Log(int32_t value) = 0; }; // class ISub class ISubDefault : public ISub { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status Log(int32_t /*value*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } }; // class ISubDefault class BpSub : public ::android::BpInterface { public: explicit BpSub(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpSub() = default; ::android::binder::Status Log(int32_t value) override; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; }; // class BpSub class BnSub : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_Log = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; explicit BnSub(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; }; // class BnSub class ISubDelegator : public BnSub { public: explicit ISubDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status Log(int32_t value) override { return _aidl_delegate->Log(value); } private: ::android::sp _aidl_delegate; }; // class ISubDelegator virtual ::android::binder::Status LogThis(bool boolValue, ::std::vector* boolArray, int8_t byteValue, ::std::vector* byteArray, char16_t charValue, ::std::vector* charArray, int32_t intValue, ::std::vector* intArray, int64_t longValue, ::std::vector* longArray, float floatValue, ::std::vector* floatArray, double doubleValue, ::std::vector* doubleArray, const ::android::String16& stringValue, ::std::vector<::android::String16>* stringArray, ::std::vector<::android::String16>* listValue, const ::android::aidl::loggable::Data& dataValue, const ::android::sp<::android::IBinder>& binderValue, ::std::optional<::android::os::ParcelFileDescriptor>* pfdValue, ::std::vector<::android::os::ParcelFileDescriptor>* pfdArray, ::std::vector<::android::String16>* _aidl_return) = 0; }; // class ILoggableInterface class ILoggableInterfaceDefault : public ILoggableInterface { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status LogThis(bool /*boolValue*/, ::std::vector* /*boolArray*/, int8_t /*byteValue*/, ::std::vector* /*byteArray*/, char16_t /*charValue*/, ::std::vector* /*charArray*/, int32_t /*intValue*/, ::std::vector* /*intArray*/, int64_t /*longValue*/, ::std::vector* /*longArray*/, float /*floatValue*/, ::std::vector* /*floatArray*/, double /*doubleValue*/, ::std::vector* /*doubleArray*/, const ::android::String16& /*stringValue*/, ::std::vector<::android::String16>* /*stringArray*/, ::std::vector<::android::String16>* /*listValue*/, const ::android::aidl::loggable::Data& /*dataValue*/, const ::android::sp<::android::IBinder>& /*binderValue*/, ::std::optional<::android::os::ParcelFileDescriptor>* /*pfdValue*/, ::std::vector<::android::os::ParcelFileDescriptor>* /*pfdArray*/, ::std::vector<::android::String16>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } }; // class ILoggableInterfaceDefault } // namespace loggable } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-cpp-source_gen_include_android_aidl0100644 0000000 0000000 00000000213 15172120304 033337 xustar000000000 0000000 111 path=tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/Union.h 28 mtime=1776853188.5210000 tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/Union.0100644 0000000 0000000 00000011706 15172120304 033133 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging/android/aidl/loggable/Union.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Union.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace android { namespace aidl { namespace loggable { class Union : public ::android::Parcelable { public: enum class Tag : int32_t { num = 0, str = 1, }; // Expose tag symbols for legacy code static const inline Tag num = Tag::num; static const inline Tag str = Tag::str; template static constexpr bool _not_self = !std::is_same_v>, Union>; Union() : _value(std::in_place_index(num)>, int32_t(43)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr Union(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit Union(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static Union make(_Tp&&... _args) { return Union(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static Union make(std::initializer_list<_Tp> _il, _Up&&... _args) { return Union(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } inline bool operator==(const Union& _rhs) const { return _value == _rhs._value; } inline bool operator<(const Union& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const Union& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Union& _rhs) const { return _rhs < *this; } inline bool operator>=(const Union& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Union& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.loggable.Union"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream os; os << "Union{"; switch (getTag()) { case num: os << "num: " << ::android::internal::ToString(get()); break; case str: os << "str: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant _value; }; // class Union } // namespace loggable } // namespace aidl } // namespace android namespace android { namespace aidl { namespace loggable { [[nodiscard]] static inline std::string toString(Union::Tag val) { switch(val) { case Union::Tag::num: return "num"; case Union::Tag::str: return "str"; default: return std::to_string(static_cast(val)); } } } // namespace loggable } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::loggable::Union::Tag, 2> enum_values<::android::aidl::loggable::Union::Tag> = { ::android::aidl::loggable::Union::Tag::num, ::android::aidl::loggable::Union::Tag::str, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-cpp-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 031227 xustar000000000 0000000 28 mtime=1776853188.5210000 tests/golden_output/aidl_test_loggable_interface-cpp-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 026221 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-java-source_0100644 0000000 0000000 00000000034 15172120304 026611 xustar000000000 0000000 28 mtime=1776853188.5210000 tests/golden_output/aidl_test_loggable_interface-java-source/0040755 0000000 0000000 00000000000 15172120304 023676 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-java-source_gen_0100644 0000000 0000000 00000000034 15172120304 027442 xustar000000000 0000000 28 mtime=1776853188.5210000 tests/golden_output/aidl_test_loggable_interface-java-source/gen/0040755 0000000 0000000 00000000000 15172120304 024447 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-java-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 031142 xustar000000000 0000000 28 mtime=1776853188.5210000 tests/golden_output/aidl_test_loggable_interface-java-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 026067 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-java-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 032133 xustar000000000 0000000 28 mtime=1776853188.5210000 tests/golden_output/aidl_test_loggable_interface-java-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 027000 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-java-source_gen_android_aidl_loggab0100644 0000000 0000000 00000000034 15172120304 033307 xustar000000000 0000000 28 mtime=1776853188.5210000 tests/golden_output/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/0040755 0000000 0000000 00000000000 15172120304 030554 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-java-source_gen_android_aidl_loggab0100644 0000000 0000000 00000000034 15172120304 033307 xustar000000000 0000000 28 mtime=1776853188.5210000 tests/golden_output/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/Data.java0100644 0000000 0000000 00000006204 15172120304 032267 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/Data.java.d -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Data.aidl */ package android.aidl.loggable; public class Data implements android.os.Parcelable { public int num = 0; public java.lang.String str; public android.aidl.loggable.Union nestedUnion; public byte nestedEnum = android.aidl.loggable.Enum.FOO; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public Data createFromParcel(android.os.Parcel _aidl_source) { Data _aidl_out = new Data(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public Data[] newArray(int _aidl_size) { return new Data[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(num); _aidl_parcel.writeString(str); _aidl_parcel.writeTypedObject(nestedUnion, _aidl_flag); _aidl_parcel.writeByte(nestedEnum); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; num = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; str = _aidl_parcel.readString(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; nestedUnion = _aidl_parcel.readTypedObject(android.aidl.loggable.Union.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; nestedEnum = _aidl_parcel.readByte(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; _mask |= describeContents(nestedUnion); return _mask; } private int describeContents(Object _v) { if (_v == null) return 0; if (_v instanceof android.os.Parcelable) { return ((android.os.Parcelable) _v).describeContents(); } return 0; } } ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-java-source_gen_android_aidl_loggab0100644 0000000 0000000 00000000034 15172120304 033307 xustar000000000 0000000 28 mtime=1776853188.5220000 tests/golden_output/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/Data.java.d0100644 0000000 0000000 00000000457 15172120304 032515 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/Data.java : \ system/tools/aidl/tests/android/aidl/loggable/Data.aidl \ system/tools/aidl/tests/android/aidl/loggable/Enum.aidl \ system/tools/aidl/tests/android/aidl/loggable/Union.aidl ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-java-source_gen_android_aidl_loggab0100644 0000000 0000000 00000000034 15172120304 033307 xustar000000000 0000000 28 mtime=1776853188.5220000 tests/golden_output/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/Enum.java0100644 0000000 0000000 00000001125 15172120304 032317 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/Enum.java.d -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Enum.aidl */ package android.aidl.loggable; public @interface Enum { public static final byte FOO = 42; } ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-java-source_gen_android_aidl_loggab0100644 0000000 0000000 00000000034 15172120304 033307 xustar000000000 0000000 28 mtime=1776853188.5220000 tests/golden_output/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/Enum.java.d0100644 0000000 0000000 00000000266 15172120304 032546 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/Enum.java : \ system/tools/aidl/tests/android/aidl/loggable/Enum.aidl ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-java-source_gen_android_aidl_loggab0100644 0000000 0000000 00000000224 15172120304 033310 xustar000000000 0000000 120 path=tests/golden_output/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/ILoggableInterface.java 28 mtime=1776853188.5300000 tests/golden_output/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/ILoggableInte0100644 0000000 0000000 00000034140 15172120304 033143 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/ILoggableInterface.java.d -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/ILoggableInterface.aidl */ package android.aidl.loggable; public interface ILoggableInterface extends android.os.IInterface { /** Default implementation for ILoggableInterface. */ public static class Default implements android.aidl.loggable.ILoggableInterface { @Override public java.lang.String[] LogThis(boolean boolValue, boolean[] boolArray, byte byteValue, byte[] byteArray, char charValue, char[] charArray, int intValue, int[] intArray, long longValue, long[] longArray, float floatValue, float[] floatArray, double doubleValue, double[] doubleArray, java.lang.String stringValue, java.lang.String[] stringArray, java.util.List listValue, android.aidl.loggable.Data dataValue, android.os.IBinder binderValue, android.os.ParcelFileDescriptor pfdValue, android.os.ParcelFileDescriptor[] pfdArray) throws android.os.RemoteException { return null; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.loggable.ILoggableInterface { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.loggable.ILoggableInterface interface, * generating a proxy if needed. */ public static android.aidl.loggable.ILoggableInterface asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.loggable.ILoggableInterface))) { return ((android.aidl.loggable.ILoggableInterface)iin); } return new android.aidl.loggable.ILoggableInterface.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_LogThis: { return "LogThis"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_LogThis: { boolean _arg0; _arg0 = data.readBoolean(); boolean[] _arg1; _arg1 = data.createBooleanArray(); byte _arg2; _arg2 = data.readByte(); byte[] _arg3; _arg3 = data.createByteArray(); char _arg4; _arg4 = (char)data.readInt(); char[] _arg5; _arg5 = data.createCharArray(); int _arg6; _arg6 = data.readInt(); int[] _arg7; _arg7 = data.createIntArray(); long _arg8; _arg8 = data.readLong(); long[] _arg9; _arg9 = data.createLongArray(); float _arg10; _arg10 = data.readFloat(); float[] _arg11; _arg11 = data.createFloatArray(); double _arg12; _arg12 = data.readDouble(); double[] _arg13; _arg13 = data.createDoubleArray(); java.lang.String _arg14; _arg14 = data.readString(); java.lang.String[] _arg15; _arg15 = data.createStringArray(); java.util.List _arg16; _arg16 = data.createStringArrayList(); android.aidl.loggable.Data _arg17; _arg17 = data.readTypedObject(android.aidl.loggable.Data.CREATOR); android.os.IBinder _arg18; _arg18 = data.readStrongBinder(); android.os.ParcelFileDescriptor _arg19; _arg19 = data.readTypedObject(android.os.ParcelFileDescriptor.CREATOR); android.os.ParcelFileDescriptor[] _arg20; _arg20 = data.createTypedArray(android.os.ParcelFileDescriptor.CREATOR); data.enforceNoDataAvail(); java.lang.String[] _result = this.LogThis(_arg0, _arg1, _arg2, _arg3, _arg4, _arg5, _arg6, _arg7, _arg8, _arg9, _arg10, _arg11, _arg12, _arg13, _arg14, _arg15, _arg16, _arg17, _arg18, _arg19, _arg20); reply.writeNoException(); reply.writeStringArray(_result); reply.writeBooleanArray(_arg1); reply.writeByteArray(_arg3); reply.writeCharArray(_arg5); reply.writeIntArray(_arg7); reply.writeLongArray(_arg9); reply.writeFloatArray(_arg11); reply.writeDoubleArray(_arg13); reply.writeStringArray(_arg15); reply.writeStringList(_arg16); reply.writeTypedObject(_arg19, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); reply.writeTypedArray(_arg20, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.loggable.ILoggableInterface { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public java.lang.String[] LogThis(boolean boolValue, boolean[] boolArray, byte byteValue, byte[] byteArray, char charValue, char[] charArray, int intValue, int[] intArray, long longValue, long[] longArray, float floatValue, float[] floatArray, double doubleValue, double[] doubleArray, java.lang.String stringValue, java.lang.String[] stringArray, java.util.List listValue, android.aidl.loggable.Data dataValue, android.os.IBinder binderValue, android.os.ParcelFileDescriptor pfdValue, android.os.ParcelFileDescriptor[] pfdArray) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.lang.String[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeBoolean(boolValue); _data.writeBooleanArray(boolArray); _data.writeByte(byteValue); _data.writeByteArray(byteArray); _data.writeInt(((int)charValue)); _data.writeCharArray(charArray); _data.writeInt(intValue); _data.writeIntArray(intArray); _data.writeLong(longValue); _data.writeLongArray(longArray); _data.writeFloat(floatValue); _data.writeFloatArray(floatArray); _data.writeDouble(doubleValue); _data.writeDoubleArray(doubleArray); _data.writeString(stringValue); _data.writeStringArray(stringArray); _data.writeStringList(listValue); _data.writeTypedObject(dataValue, 0); _data.writeStrongBinder(binderValue); _data.writeTypedObject(pfdValue, 0); _data.writeTypedArray(pfdArray, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_LogThis, _data, _reply, 0); _reply.readException(); _result = _reply.createStringArray(); _reply.readBooleanArray(boolArray); _reply.readByteArray(byteArray); _reply.readCharArray(charArray); _reply.readIntArray(intArray); _reply.readLongArray(longArray); _reply.readFloatArray(floatArray); _reply.readDoubleArray(doubleArray); _reply.readStringArray(stringArray); _reply.readStringList(listValue); if ((0!=_reply.readInt())) { pfdValue = android.os.ParcelFileDescriptor.CREATOR.createFromParcel(_reply); } _reply.readTypedArray(pfdArray, android.os.ParcelFileDescriptor.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } } static final int TRANSACTION_LogThis = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.loggable.ILoggableInterface"; public java.lang.String[] LogThis(boolean boolValue, boolean[] boolArray, byte byteValue, byte[] byteArray, char charValue, char[] charArray, int intValue, int[] intArray, long longValue, long[] longArray, float floatValue, float[] floatArray, double doubleValue, double[] doubleArray, java.lang.String stringValue, java.lang.String[] stringArray, java.util.List listValue, android.aidl.loggable.Data dataValue, android.os.IBinder binderValue, android.os.ParcelFileDescriptor pfdValue, android.os.ParcelFileDescriptor[] pfdArray) throws android.os.RemoteException; public interface ISub extends android.os.IInterface { /** Default implementation for ISub. */ public static class Default implements android.aidl.loggable.ILoggableInterface.ISub { @Override public void Log(int value) throws android.os.RemoteException { } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.loggable.ILoggableInterface.ISub { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.loggable.ILoggableInterface.ISub interface, * generating a proxy if needed. */ public static android.aidl.loggable.ILoggableInterface.ISub asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.loggable.ILoggableInterface.ISub))) { return ((android.aidl.loggable.ILoggableInterface.ISub)iin); } return new android.aidl.loggable.ILoggableInterface.ISub.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_Log: { return "Log"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_Log: { int _arg0; _arg0 = data.readInt(); data.enforceNoDataAvail(); this.Log(_arg0); reply.writeNoException(); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.loggable.ILoggableInterface.ISub { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public void Log(int value) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeInt(value); boolean _status = mRemote.transact(Stub.TRANSACTION_Log, _data, _reply, 0); _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } } static final int TRANSACTION_Log = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.loggable.ILoggableInterface.ISub"; public void Log(int value) throws android.os.RemoteException; } } ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-java-source_gen_android_aidl_loggab0100644 0000000 0000000 00000000226 15172120304 033312 xustar000000000 0000000 122 path=tests/golden_output/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/ILoggableInterface.java.d 28 mtime=1776853188.5310000 tests/golden_output/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/ILoggableInte0100644 0000000 0000000 00000000607 15172120304 033144 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/ILoggableInterface.java : \ system/tools/aidl/tests/android/aidl/loggable/ILoggableInterface.aidl \ system/tools/aidl/tests/android/aidl/loggable/Data.aidl \ system/tools/aidl/tests/android/aidl/loggable/Union.aidl \ system/tools/aidl/tests/android/aidl/loggable/Enum.aidl ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-java-source_gen_android_aidl_loggab0100644 0000000 0000000 00000000034 15172120304 033307 xustar000000000 0000000 28 mtime=1776853188.5310000 tests/golden_output/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/Union.java0100644 0000000 0000000 00000006644 15172120304 032516 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/Union.java.d -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Union.aidl */ package android.aidl.loggable; public final class Union implements android.os.Parcelable { // tags for union fields public final static int num = 0; // int num; public final static int str = 1; // String str; private int _tag; private Object _value; public Union() { int _value = 43; this._tag = num; this._value = _value; } private Union(android.os.Parcel _aidl_parcel) { readFromParcel(_aidl_parcel); } private Union(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public int getTag() { return _tag; } // int num; public static Union num(int _value) { return new Union(num, _value); } public int getNum() { _assertTag(num); return (int) _value; } public void setNum(int _value) { _set(num, _value); } // String str; public static Union str(java.lang.String _value) { return new Union(str, _value); } public java.lang.String getStr() { _assertTag(str); return (java.lang.String) _value; } public void setStr(java.lang.String _value) { _set(str, _value); } public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public Union createFromParcel(android.os.Parcel _aidl_source) { return new Union(_aidl_source); } @Override public Union[] newArray(int _aidl_size) { return new Union[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { _aidl_parcel.writeInt(_tag); switch (_tag) { case num: _aidl_parcel.writeInt(getNum()); break; case str: _aidl_parcel.writeString(getStr()); break; } } public void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_tag; _aidl_tag = _aidl_parcel.readInt(); switch (_aidl_tag) { case num: { int _aidl_value; _aidl_value = _aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } case str: { java.lang.String _aidl_value; _aidl_value = _aidl_parcel.readString(); _set(_aidl_tag, _aidl_value); return; } } throw new IllegalArgumentException("union: unknown tag: " + _aidl_tag); } @Override public int describeContents() { int _mask = 0; switch (getTag()) { } return _mask; } private void _assertTag(int tag) { if (getTag() != tag) { throw new IllegalStateException("bad access: " + _tagString(tag) + ", " + _tagString(getTag()) + " is available."); } } private String _tagString(int _tag) { switch (_tag) { case num: return "num"; case str: return "str"; } throw new IllegalStateException("unknown field: " + _tag); } private void _set(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public static @interface Tag { public static final int num = 0; public static final int str = 1; } } ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-java-source_gen_android_aidl_loggab0100644 0000000 0000000 00000000034 15172120304 033307 xustar000000000 0000000 28 mtime=1776853188.5320000 tests/golden_output/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/Union.java.d0100644 0000000 0000000 00000000270 15172120304 032725 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/Union.java : \ system/tools/aidl/tests/android/aidl/loggable/Union.aidl ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-java-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 031366 xustar000000000 0000000 28 mtime=1776853188.5320000 tests/golden_output/aidl_test_loggable_interface-java-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 026360 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-ndk-source_0100644 0000000 0000000 00000000034 15172120304 026444 xustar000000000 0000000 28 mtime=1776853188.5320000 tests/golden_output/aidl_test_loggable_interface-ndk-source/0040755 0000000 0000000 00000000000 15172120304 023531 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-ndk-source_gen_0100644 0000000 0000000 00000000034 15172120304 027275 xustar000000000 0000000 28 mtime=1776853188.5320000 tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/0040755 0000000 0000000 00000000000 15172120304 024302 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-ndk-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 030775 xustar000000000 0000000 28 mtime=1776853188.5320000 tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 025722 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-ndk-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 031766 xustar000000000 0000000 28 mtime=1776853188.5320000 tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 026633 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-ndk-source_gen_android_aidl_loggabl0100644 0000000 0000000 00000000034 15172120304 033316 xustar000000000 0000000 28 mtime=1776853188.5320000 tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/0040755 0000000 0000000 00000000000 15172120304 030407 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-ndk-source_gen_android_aidl_loggabl0100644 0000000 0000000 00000000034 15172120304 033316 xustar000000000 0000000 28 mtime=1776853188.5320000 tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/Data.cpp0100644 0000000 0000000 00000007647 15172120304 031777 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging/android/aidl/loggable/Data.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Data.aidl */ #include "aidl/android/aidl/loggable/Data.h" #include namespace aidl { namespace android { namespace aidl { namespace loggable { const char* Data::descriptor = "android.aidl.loggable.Data"; binder_status_t Data::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &num); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &str); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &nestedUnion); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &nestedEnum); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t Data::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, num); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, str); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, nestedUnion); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, nestedEnum); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace loggable } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-ndk-source_gen_android_aidl_loggabl0100644 0000000 0000000 00000000034 15172120304 033316 xustar000000000 0000000 28 mtime=1776853188.5320000 tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/Data.cpp.d0100644 0000000 0000000 00000000455 15172120304 032207 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/Data.cpp : \ system/tools/aidl/tests/android/aidl/loggable/Data.aidl \ system/tools/aidl/tests/android/aidl/loggable/Enum.aidl \ system/tools/aidl/tests/android/aidl/loggable/Union.aidl ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-ndk-source_gen_android_aidl_loggabl0100644 0000000 0000000 00000000034 15172120304 033316 xustar000000000 0000000 28 mtime=1776853188.5320000 tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/Enum.cpp0100644 0000000 0000000 00000001272 15172120304 032016 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging/android/aidl/loggable/Enum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Enum.aidl */ // This file is intentionally left blank as placeholder for enum declaration. ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-ndk-source_gen_android_aidl_loggabl0100644 0000000 0000000 00000000034 15172120304 033316 xustar000000000 0000000 28 mtime=1776853188.5320000 tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/Enum.cpp.d0100644 0000000 0000000 00000000264 15172120304 032240 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/Enum.cpp : \ system/tools/aidl/tests/android/aidl/loggable/Enum.aidl ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-ndk-source_gen_android_aidl_loggabl0100644 0000000 0000000 00000000222 15172120304 033315 xustar000000000 0000000 118 path=tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/ILoggableInterface.cpp 28 mtime=1776853188.5330000 tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/ILoggableInter0100644 0000000 0000000 00000107025 15172120304 033163 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging/android/aidl/loggable/ILoggableInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/ILoggableInterface.aidl */ #include "aidl/android/aidl/loggable/ILoggableInterface.h" #include #include #include #include namespace { struct ScopedTrace { inline explicit ScopedTrace(const char* name) { ATrace_beginSection(name); } inline ~ScopedTrace() { ATrace_endSection(); } }; } // namespace namespace aidl { namespace android { namespace aidl { namespace loggable { static binder_status_t _aidl_android_aidl_loggable_ILoggableInterface_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*LogThis*/): { bool in_boolValue; std::vector in_boolArray; int8_t in_byteValue; std::vector in_byteArray; char16_t in_charValue; std::vector in_charArray; int32_t in_intValue; std::vector in_intArray; int64_t in_longValue; std::vector in_longArray; float in_floatValue; std::vector in_floatArray; double in_doubleValue; std::vector in_doubleArray; std::string in_stringValue; std::vector in_stringArray; std::vector in_listValue; ::aidl::android::aidl::loggable::Data in_dataValue; ::ndk::SpAIBinder in_binderValue; ::ndk::ScopedFileDescriptor in_pfdValue; std::vector<::ndk::ScopedFileDescriptor> in_pfdArray; std::vector _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::ILoggableInterface::LogThis::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_boolValue); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_boolArray); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_byteValue); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_byteArray); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_charValue); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_charArray); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_intValue); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_intArray); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_longValue); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_longArray); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_floatValue); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_floatArray); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_doubleValue); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_doubleArray); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_stringValue); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_stringArray); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_listValue); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_dataValue); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_binderValue); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_pfdValue); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_pfdArray); if (_aidl_ret_status != STATUS_OK) break; BnLoggableInterface::TransactionLog _transaction_log; if (BnLoggableInterface::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_boolValue", ::android::internal::ToString(in_boolValue)); _transaction_log.input_args.emplace_back("in_boolArray", ::android::internal::ToString(in_boolArray)); _transaction_log.input_args.emplace_back("in_byteValue", ::android::internal::ToString(in_byteValue)); _transaction_log.input_args.emplace_back("in_byteArray", ::android::internal::ToString(in_byteArray)); _transaction_log.input_args.emplace_back("in_charValue", ::android::internal::ToString(in_charValue)); _transaction_log.input_args.emplace_back("in_charArray", ::android::internal::ToString(in_charArray)); _transaction_log.input_args.emplace_back("in_intValue", ::android::internal::ToString(in_intValue)); _transaction_log.input_args.emplace_back("in_intArray", ::android::internal::ToString(in_intArray)); _transaction_log.input_args.emplace_back("in_longValue", ::android::internal::ToString(in_longValue)); _transaction_log.input_args.emplace_back("in_longArray", ::android::internal::ToString(in_longArray)); _transaction_log.input_args.emplace_back("in_floatValue", ::android::internal::ToString(in_floatValue)); _transaction_log.input_args.emplace_back("in_floatArray", ::android::internal::ToString(in_floatArray)); _transaction_log.input_args.emplace_back("in_doubleValue", ::android::internal::ToString(in_doubleValue)); _transaction_log.input_args.emplace_back("in_doubleArray", ::android::internal::ToString(in_doubleArray)); _transaction_log.input_args.emplace_back("in_stringValue", ::android::internal::ToString(in_stringValue)); _transaction_log.input_args.emplace_back("in_stringArray", ::android::internal::ToString(in_stringArray)); _transaction_log.input_args.emplace_back("in_listValue", ::android::internal::ToString(in_listValue)); _transaction_log.input_args.emplace_back("in_dataValue", ::android::internal::ToString(in_dataValue)); _transaction_log.input_args.emplace_back("in_binderValue", ::android::internal::ToString(in_binderValue)); _transaction_log.input_args.emplace_back("in_pfdValue", ::android::internal::ToString(in_pfdValue)); _transaction_log.input_args.emplace_back("in_pfdArray", ::android::internal::ToString(in_pfdArray)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->LogThis(in_boolValue, &in_boolArray, in_byteValue, &in_byteArray, in_charValue, &in_charArray, in_intValue, &in_intArray, in_longValue, &in_longArray, in_floatValue, &in_floatArray, in_doubleValue, &in_doubleArray, in_stringValue, &in_stringArray, &in_listValue, in_dataValue, in_binderValue, &in_pfdValue, &in_pfdArray, &_aidl_return); if (BnLoggableInterface::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.loggable.ILoggableInterface"; _transaction_log.method_name = "LogThis"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.output_args.emplace_back("in_boolArray", ::android::internal::ToString(in_boolArray)); _transaction_log.output_args.emplace_back("in_byteArray", ::android::internal::ToString(in_byteArray)); _transaction_log.output_args.emplace_back("in_charArray", ::android::internal::ToString(in_charArray)); _transaction_log.output_args.emplace_back("in_intArray", ::android::internal::ToString(in_intArray)); _transaction_log.output_args.emplace_back("in_longArray", ::android::internal::ToString(in_longArray)); _transaction_log.output_args.emplace_back("in_floatArray", ::android::internal::ToString(in_floatArray)); _transaction_log.output_args.emplace_back("in_doubleArray", ::android::internal::ToString(in_doubleArray)); _transaction_log.output_args.emplace_back("in_stringArray", ::android::internal::ToString(in_stringArray)); _transaction_log.output_args.emplace_back("in_listValue", ::android::internal::ToString(in_listValue)); _transaction_log.output_args.emplace_back("in_pfdValue", ::android::internal::ToString(in_pfdValue)); _transaction_log.output_args.emplace_back("in_pfdArray", ::android::internal::ToString(in_pfdArray)); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnLoggableInterface::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, in_boolArray); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, in_byteArray); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, in_charArray); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, in_intArray); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, in_longArray); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, in_floatArray); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, in_doubleArray); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, in_stringArray); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, in_listValue); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, in_pfdValue); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, in_pfdArray); if (_aidl_ret_status != STATUS_OK) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_loggable_ILoggableInterface_clazz = ::ndk::ICInterface::defineClass(ILoggableInterface::descriptor, _aidl_android_aidl_loggable_ILoggableInterface_onTransact); BpLoggableInterface::BpLoggableInterface(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} BpLoggableInterface::~BpLoggableInterface() {} std::function BpLoggableInterface::logFunc; ::ndk::ScopedAStatus BpLoggableInterface::LogThis(bool in_boolValue, std::vector* in_boolArray, int8_t in_byteValue, std::vector* in_byteArray, char16_t in_charValue, std::vector* in_charArray, int32_t in_intValue, std::vector* in_intArray, int64_t in_longValue, std::vector* in_longArray, float in_floatValue, std::vector* in_floatArray, double in_doubleValue, std::vector* in_doubleArray, const std::string& in_stringValue, std::vector* in_stringArray, std::vector* in_listValue, const ::aidl::android::aidl::loggable::Data& in_dataValue, const ::ndk::SpAIBinder& in_binderValue, ::ndk::ScopedFileDescriptor* in_pfdValue, std::vector<::ndk::ScopedFileDescriptor>* in_pfdArray, std::vector* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; BpLoggableInterface::TransactionLog _transaction_log; if (BpLoggableInterface::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_boolValue", ::android::internal::ToString(in_boolValue)); _transaction_log.input_args.emplace_back("in_boolArray", ::android::internal::ToString(*in_boolArray)); _transaction_log.input_args.emplace_back("in_byteValue", ::android::internal::ToString(in_byteValue)); _transaction_log.input_args.emplace_back("in_byteArray", ::android::internal::ToString(*in_byteArray)); _transaction_log.input_args.emplace_back("in_charValue", ::android::internal::ToString(in_charValue)); _transaction_log.input_args.emplace_back("in_charArray", ::android::internal::ToString(*in_charArray)); _transaction_log.input_args.emplace_back("in_intValue", ::android::internal::ToString(in_intValue)); _transaction_log.input_args.emplace_back("in_intArray", ::android::internal::ToString(*in_intArray)); _transaction_log.input_args.emplace_back("in_longValue", ::android::internal::ToString(in_longValue)); _transaction_log.input_args.emplace_back("in_longArray", ::android::internal::ToString(*in_longArray)); _transaction_log.input_args.emplace_back("in_floatValue", ::android::internal::ToString(in_floatValue)); _transaction_log.input_args.emplace_back("in_floatArray", ::android::internal::ToString(*in_floatArray)); _transaction_log.input_args.emplace_back("in_doubleValue", ::android::internal::ToString(in_doubleValue)); _transaction_log.input_args.emplace_back("in_doubleArray", ::android::internal::ToString(*in_doubleArray)); _transaction_log.input_args.emplace_back("in_stringValue", ::android::internal::ToString(in_stringValue)); _transaction_log.input_args.emplace_back("in_stringArray", ::android::internal::ToString(*in_stringArray)); _transaction_log.input_args.emplace_back("in_listValue", ::android::internal::ToString(*in_listValue)); _transaction_log.input_args.emplace_back("in_dataValue", ::android::internal::ToString(in_dataValue)); _transaction_log.input_args.emplace_back("in_binderValue", ::android::internal::ToString(in_binderValue)); _transaction_log.input_args.emplace_back("in_pfdValue", ::android::internal::ToString(*in_pfdValue)); _transaction_log.input_args.emplace_back("in_pfdArray", ::android::internal::ToString(*in_pfdArray)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::ILoggableInterface::LogThis::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_boolValue); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), *in_boolArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_byteValue); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), *in_byteArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_charValue); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), *in_charArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_intValue); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), *in_intArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_longValue); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), *in_longArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_floatValue); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), *in_floatArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_doubleValue); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), *in_doubleArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_stringValue); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), *in_stringArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), *in_listValue); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_dataValue); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_binderValue); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), *in_pfdValue); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), *in_pfdArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*LogThis*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ILoggableInterface::getDefaultImpl()) { _aidl_status = ILoggableInterface::getDefaultImpl()->LogThis(in_boolValue, in_boolArray, in_byteValue, in_byteArray, in_charValue, in_charArray, in_intValue, in_intArray, in_longValue, in_longArray, in_floatValue, in_floatArray, in_doubleValue, in_doubleArray, in_stringValue, in_stringArray, in_listValue, in_dataValue, in_binderValue, in_pfdValue, in_pfdArray, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), in_boolArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), in_byteArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), in_charArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), in_intArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), in_longArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), in_floatArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), in_doubleArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), in_stringArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), in_listValue); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), in_pfdValue); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), in_pfdArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (BpLoggableInterface::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.loggable.ILoggableInterface"; _transaction_log.method_name = "LogThis"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.output_args.emplace_back("in_boolArray", ::android::internal::ToString(*in_boolArray)); _transaction_log.output_args.emplace_back("in_byteArray", ::android::internal::ToString(*in_byteArray)); _transaction_log.output_args.emplace_back("in_charArray", ::android::internal::ToString(*in_charArray)); _transaction_log.output_args.emplace_back("in_intArray", ::android::internal::ToString(*in_intArray)); _transaction_log.output_args.emplace_back("in_longArray", ::android::internal::ToString(*in_longArray)); _transaction_log.output_args.emplace_back("in_floatArray", ::android::internal::ToString(*in_floatArray)); _transaction_log.output_args.emplace_back("in_doubleArray", ::android::internal::ToString(*in_doubleArray)); _transaction_log.output_args.emplace_back("in_stringArray", ::android::internal::ToString(*in_stringArray)); _transaction_log.output_args.emplace_back("in_listValue", ::android::internal::ToString(*in_listValue)); _transaction_log.output_args.emplace_back("in_pfdValue", ::android::internal::ToString(*in_pfdValue)); _transaction_log.output_args.emplace_back("in_pfdArray", ::android::internal::ToString(*in_pfdArray)); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpLoggableInterface::logFunc(_transaction_log); } return _aidl_status; } // Source for BnLoggableInterface BnLoggableInterface::BnLoggableInterface() {} BnLoggableInterface::~BnLoggableInterface() {} std::function BnLoggableInterface::logFunc; ::ndk::SpAIBinder BnLoggableInterface::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_loggable_ILoggableInterface_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for ILoggableInterface const char* ILoggableInterface::descriptor = "android.aidl.loggable.ILoggableInterface"; ILoggableInterface::ILoggableInterface() {} ILoggableInterface::~ILoggableInterface() {} std::shared_ptr ILoggableInterface::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_loggable_ILoggableInterface_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t ILoggableInterface::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t ILoggableInterface::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = ILoggableInterface::fromBinder(binder); return STATUS_OK; } bool ILoggableInterface::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!ILoggableInterface::default_impl); if (impl) { ILoggableInterface::default_impl = impl; return true; } return false; } const std::shared_ptr& ILoggableInterface::getDefaultImpl() { return ILoggableInterface::default_impl; } std::shared_ptr ILoggableInterface::default_impl = nullptr; ::ndk::ScopedAStatus ILoggableInterfaceDefault::LogThis(bool /*in_boolValue*/, std::vector* /*in_boolArray*/, int8_t /*in_byteValue*/, std::vector* /*in_byteArray*/, char16_t /*in_charValue*/, std::vector* /*in_charArray*/, int32_t /*in_intValue*/, std::vector* /*in_intArray*/, int64_t /*in_longValue*/, std::vector* /*in_longArray*/, float /*in_floatValue*/, std::vector* /*in_floatArray*/, double /*in_doubleValue*/, std::vector* /*in_doubleArray*/, const std::string& /*in_stringValue*/, std::vector* /*in_stringArray*/, std::vector* /*in_listValue*/, const ::aidl::android::aidl::loggable::Data& /*in_dataValue*/, const ::ndk::SpAIBinder& /*in_binderValue*/, ::ndk::ScopedFileDescriptor* /*in_pfdValue*/, std::vector<::ndk::ScopedFileDescriptor>* /*in_pfdArray*/, std::vector* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::SpAIBinder ILoggableInterfaceDefault::asBinder() { return ::ndk::SpAIBinder(); } bool ILoggableInterfaceDefault::isRemote() { return false; } } // namespace loggable } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace loggable { static binder_status_t _aidl_android_aidl_loggable_ILoggableInterface_ISub_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*Log*/): { int32_t in_value; ScopedTrace _aidl_trace("AIDL::ndk::ISub::Log::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_value); if (_aidl_ret_status != STATUS_OK) break; ILoggableInterface::BnSub::TransactionLog _transaction_log; if (ILoggableInterface::BnSub::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_value", ::android::internal::ToString(in_value)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->Log(in_value); if (ILoggableInterface::BnSub::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.loggable.ILoggableInterface.ISub"; _transaction_log.method_name = "Log"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); ILoggableInterface::BnSub::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_loggable_ILoggableInterface_ISub_clazz = ::ndk::ICInterface::defineClass(ILoggableInterface::ISub::descriptor, _aidl_android_aidl_loggable_ILoggableInterface_ISub_onTransact); ILoggableInterface::BpSub::BpSub(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} ILoggableInterface::BpSub::~BpSub() {} std::function ILoggableInterface::BpSub::logFunc; ::ndk::ScopedAStatus ILoggableInterface::BpSub::Log(int32_t in_value) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; ILoggableInterface::BpSub::TransactionLog _transaction_log; if (ILoggableInterface::BpSub::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_value", ::android::internal::ToString(in_value)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::ISub::Log::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_value); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*Log*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ISub::getDefaultImpl()) { _aidl_status = ISub::getDefaultImpl()->Log(in_value); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (ILoggableInterface::BpSub::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.loggable.ILoggableInterface.ISub"; _transaction_log.method_name = "Log"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); ILoggableInterface::BpSub::logFunc(_transaction_log); } return _aidl_status; } // Source for BnSub ILoggableInterface::BnSub::BnSub() {} ILoggableInterface::BnSub::~BnSub() {} std::function ILoggableInterface::BnSub::logFunc; ::ndk::SpAIBinder ILoggableInterface::BnSub::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_loggable_ILoggableInterface_ISub_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for ISub const char* ILoggableInterface::ISub::descriptor = "android.aidl.loggable.ILoggableInterface.ISub"; ILoggableInterface::ISub::ISub() {} ILoggableInterface::ISub::~ISub() {} std::shared_ptr ILoggableInterface::ISub::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_loggable_ILoggableInterface_ISub_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t ILoggableInterface::ISub::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t ILoggableInterface::ISub::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = ISub::fromBinder(binder); return STATUS_OK; } bool ILoggableInterface::ISub::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!ISub::default_impl); if (impl) { ISub::default_impl = impl; return true; } return false; } const std::shared_ptr& ILoggableInterface::ISub::getDefaultImpl() { return ISub::default_impl; } std::shared_ptr ILoggableInterface::ISub::default_impl = nullptr; ::ndk::ScopedAStatus ILoggableInterface::ISubDefault::Log(int32_t /*in_value*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::SpAIBinder ILoggableInterface::ISubDefault::asBinder() { return ::ndk::SpAIBinder(); } bool ILoggableInterface::ISubDefault::isRemote() { return false; } } // namespace loggable } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-ndk-source_gen_android_aidl_loggabl0100644 0000000 0000000 00000000224 15172120304 033317 xustar000000000 0000000 120 path=tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/ILoggableInterface.cpp.d 28 mtime=1776853188.5340000 tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/ILoggableInter0100644 0000000 0000000 00000000605 15172120304 033157 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/ILoggableInterface.cpp : \ system/tools/aidl/tests/android/aidl/loggable/ILoggableInterface.aidl \ system/tools/aidl/tests/android/aidl/loggable/Data.aidl \ system/tools/aidl/tests/android/aidl/loggable/Union.aidl \ system/tools/aidl/tests/android/aidl/loggable/Enum.aidl ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-ndk-source_gen_android_aidl_loggabl0100644 0000000 0000000 00000000034 15172120304 033316 xustar000000000 0000000 28 mtime=1776853188.5340000 tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/Union.cpp0100644 0000000 0000000 00000004651 15172120304 032206 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging/android/aidl/loggable/Union.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Union.aidl */ #include "aidl/android/aidl/loggable/Union.h" #include namespace aidl { namespace android { namespace aidl { namespace loggable { const char* Union::descriptor = "android.aidl.loggable.Union"; binder_status_t Union::readFromParcel(const AParcel* _parcel) { binder_status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_tag)) != STATUS_OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case num: { int32_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case str: { std::string _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } } return STATUS_BAD_VALUE; } binder_status_t Union::writeToParcel(AParcel* _parcel) const { binder_status_t _aidl_ret_status = ::ndk::AParcel_writeData(_parcel, static_cast(getTag())); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; switch (getTag()) { case num: return ::ndk::AParcel_writeData(_parcel, get()); case str: return ::ndk::AParcel_writeData(_parcel, get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace loggable } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-ndk-source_gen_android_aidl_loggabl0100644 0000000 0000000 00000000034 15172120304 033316 xustar000000000 0000000 28 mtime=1776853188.5340000 tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/Union.cpp.d0100644 0000000 0000000 00000000266 15172120304 032426 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/Union.cpp : \ system/tools/aidl/tests/android/aidl/loggable/Union.aidl ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-ndk-source_gen_include_0100644 0000000 0000000 00000000034 15172120304 031000 xustar000000000 0000000 28 mtime=1776853188.5350000 tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/include/0040755 0000000 0000000 00000000000 15172120304 025725 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-ndk-source_gen_include_aidl_0100644 0000000 0000000 00000000034 15172120304 031771 xustar000000000 0000000 28 mtime=1776853188.5350000 tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/include/aidl/0040755 0000000 0000000 00000000000 15172120304 026636 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-ndk-source_gen_include_aidl_android0100644 0000000 0000000 00000000034 15172120304 033332 xustar000000000 0000000 28 mtime=1776853188.5350000 tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/0040755 0000000 0000000 00000000000 15172120304 030256 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-ndk-source_gen_include_aidl_android0100644 0000000 0000000 00000000034 15172120304 033332 xustar000000000 0000000 28 mtime=1776853188.5350000 tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/0040755 0000000 0000000 00000000000 15172120304 031167 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-ndk-source_gen_include_aidl_android0100644 0000000 0000000 00000000034 15172120304 033332 xustar000000000 0000000 28 mtime=1776853188.5350000 tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/0040755 0000000 0000000 00000000000 15172120304 032743 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-ndk-source_gen_include_aidl_android0100644 0000000 0000000 00000000221 15172120304 033330 xustar000000000 0000000 117 path=tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/BnData.h 28 mtime=1776853188.5350000 tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/B0100644 0000000 0000000 00000001252 15172120304 033044 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging/android/aidl/loggable/Data.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Data.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-ndk-source_gen_include_aidl_android0100644 0000000 0000000 00000000221 15172120304 033330 xustar000000000 0000000 117 path=tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/BnEnum.h 28 mtime=1776853188.5350000 tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/B0100644 0000000 0000000 00000001242 15172120304 033043 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging/android/aidl/loggable/Enum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Enum.aidl */ #error TODO(b/111362593) enums do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-ndk-source_gen_include_aidl_android0100644 0000000 0000000 00000000236 15172120304 033336 xustar000000000 0000000 130 path=tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/BnLoggableInterface.h 28 mtime=1776853188.5360000 tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/B0100644 0000000 0000000 00000006136 15172120304 033052 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging/android/aidl/loggable/ILoggableInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/ILoggableInterface.aidl */ #pragma once #include "aidl/android/aidl/loggable/ILoggableInterface.h" #include #include #ifndef __BIONIC__ #ifndef __assert2 #define __assert2(a,b,c,d) ((void)0) #endif #endif namespace aidl { namespace android { namespace aidl { namespace loggable { class BnLoggableInterface : public ::ndk::BnCInterface { public: BnLoggableInterface(); virtual ~BnLoggableInterface(); struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; protected: ::ndk::SpAIBinder createBinder() override; private: }; class ILoggableInterfaceDelegator : public BnLoggableInterface { public: explicit ILoggableInterfaceDelegator(const std::shared_ptr &impl) : _impl(impl) { } ::ndk::ScopedAStatus LogThis(bool in_boolValue, std::vector* in_boolArray, int8_t in_byteValue, std::vector* in_byteArray, char16_t in_charValue, std::vector* in_charArray, int32_t in_intValue, std::vector* in_intArray, int64_t in_longValue, std::vector* in_longArray, float in_floatValue, std::vector* in_floatArray, double in_doubleValue, std::vector* in_doubleArray, const std::string& in_stringValue, std::vector* in_stringArray, std::vector* in_listValue, const ::aidl::android::aidl::loggable::Data& in_dataValue, const ::ndk::SpAIBinder& in_binderValue, ::ndk::ScopedFileDescriptor* in_pfdValue, std::vector<::ndk::ScopedFileDescriptor>* in_pfdArray, std::vector* _aidl_return) override { return _impl->LogThis(in_boolValue, in_boolArray, in_byteValue, in_byteArray, in_charValue, in_charArray, in_intValue, in_intArray, in_longValue, in_longArray, in_floatValue, in_floatArray, in_doubleValue, in_doubleArray, in_stringValue, in_stringArray, in_listValue, in_dataValue, in_binderValue, in_pfdValue, in_pfdArray, _aidl_return); } protected: private: std::shared_ptr _impl; }; } // namespace loggable } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-ndk-source_gen_include_aidl_android0100644 0000000 0000000 00000000222 15172120304 033331 xustar000000000 0000000 118 path=tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/BnUnion.h 28 mtime=1776853188.5360000 tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/B0100644 0000000 0000000 00000001254 15172120304 033046 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging/android/aidl/loggable/Union.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Union.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-ndk-source_gen_include_aidl_android0100644 0000000 0000000 00000000221 15172120304 033330 xustar000000000 0000000 117 path=tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/BpData.h 28 mtime=1776853188.5360000 tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/B0100644 0000000 0000000 00000001252 15172120304 033044 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging/android/aidl/loggable/Data.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Data.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-ndk-source_gen_include_aidl_android0100644 0000000 0000000 00000000221 15172120304 033330 xustar000000000 0000000 117 path=tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/BpEnum.h 28 mtime=1776853188.5360000 tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/B0100644 0000000 0000000 00000001242 15172120304 033043 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging/android/aidl/loggable/Enum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Enum.aidl */ #error TODO(b/111362593) enums do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-ndk-source_gen_include_aidl_android0100644 0000000 0000000 00000000236 15172120304 033336 xustar000000000 0000000 130 path=tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/BpLoggableInterface.h 28 mtime=1776853188.5360000 tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/B0100644 0000000 0000000 00000004731 15172120304 033051 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging/android/aidl/loggable/ILoggableInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/ILoggableInterface.aidl */ #pragma once #include "aidl/android/aidl/loggable/ILoggableInterface.h" #include #include #include #include #include namespace aidl { namespace android { namespace aidl { namespace loggable { class BpLoggableInterface : public ::ndk::BpCInterface { public: explicit BpLoggableInterface(const ::ndk::SpAIBinder& binder); virtual ~BpLoggableInterface(); ::ndk::ScopedAStatus LogThis(bool in_boolValue, std::vector* in_boolArray, int8_t in_byteValue, std::vector* in_byteArray, char16_t in_charValue, std::vector* in_charArray, int32_t in_intValue, std::vector* in_intArray, int64_t in_longValue, std::vector* in_longArray, float in_floatValue, std::vector* in_floatArray, double in_doubleValue, std::vector* in_doubleArray, const std::string& in_stringValue, std::vector* in_stringArray, std::vector* in_listValue, const ::aidl::android::aidl::loggable::Data& in_dataValue, const ::ndk::SpAIBinder& in_binderValue, ::ndk::ScopedFileDescriptor* in_pfdValue, std::vector<::ndk::ScopedFileDescriptor>* in_pfdArray, std::vector* _aidl_return) override; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; }; } // namespace loggable } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-ndk-source_gen_include_aidl_android0100644 0000000 0000000 00000000222 15172120304 033331 xustar000000000 0000000 118 path=tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/BpUnion.h 28 mtime=1776853188.5370000 tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/B0100644 0000000 0000000 00000001254 15172120304 033046 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging/android/aidl/loggable/Union.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Union.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-ndk-source_gen_include_aidl_android0100644 0000000 0000000 00000000217 15172120304 033335 xustar000000000 0000000 115 path=tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/Data.h 28 mtime=1776853188.5370000 tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/D0100644 0000000 0000000 00000005413 15172120304 033051 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging/android/aidl/loggable/Data.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Data.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace loggable { class Data { public: typedef std::false_type fixed_size; static const char* descriptor; int32_t num = 0; std::string str; ::aidl::android::aidl::loggable::Union nestedUnion; ::aidl::android::aidl::loggable::Enum nestedEnum = ::aidl::android::aidl::loggable::Enum::FOO; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const Data& _rhs) const { return std::tie(num, str, nestedUnion, nestedEnum) == std::tie(_rhs.num, _rhs.str, _rhs.nestedUnion, _rhs.nestedEnum); } inline bool operator<(const Data& _rhs) const { return std::tie(num, str, nestedUnion, nestedEnum) < std::tie(_rhs.num, _rhs.str, _rhs.nestedUnion, _rhs.nestedEnum); } inline bool operator!=(const Data& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Data& _rhs) const { return _rhs < *this; } inline bool operator>=(const Data& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Data& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "Data{"; _aidl_os << "num: " << ::android::internal::ToString(num); _aidl_os << ", str: " << ::android::internal::ToString(str); _aidl_os << ", nestedUnion: " << ::android::internal::ToString(nestedUnion); _aidl_os << ", nestedEnum: " << ::android::internal::ToString(nestedEnum); _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace loggable } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-ndk-source_gen_include_aidl_android0100644 0000000 0000000 00000000217 15172120304 033335 xustar000000000 0000000 115 path=tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/Enum.h 28 mtime=1776853188.5370000 tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/E0100644 0000000 0000000 00000003432 15172120304 033051 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging/android/aidl/loggable/Enum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Enum.aidl */ #pragma once #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace loggable { enum class Enum : int8_t { FOO = 42, }; } // namespace loggable } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace loggable { [[nodiscard]] static inline std::string toString(Enum val) { switch(val) { case Enum::FOO: return "FOO"; default: return std::to_string(static_cast(val)); } } } // namespace loggable } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::loggable::Enum::FOO, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-ndk-source_gen_include_aidl_android0100644 0000000 0000000 00000000235 15172120304 033335 xustar000000000 0000000 129 path=tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/ILoggableInterface.h 28 mtime=1776853188.5370000 tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/I0100644 0000000 0000000 00000014362 15172120304 033061 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging/android/aidl/loggable/ILoggableInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/ILoggableInterface.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl::android::aidl::loggable { class Data; } // namespace aidl::android::aidl::loggable namespace aidl { namespace android { namespace aidl { namespace loggable { class ILoggableInterfaceDelegator; class ILoggableInterface : public ::ndk::ICInterface { public: typedef ILoggableInterfaceDelegator DefaultDelegator; static const char* descriptor; ILoggableInterface(); virtual ~ILoggableInterface(); class ISubDelegator; class ISub : public ::ndk::ICInterface { public: typedef ISubDelegator DefaultDelegator; static const char* descriptor; ISub(); virtual ~ISub(); static constexpr uint32_t TRANSACTION_Log = FIRST_CALL_TRANSACTION + 0; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus Log(int32_t in_value) = 0; private: static std::shared_ptr default_impl; }; class ISubDefault : public ISub { public: ::ndk::ScopedAStatus Log(int32_t in_value) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; class BpSub : public ::ndk::BpCInterface { public: explicit BpSub(const ::ndk::SpAIBinder& binder); virtual ~BpSub(); ::ndk::ScopedAStatus Log(int32_t in_value) override; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; }; class BnSub : public ::ndk::BnCInterface { public: BnSub(); virtual ~BnSub(); struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; protected: ::ndk::SpAIBinder createBinder() override; private: }; static constexpr uint32_t TRANSACTION_LogThis = FIRST_CALL_TRANSACTION + 0; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus LogThis(bool in_boolValue, std::vector* in_boolArray, int8_t in_byteValue, std::vector* in_byteArray, char16_t in_charValue, std::vector* in_charArray, int32_t in_intValue, std::vector* in_intArray, int64_t in_longValue, std::vector* in_longArray, float in_floatValue, std::vector* in_floatArray, double in_doubleValue, std::vector* in_doubleArray, const std::string& in_stringValue, std::vector* in_stringArray, std::vector* in_listValue, const ::aidl::android::aidl::loggable::Data& in_dataValue, const ::ndk::SpAIBinder& in_binderValue, ::ndk::ScopedFileDescriptor* in_pfdValue, std::vector<::ndk::ScopedFileDescriptor>* in_pfdArray, std::vector* _aidl_return) = 0; private: static std::shared_ptr default_impl; }; class ILoggableInterfaceDefault : public ILoggableInterface { public: ::ndk::ScopedAStatus LogThis(bool in_boolValue, std::vector* in_boolArray, int8_t in_byteValue, std::vector* in_byteArray, char16_t in_charValue, std::vector* in_charArray, int32_t in_intValue, std::vector* in_intArray, int64_t in_longValue, std::vector* in_longArray, float in_floatValue, std::vector* in_floatArray, double in_doubleValue, std::vector* in_doubleArray, const std::string& in_stringValue, std::vector* in_stringArray, std::vector* in_listValue, const ::aidl::android::aidl::loggable::Data& in_dataValue, const ::ndk::SpAIBinder& in_binderValue, ::ndk::ScopedFileDescriptor* in_pfdValue, std::vector<::ndk::ScopedFileDescriptor>* in_pfdArray, std::vector* _aidl_return) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; } // namespace loggable } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-ndk-source_gen_include_aidl_android0100644 0000000 0000000 00000000220 15172120304 033327 xustar000000000 0000000 116 path=tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/Union.h 28 mtime=1776853188.5370000 tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/U0100644 0000000 0000000 00000012126 15172120304 033071 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging/android/aidl/loggable/Union.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Union.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace aidl { namespace android { namespace aidl { namespace loggable { class Union { public: typedef std::false_type fixed_size; static const char* descriptor; enum class Tag : int32_t { num = 0, str = 1, }; // Expose tag symbols for legacy code static const inline Tag num = Tag::num; static const inline Tag str = Tag::str; template static constexpr bool _not_self = !std::is_same_v>, Union>; Union() : _value(std::in_place_index(num)>, int32_t(43)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr Union(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit Union(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static Union make(_Tp&&... _args) { return Union(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static Union make(std::initializer_list<_Tp> _il, _Up&&... _args) { return Union(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } binder_status_t readFromParcel(const AParcel* _parcel); binder_status_t writeToParcel(AParcel* _parcel) const; inline bool operator==(const Union& _rhs) const { return _value == _rhs._value; } inline bool operator<(const Union& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const Union& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Union& _rhs) const { return _rhs < *this; } inline bool operator>=(const Union& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Union& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream os; os << "Union{"; switch (getTag()) { case num: os << "num: " << ::android::internal::ToString(get()); break; case str: os << "str: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant _value; }; } // namespace loggable } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace loggable { [[nodiscard]] static inline std::string toString(Union::Tag val) { switch(val) { case Union::Tag::num: return "num"; case Union::Tag::str: return "str"; default: return std::to_string(static_cast(val)); } } } // namespace loggable } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::loggable::Union::Tag::num, aidl::android::aidl::loggable::Union::Tag::str, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_aidl_test_loggable_interface-ndk-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 031221 xustar000000000 0000000 28 mtime=1776853188.5370000 tests/golden_output/aidl_test_loggable_interface-ndk-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 026213 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_0100644 0000000 0000000 00000000034 15172120304 020053 xustar000000000 0000000 28 mtime=1776853188.5380000 tests/golden_output/frozen/0040755 0000000 0000000 00000000000 15172120304 015140 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-cpp-java-test-interface-cpp-source_0100644 0000000 0000000 00000000034 15172120304 027534 xustar000000000 0000000 28 mtime=1776853188.5380000 tests/golden_output/frozen/aidl-cpp-java-test-interface-cpp-source/0040755 0000000 0000000 00000000000 15172120304 024541 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-cpp-java-test-interface-cpp-source_gen_0100644 0000000 0000000 00000000034 15172120304 030365 xustar000000000 0000000 28 mtime=1776853188.5380000 tests/golden_output/frozen/aidl-cpp-java-test-interface-cpp-source/gen/0040755 0000000 0000000 00000000000 15172120304 025312 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-cpp-java-test-interface-cpp-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 032065 xustar000000000 0000000 28 mtime=1776853188.5380000 tests/golden_output/frozen/aidl-cpp-java-test-interface-cpp-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 026732 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-cpp-java-test-interface-cpp-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 033056 xustar000000000 0000000 28 mtime=1776853188.5380000 tests/golden_output/frozen/aidl-cpp-java-test-interface-cpp-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 027643 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-cpp-java-test-interface-cpp-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 033056 xustar000000000 0000000 28 mtime=1776853188.5380000 tests/golden_output/frozen/aidl-cpp-java-test-interface-cpp-source/gen/android/aidl/tests/0040755 0000000 0000000 00000000000 15172120304 031005 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-cpp-java-test-interface-cpp-source_gen_android_aidl_0100644 0000000 0000000 00000000221 15172120304 033054 xustar000000000 0000000 117 path=tests/golden_output/frozen/aidl-cpp-java-test-interface-cpp-source/gen/android/aidl/tests/BadParcelable.cpp 28 mtime=1776853188.5380000 tests/golden_output/frozen/aidl-cpp-java-test-interface-cpp-source/gen/android/aidl/tests/BadParcela0100644 0000000 0000000 00000001467 15172120304 032713 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -t --min_sdk_version current -pout/soong/.intermediates/system/tools/aidl/aidl-test-interface_interface/preprocessed.aidl --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/staging/android/aidl/tests/BadParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/staging -Iframeworks/native/aidl/binder -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/BadParcelable.aidl */ // This file is intentionally left blank as placeholder for parcel declaration. ./PaxHeaders.X/tests_golden_output_frozen_aidl-cpp-java-test-interface-cpp-source_gen_android_aidl_0100644 0000000 0000000 00000000223 15172120304 033056 xustar000000000 0000000 119 path=tests/golden_output/frozen/aidl-cpp-java-test-interface-cpp-source/gen/android/aidl/tests/BadParcelable.cpp.d 28 mtime=1776853188.5400000 tests/golden_output/frozen/aidl-cpp-java-test-interface-cpp-source/gen/android/aidl/tests/BadParcela0100644 0000000 0000000 00000000300 15172120304 032674 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/android/aidl/tests/BadParcelable.cpp : \ system/tools/aidl/tests/android/aidl/tests/BadParcelable.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-cpp-java-test-interface-cpp-source_gen_android_aidl_0100644 0000000 0000000 00000000221 15172120304 033054 xustar000000000 0000000 117 path=tests/golden_output/frozen/aidl-cpp-java-test-interface-cpp-source/gen/android/aidl/tests/ICppJavaTests.cpp 28 mtime=1776853188.5400000 tests/golden_output/frozen/aidl-cpp-java-test-interface-cpp-source/gen/android/aidl/tests/ICppJavaTe0100644 0000000 0000000 00000065625 15172120304 032671 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -t --min_sdk_version current -pout/soong/.intermediates/system/tools/aidl/aidl-test-interface_interface/preprocessed.aidl --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/staging/android/aidl/tests/ICppJavaTests.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/staging -Iframeworks/native/aidl/binder -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ICppJavaTests.aidl */ #include #include namespace android { namespace aidl { namespace tests { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE(CppJavaTests, "android.aidl.tests.ICppJavaTests") } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { BpCppJavaTests::BpCppJavaTests(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } ::android::binder::Status BpCppJavaTests::RepeatBadParcelable(const ::android::aidl::tests::BadParcelable& input, ::android::aidl::tests::BadParcelable* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICppJavaTests::RepeatBadParcelable::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnCppJavaTests::TRANSACTION_RepeatBadParcelable, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ICppJavaTests::getDefaultImpl()) [[unlikely]] { return ICppJavaTests::getDefaultImpl()->RepeatBadParcelable(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpCppJavaTests::RepeatGenericParcelable(const ::android::aidl::tests::GenericStructuredParcelable& input, ::android::aidl::tests::GenericStructuredParcelable* repeat, ::android::aidl::tests::GenericStructuredParcelable* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICppJavaTests::RepeatGenericParcelable::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnCppJavaTests::TRANSACTION_RepeatGenericParcelable, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ICppJavaTests::getDefaultImpl()) [[unlikely]] { return ICppJavaTests::getDefaultImpl()->RepeatGenericParcelable(input, repeat, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readParcelable(repeat); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpCppJavaTests::RepeatPersistableBundle(const ::android::os::PersistableBundle& input, ::android::os::PersistableBundle* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICppJavaTests::RepeatPersistableBundle::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnCppJavaTests::TRANSACTION_RepeatPersistableBundle, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ICppJavaTests::getDefaultImpl()) [[unlikely]] { return ICppJavaTests::getDefaultImpl()->RepeatPersistableBundle(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpCppJavaTests::ReversePersistableBundles(const ::std::vector<::android::os::PersistableBundle>& input, ::std::vector<::android::os::PersistableBundle>* repeated, ::std::vector<::android::os::PersistableBundle>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICppJavaTests::ReversePersistableBundles::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelableVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnCppJavaTests::TRANSACTION_ReversePersistableBundles, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ICppJavaTests::getDefaultImpl()) [[unlikely]] { return ICppJavaTests::getDefaultImpl()->ReversePersistableBundles(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelableVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readParcelableVector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpCppJavaTests::ReverseUnion(const ::android::aidl::tests::Union& input, ::android::aidl::tests::Union* repeated, ::android::aidl::tests::Union* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICppJavaTests::ReverseUnion::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnCppJavaTests::TRANSACTION_ReverseUnion, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ICppJavaTests::getDefaultImpl()) [[unlikely]] { return ICppJavaTests::getDefaultImpl()->ReverseUnion(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readParcelable(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpCppJavaTests::ReverseNamedCallbackList(const ::std::vector<::android::sp<::android::IBinder>>& input, ::std::vector<::android::sp<::android::IBinder>>* repeated, ::std::vector<::android::sp<::android::IBinder>>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICppJavaTests::ReverseNamedCallbackList::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinderVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnCppJavaTests::TRANSACTION_ReverseNamedCallbackList, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ICppJavaTests::getDefaultImpl()) [[unlikely]] { return ICppJavaTests::getDefaultImpl()->ReverseNamedCallbackList(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpCppJavaTests::RepeatFileDescriptor(::android::base::unique_fd read, ::android::base::unique_fd* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICppJavaTests::RepeatFileDescriptor::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeUniqueFileDescriptor(read); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnCppJavaTests::TRANSACTION_RepeatFileDescriptor, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ICppJavaTests::getDefaultImpl()) [[unlikely]] { return ICppJavaTests::getDefaultImpl()->RepeatFileDescriptor(std::move(read), _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readUniqueFileDescriptor(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpCppJavaTests::ReverseFileDescriptorArray(const ::std::vector<::android::base::unique_fd>& input, ::std::vector<::android::base::unique_fd>* repeated, ::std::vector<::android::base::unique_fd>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICppJavaTests::ReverseFileDescriptorArray::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeUniqueFileDescriptorVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnCppJavaTests::TRANSACTION_ReverseFileDescriptorArray, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ICppJavaTests::getDefaultImpl()) [[unlikely]] { return ICppJavaTests::getDefaultImpl()->ReverseFileDescriptorArray(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readUniqueFileDescriptorVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readUniqueFileDescriptorVector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { BnCppJavaTests::BnCppJavaTests() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t BnCppJavaTests::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnCppJavaTests::TRANSACTION_RepeatBadParcelable: { ::android::aidl::tests::BadParcelable in_input; ::android::aidl::tests::BadParcelable _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICppJavaTests::RepeatBadParcelable::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatBadParcelable(in_input, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnCppJavaTests::TRANSACTION_RepeatGenericParcelable: { ::android::aidl::tests::GenericStructuredParcelable in_input; ::android::aidl::tests::GenericStructuredParcelable out_repeat; ::android::aidl::tests::GenericStructuredParcelable _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICppJavaTests::RepeatGenericParcelable::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatGenericParcelable(in_input, &out_repeat, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(out_repeat); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnCppJavaTests::TRANSACTION_RepeatPersistableBundle: { ::android::os::PersistableBundle in_input; ::android::os::PersistableBundle _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICppJavaTests::RepeatPersistableBundle::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatPersistableBundle(in_input, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnCppJavaTests::TRANSACTION_ReversePersistableBundles: { ::std::vector<::android::os::PersistableBundle> in_input; ::std::vector<::android::os::PersistableBundle> out_repeated; ::std::vector<::android::os::PersistableBundle> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICppJavaTests::ReversePersistableBundles::cppServer"); _aidl_ret_status = _aidl_data.readParcelableVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReversePersistableBundles(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelableVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeParcelableVector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnCppJavaTests::TRANSACTION_ReverseUnion: { ::android::aidl::tests::Union in_input; ::android::aidl::tests::Union out_repeated; ::android::aidl::tests::Union _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICppJavaTests::ReverseUnion::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseUnion(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnCppJavaTests::TRANSACTION_ReverseNamedCallbackList: { ::std::vector<::android::sp<::android::IBinder>> in_input; ::std::vector<::android::sp<::android::IBinder>> out_repeated; ::std::vector<::android::sp<::android::IBinder>> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICppJavaTests::ReverseNamedCallbackList::cppServer"); _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseNamedCallbackList(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnCppJavaTests::TRANSACTION_RepeatFileDescriptor: { ::android::base::unique_fd in_read; ::android::base::unique_fd _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICppJavaTests::RepeatFileDescriptor::cppServer"); _aidl_ret_status = _aidl_data.readUniqueFileDescriptor(&in_read); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatFileDescriptor(std::move(in_read), &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeUniqueFileDescriptor(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnCppJavaTests::TRANSACTION_ReverseFileDescriptorArray: { ::std::vector<::android::base::unique_fd> in_input; ::std::vector<::android::base::unique_fd> out_repeated; ::std::vector<::android::base::unique_fd> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICppJavaTests::ReverseFileDescriptorArray::cppServer"); _aidl_ret_status = _aidl_data.readUniqueFileDescriptorVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseFileDescriptorArray(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeUniqueFileDescriptorVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeUniqueFileDescriptorVector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-cpp-java-test-interface-cpp-source_gen_android_aidl_0100644 0000000 0000000 00000000223 15172120304 033056 xustar000000000 0000000 119 path=tests/golden_output/frozen/aidl-cpp-java-test-interface-cpp-source/gen/android/aidl/tests/ICppJavaTests.cpp.d 28 mtime=1776853188.5400000 tests/golden_output/frozen/aidl-cpp-java-test-interface-cpp-source/gen/android/aidl/tests/ICppJavaTe0100644 0000000 0000000 00000000506 15172120304 032654 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/android/aidl/tests/ICppJavaTests.cpp : \ system/tools/aidl/tests/android/aidl/tests/ICppJavaTests.aidl \ system/tools/aidl/tests/android/aidl/tests/BadParcelable.aidl \ frameworks/native/aidl/binder/android/os/PersistableBundle.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-cpp-java-test-interface-cpp-source_gen_include_0100644 0000000 0000000 00000000034 15172120304 032070 xustar000000000 0000000 28 mtime=1776853188.5400000 tests/golden_output/frozen/aidl-cpp-java-test-interface-cpp-source/gen/include/0040755 0000000 0000000 00000000000 15172120304 026735 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-cpp-java-test-interface-cpp-source_gen_include_andro0100644 0000000 0000000 00000000034 15172120304 033114 xustar000000000 0000000 28 mtime=1776853188.5400000 tests/golden_output/frozen/aidl-cpp-java-test-interface-cpp-source/gen/include/android/0040755 0000000 0000000 00000000000 15172120304 030355 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-cpp-java-test-interface-cpp-source_gen_include_andro0100644 0000000 0000000 00000000034 15172120304 033114 xustar000000000 0000000 28 mtime=1776853188.5400000 tests/golden_output/frozen/aidl-cpp-java-test-interface-cpp-source/gen/include/android/aidl/0040755 0000000 0000000 00000000000 15172120304 031266 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-cpp-java-test-interface-cpp-source_gen_include_andro0100644 0000000 0000000 00000000034 15172120304 033114 xustar000000000 0000000 28 mtime=1776853188.5400000 tests/golden_output/frozen/aidl-cpp-java-test-interface-cpp-source/gen/include/android/aidl/tests/0040755 0000000 0000000 00000000000 15172120304 032430 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-cpp-java-test-interface-cpp-source_gen_include_andro0100644 0000000 0000000 00000000227 15172120304 033120 xustar000000000 0000000 123 path=tests/golden_output/frozen/aidl-cpp-java-test-interface-cpp-source/gen/include/android/aidl/tests/BadParcelable.h 28 mtime=1776853188.5400000 tests/golden_output/frozen/aidl-cpp-java-test-interface-cpp-source/gen/include/android/aidl/tests/Ba0100644 0000000 0000000 00000001437 15172120304 032677 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -t --min_sdk_version current -pout/soong/.intermediates/system/tools/aidl/aidl-test-interface_interface/preprocessed.aidl --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/staging/android/aidl/tests/BadParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/staging -Iframeworks/native/aidl/binder -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/BadParcelable.aidl */ #error TODO(b/111362593) parcelables do not have headers./PaxHeaders.X/tests_golden_output_frozen_aidl-cpp-java-test-interface-cpp-source_gen_include_andro0100644 0000000 0000000 00000000231 15172120304 033113 xustar000000000 0000000 125 path=tests/golden_output/frozen/aidl-cpp-java-test-interface-cpp-source/gen/include/android/aidl/tests/BnBadParcelable.h 28 mtime=1776853188.5400000 tests/golden_output/frozen/aidl-cpp-java-test-interface-cpp-source/gen/include/android/aidl/tests/Bn0100644 0000000 0000000 00000001442 15172120304 032710 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -t --min_sdk_version current -pout/soong/.intermediates/system/tools/aidl/aidl-test-interface_interface/preprocessed.aidl --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/staging/android/aidl/tests/BadParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/staging -Iframeworks/native/aidl/binder -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/BadParcelable.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl-cpp-java-test-interface-cpp-source_gen_include_andro0100644 0000000 0000000 00000000230 15172120304 033112 xustar000000000 0000000 124 path=tests/golden_output/frozen/aidl-cpp-java-test-interface-cpp-source/gen/include/android/aidl/tests/BnCppJavaTests.h 28 mtime=1776853188.5400000 tests/golden_output/frozen/aidl-cpp-java-test-interface-cpp-source/gen/include/android/aidl/tests/Bn0100644 0000000 0000000 00000011761 15172120304 032715 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -t --min_sdk_version current -pout/soong/.intermediates/system/tools/aidl/aidl-test-interface_interface/preprocessed.aidl --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/staging/android/aidl/tests/ICppJavaTests.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/staging -Iframeworks/native/aidl/binder -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ICppJavaTests.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { class BnCppJavaTests : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_RepeatBadParcelable = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_RepeatGenericParcelable = ::android::IBinder::FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_RepeatPersistableBundle = ::android::IBinder::FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_ReversePersistableBundles = ::android::IBinder::FIRST_CALL_TRANSACTION + 3; static constexpr uint32_t TRANSACTION_ReverseUnion = ::android::IBinder::FIRST_CALL_TRANSACTION + 4; static constexpr uint32_t TRANSACTION_ReverseNamedCallbackList = ::android::IBinder::FIRST_CALL_TRANSACTION + 5; static constexpr uint32_t TRANSACTION_RepeatFileDescriptor = ::android::IBinder::FIRST_CALL_TRANSACTION + 6; static constexpr uint32_t TRANSACTION_ReverseFileDescriptorArray = ::android::IBinder::FIRST_CALL_TRANSACTION + 7; explicit BnCppJavaTests(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnCppJavaTests class ICppJavaTestsDelegator : public BnCppJavaTests { public: explicit ICppJavaTestsDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status RepeatBadParcelable(const ::android::aidl::tests::BadParcelable& input, ::android::aidl::tests::BadParcelable* _aidl_return) override { return _aidl_delegate->RepeatBadParcelable(input, _aidl_return); } ::android::binder::Status RepeatGenericParcelable(const ::android::aidl::tests::GenericStructuredParcelable& input, ::android::aidl::tests::GenericStructuredParcelable* repeat, ::android::aidl::tests::GenericStructuredParcelable* _aidl_return) override { return _aidl_delegate->RepeatGenericParcelable(input, repeat, _aidl_return); } ::android::binder::Status RepeatPersistableBundle(const ::android::os::PersistableBundle& input, ::android::os::PersistableBundle* _aidl_return) override { return _aidl_delegate->RepeatPersistableBundle(input, _aidl_return); } ::android::binder::Status ReversePersistableBundles(const ::std::vector<::android::os::PersistableBundle>& input, ::std::vector<::android::os::PersistableBundle>* repeated, ::std::vector<::android::os::PersistableBundle>* _aidl_return) override { return _aidl_delegate->ReversePersistableBundles(input, repeated, _aidl_return); } ::android::binder::Status ReverseUnion(const ::android::aidl::tests::Union& input, ::android::aidl::tests::Union* repeated, ::android::aidl::tests::Union* _aidl_return) override { return _aidl_delegate->ReverseUnion(input, repeated, _aidl_return); } ::android::binder::Status ReverseNamedCallbackList(const ::std::vector<::android::sp<::android::IBinder>>& input, ::std::vector<::android::sp<::android::IBinder>>* repeated, ::std::vector<::android::sp<::android::IBinder>>* _aidl_return) override { return _aidl_delegate->ReverseNamedCallbackList(input, repeated, _aidl_return); } ::android::binder::Status RepeatFileDescriptor(::android::base::unique_fd read, ::android::base::unique_fd* _aidl_return) override { return _aidl_delegate->RepeatFileDescriptor(std::move(read), _aidl_return); } ::android::binder::Status ReverseFileDescriptorArray(const ::std::vector<::android::base::unique_fd>& input, ::std::vector<::android::base::unique_fd>* repeated, ::std::vector<::android::base::unique_fd>* _aidl_return) override { return _aidl_delegate->ReverseFileDescriptorArray(input, repeated, _aidl_return); } private: ::android::sp _aidl_delegate; }; // class ICppJavaTestsDelegator } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-cpp-java-test-interface-cpp-source_gen_include_andro0100644 0000000 0000000 00000000231 15172120304 033113 xustar000000000 0000000 125 path=tests/golden_output/frozen/aidl-cpp-java-test-interface-cpp-source/gen/include/android/aidl/tests/BpBadParcelable.h 28 mtime=1776853188.5410000 tests/golden_output/frozen/aidl-cpp-java-test-interface-cpp-source/gen/include/android/aidl/tests/Bp0100644 0000000 0000000 00000001442 15172120304 032712 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -t --min_sdk_version current -pout/soong/.intermediates/system/tools/aidl/aidl-test-interface_interface/preprocessed.aidl --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/staging/android/aidl/tests/BadParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/staging -Iframeworks/native/aidl/binder -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/BadParcelable.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl-cpp-java-test-interface-cpp-source_gen_include_andro0100644 0000000 0000000 00000000230 15172120304 033112 xustar000000000 0000000 124 path=tests/golden_output/frozen/aidl-cpp-java-test-interface-cpp-source/gen/include/android/aidl/tests/BpCppJavaTests.h 28 mtime=1776853188.5410000 tests/golden_output/frozen/aidl-cpp-java-test-interface-cpp-source/gen/include/android/aidl/tests/Bp0100644 0000000 0000000 00000006060 15172120304 032713 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -t --min_sdk_version current -pout/soong/.intermediates/system/tools/aidl/aidl-test-interface_interface/preprocessed.aidl --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/staging/android/aidl/tests/ICppJavaTests.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/staging -Iframeworks/native/aidl/binder -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ICppJavaTests.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { class BpCppJavaTests : public ::android::BpInterface { public: explicit BpCppJavaTests(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpCppJavaTests() = default; ::android::binder::Status RepeatBadParcelable(const ::android::aidl::tests::BadParcelable& input, ::android::aidl::tests::BadParcelable* _aidl_return) override; ::android::binder::Status RepeatGenericParcelable(const ::android::aidl::tests::GenericStructuredParcelable& input, ::android::aidl::tests::GenericStructuredParcelable* repeat, ::android::aidl::tests::GenericStructuredParcelable* _aidl_return) override; ::android::binder::Status RepeatPersistableBundle(const ::android::os::PersistableBundle& input, ::android::os::PersistableBundle* _aidl_return) override; ::android::binder::Status ReversePersistableBundles(const ::std::vector<::android::os::PersistableBundle>& input, ::std::vector<::android::os::PersistableBundle>* repeated, ::std::vector<::android::os::PersistableBundle>* _aidl_return) override; ::android::binder::Status ReverseUnion(const ::android::aidl::tests::Union& input, ::android::aidl::tests::Union* repeated, ::android::aidl::tests::Union* _aidl_return) override; ::android::binder::Status ReverseNamedCallbackList(const ::std::vector<::android::sp<::android::IBinder>>& input, ::std::vector<::android::sp<::android::IBinder>>* repeated, ::std::vector<::android::sp<::android::IBinder>>* _aidl_return) override; ::android::binder::Status RepeatFileDescriptor(::android::base::unique_fd read, ::android::base::unique_fd* _aidl_return) override; ::android::binder::Status ReverseFileDescriptorArray(const ::std::vector<::android::base::unique_fd>& input, ::std::vector<::android::base::unique_fd>* repeated, ::std::vector<::android::base::unique_fd>* _aidl_return) override; }; // class BpCppJavaTests } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-cpp-java-test-interface-cpp-source_gen_include_andro0100644 0000000 0000000 00000000227 15172120304 033120 xustar000000000 0000000 123 path=tests/golden_output/frozen/aidl-cpp-java-test-interface-cpp-source/gen/include/android/aidl/tests/ICppJavaTests.h 28 mtime=1776853188.5410000 tests/golden_output/frozen/aidl-cpp-java-test-interface-cpp-source/gen/include/android/aidl/tests/IC0100644 0000000 0000000 00000014536 15172120304 032654 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -t --min_sdk_version current -pout/soong/.intermediates/system/tools/aidl/aidl-test-interface_interface/preprocessed.aidl --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/staging/android/aidl/tests/ICppJavaTests.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-cpp-source/gen/staging -Iframeworks/native/aidl/binder -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ICppJavaTests.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace android::aidl::tests { template class GenericStructuredParcelable; class StructuredParcelable; } // namespace android::aidl::tests namespace android { namespace aidl { namespace tests { class ICppJavaTestsDelegator; class ICppJavaTests : public ::android::IInterface { public: typedef ICppJavaTestsDelegator DefaultDelegator; DECLARE_META_INTERFACE(CppJavaTests) virtual ::android::binder::Status RepeatBadParcelable(const ::android::aidl::tests::BadParcelable& input, ::android::aidl::tests::BadParcelable* _aidl_return) = 0; virtual ::android::binder::Status RepeatGenericParcelable(const ::android::aidl::tests::GenericStructuredParcelable& input, ::android::aidl::tests::GenericStructuredParcelable* repeat, ::android::aidl::tests::GenericStructuredParcelable* _aidl_return) = 0; virtual ::android::binder::Status RepeatPersistableBundle(const ::android::os::PersistableBundle& input, ::android::os::PersistableBundle* _aidl_return) = 0; virtual ::android::binder::Status ReversePersistableBundles(const ::std::vector<::android::os::PersistableBundle>& input, ::std::vector<::android::os::PersistableBundle>* repeated, ::std::vector<::android::os::PersistableBundle>* _aidl_return) = 0; virtual ::android::binder::Status ReverseUnion(const ::android::aidl::tests::Union& input, ::android::aidl::tests::Union* repeated, ::android::aidl::tests::Union* _aidl_return) = 0; virtual ::android::binder::Status ReverseNamedCallbackList(const ::std::vector<::android::sp<::android::IBinder>>& input, ::std::vector<::android::sp<::android::IBinder>>* repeated, ::std::vector<::android::sp<::android::IBinder>>* _aidl_return) = 0; virtual ::android::binder::Status RepeatFileDescriptor(::android::base::unique_fd read, ::android::base::unique_fd* _aidl_return) = 0; virtual ::android::binder::Status ReverseFileDescriptorArray(const ::std::vector<::android::base::unique_fd>& input, ::std::vector<::android::base::unique_fd>* repeated, ::std::vector<::android::base::unique_fd>* _aidl_return) = 0; }; // class ICppJavaTests class ICppJavaTestsDefault : public ICppJavaTests { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status RepeatBadParcelable(const ::android::aidl::tests::BadParcelable& /*input*/, ::android::aidl::tests::BadParcelable* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatGenericParcelable(const ::android::aidl::tests::GenericStructuredParcelable& /*input*/, ::android::aidl::tests::GenericStructuredParcelable* /*repeat*/, ::android::aidl::tests::GenericStructuredParcelable* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatPersistableBundle(const ::android::os::PersistableBundle& /*input*/, ::android::os::PersistableBundle* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReversePersistableBundles(const ::std::vector<::android::os::PersistableBundle>& /*input*/, ::std::vector<::android::os::PersistableBundle>* /*repeated*/, ::std::vector<::android::os::PersistableBundle>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseUnion(const ::android::aidl::tests::Union& /*input*/, ::android::aidl::tests::Union* /*repeated*/, ::android::aidl::tests::Union* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseNamedCallbackList(const ::std::vector<::android::sp<::android::IBinder>>& /*input*/, ::std::vector<::android::sp<::android::IBinder>>* /*repeated*/, ::std::vector<::android::sp<::android::IBinder>>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatFileDescriptor(::android::base::unique_fd /*read*/, ::android::base::unique_fd* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseFileDescriptorArray(const ::std::vector<::android::base::unique_fd>& /*input*/, ::std::vector<::android::base::unique_fd>* /*repeated*/, ::std::vector<::android::base::unique_fd>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } }; // class ICppJavaTestsDefault } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-cpp-java-test-interface-cpp-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 032311 xustar000000000 0000000 28 mtime=1776853188.5410000 tests/golden_output/frozen/aidl-cpp-java-test-interface-cpp-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 027223 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-cpp-java-test-interface-java-source_0100644 0000000 0000000 00000000034 15172120304 027673 xustar000000000 0000000 28 mtime=1776853188.5410000 tests/golden_output/frozen/aidl-cpp-java-test-interface-java-source/0040755 0000000 0000000 00000000000 15172120304 024700 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-cpp-java-test-interface-java-source_gen_0100644 0000000 0000000 00000000034 15172120304 030524 xustar000000000 0000000 28 mtime=1776853188.5410000 tests/golden_output/frozen/aidl-cpp-java-test-interface-java-source/gen/0040755 0000000 0000000 00000000000 15172120304 025451 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-cpp-java-test-interface-java-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 032224 xustar000000000 0000000 28 mtime=1776853188.5410000 tests/golden_output/frozen/aidl-cpp-java-test-interface-java-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 027071 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-cpp-java-test-interface-java-source_gen_android_aidl0100644 0000000 0000000 00000000034 15172120304 033056 xustar000000000 0000000 28 mtime=1776853188.5410000 tests/golden_output/frozen/aidl-cpp-java-test-interface-java-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 030002 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-cpp-java-test-interface-java-source_gen_android_aidl0100644 0000000 0000000 00000000034 15172120304 033056 xustar000000000 0000000 28 mtime=1776853188.5410000 tests/golden_output/frozen/aidl-cpp-java-test-interface-java-source/gen/android/aidl/tests/0040755 0000000 0000000 00000000000 15172120304 031144 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-cpp-java-test-interface-java-source_gen_android_aidl0100644 0000000 0000000 00000000223 15172120304 033056 xustar000000000 0000000 119 path=tests/golden_output/frozen/aidl-cpp-java-test-interface-java-source/gen/android/aidl/tests/BadParcelable.java 28 mtime=1776853188.5410000 tests/golden_output/frozen/aidl-cpp-java-test-interface-java-source/gen/android/aidl/tests/BadParcel0100644 0000000 0000000 00000000000 15172120304 032667 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-cpp-java-test-interface-java-source_gen_android_aidl0100644 0000000 0000000 00000000225 15172120304 033060 xustar000000000 0000000 121 path=tests/golden_output/frozen/aidl-cpp-java-test-interface-java-source/gen/android/aidl/tests/BadParcelable.java.d 28 mtime=1776853188.5410000 tests/golden_output/frozen/aidl-cpp-java-test-interface-java-source/gen/android/aidl/tests/BadParcel0100644 0000000 0000000 00000000105 15172120304 032675 0ustar000000000 0000000 : \ system/tools/aidl/tests/android/aidl/tests/BadParcelable.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-cpp-java-test-interface-java-source_gen_android_aidl0100644 0000000 0000000 00000000223 15172120304 033056 xustar000000000 0000000 119 path=tests/golden_output/frozen/aidl-cpp-java-test-interface-java-source/gen/android/aidl/tests/ICppJavaTests.java 28 mtime=1776853188.5410000 tests/golden_output/frozen/aidl-cpp-java-test-interface-java-source/gen/android/aidl/tests/ICppJavaT0100644 0000000 0000000 00000050663 15172120304 032657 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -t --min_sdk_version platform_apis -pout/soong/.intermediates/system/tools/aidl/aidl-test-interface_interface/preprocessed.aidl --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-java-source/gen/android/aidl/tests/ICppJavaTests.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-java-source/gen -Iframeworks/native/aidl/binder -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ICppJavaTests.aidl */ package android.aidl.tests; // Tests that are only supported by the C++/Java backends, not NDK/Rust public interface ICppJavaTests extends android.os.IInterface { /** Default implementation for ICppJavaTests. */ public static class Default implements android.aidl.tests.ICppJavaTests { @Override public android.aidl.tests.BadParcelable RepeatBadParcelable(android.aidl.tests.BadParcelable input) throws android.os.RemoteException { return null; } @Override public android.aidl.tests.GenericStructuredParcelable RepeatGenericParcelable(android.aidl.tests.GenericStructuredParcelable input, android.aidl.tests.GenericStructuredParcelable repeat) throws android.os.RemoteException { return null; } @Override public android.os.PersistableBundle RepeatPersistableBundle(android.os.PersistableBundle input) throws android.os.RemoteException { return null; } @Override public android.os.PersistableBundle[] ReversePersistableBundles(android.os.PersistableBundle[] input, android.os.PersistableBundle[] repeated) throws android.os.RemoteException { return null; } @Override public android.aidl.tests.Union ReverseUnion(android.aidl.tests.Union input, android.aidl.tests.Union repeated) throws android.os.RemoteException { return null; } // Test that List types work correctly. @Override public java.util.List ReverseNamedCallbackList(java.util.List input, java.util.List repeated) throws android.os.RemoteException { return null; } @Override public java.io.FileDescriptor RepeatFileDescriptor(java.io.FileDescriptor read) throws android.os.RemoteException { return null; } @Override public java.io.FileDescriptor[] ReverseFileDescriptorArray(java.io.FileDescriptor[] input, java.io.FileDescriptor[] repeated) throws android.os.RemoteException { return null; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.ICppJavaTests { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.ICppJavaTests interface, * generating a proxy if needed. */ public static android.aidl.tests.ICppJavaTests asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.ICppJavaTests))) { return ((android.aidl.tests.ICppJavaTests)iin); } return new android.aidl.tests.ICppJavaTests.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_RepeatBadParcelable: { return "RepeatBadParcelable"; } case TRANSACTION_RepeatGenericParcelable: { return "RepeatGenericParcelable"; } case TRANSACTION_RepeatPersistableBundle: { return "RepeatPersistableBundle"; } case TRANSACTION_ReversePersistableBundles: { return "ReversePersistableBundles"; } case TRANSACTION_ReverseUnion: { return "ReverseUnion"; } case TRANSACTION_ReverseNamedCallbackList: { return "ReverseNamedCallbackList"; } case TRANSACTION_RepeatFileDescriptor: { return "RepeatFileDescriptor"; } case TRANSACTION_ReverseFileDescriptorArray: { return "ReverseFileDescriptorArray"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_RepeatBadParcelable: { android.aidl.tests.BadParcelable _arg0; _arg0 = data.readTypedObject(android.aidl.tests.BadParcelable.CREATOR); data.enforceNoDataAvail(); android.aidl.tests.BadParcelable _result = this.RepeatBadParcelable(_arg0); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_RepeatGenericParcelable: { android.aidl.tests.GenericStructuredParcelable _arg0; _arg0 = data.readTypedObject(android.aidl.tests.GenericStructuredParcelable.CREATOR); android.aidl.tests.GenericStructuredParcelable _arg1; _arg1 = new android.aidl.tests.GenericStructuredParcelable(); data.enforceNoDataAvail(); android.aidl.tests.GenericStructuredParcelable _result = this.RepeatGenericParcelable(_arg0, _arg1); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); reply.writeTypedObject(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_RepeatPersistableBundle: { android.os.PersistableBundle _arg0; _arg0 = data.readTypedObject(android.os.PersistableBundle.CREATOR); data.enforceNoDataAvail(); android.os.PersistableBundle _result = this.RepeatPersistableBundle(_arg0); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_ReversePersistableBundles: { android.os.PersistableBundle[] _arg0; _arg0 = data.createTypedArray(android.os.PersistableBundle.CREATOR); android.os.PersistableBundle[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new android.os.PersistableBundle[_arg1_length]; } data.enforceNoDataAvail(); android.os.PersistableBundle[] _result = this.ReversePersistableBundles(_arg0, _arg1); reply.writeNoException(); reply.writeTypedArray(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); reply.writeTypedArray(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_ReverseUnion: { android.aidl.tests.Union _arg0; _arg0 = data.readTypedObject(android.aidl.tests.Union.CREATOR); android.aidl.tests.Union _arg1; _arg1 = new android.aidl.tests.Union(); data.enforceNoDataAvail(); android.aidl.tests.Union _result = this.ReverseUnion(_arg0, _arg1); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); reply.writeTypedObject(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_ReverseNamedCallbackList: { java.util.List _arg0; _arg0 = data.createBinderArrayList(); java.util.List _arg1; _arg1 = new java.util.ArrayList(); data.enforceNoDataAvail(); java.util.List _result = this.ReverseNamedCallbackList(_arg0, _arg1); reply.writeNoException(); reply.writeBinderList(_result); reply.writeBinderList(_arg1); break; } case TRANSACTION_RepeatFileDescriptor: { java.io.FileDescriptor _arg0; _arg0 = data.readRawFileDescriptor(); data.enforceNoDataAvail(); java.io.FileDescriptor _result = this.RepeatFileDescriptor(_arg0); reply.writeNoException(); reply.writeRawFileDescriptor(_result); break; } case TRANSACTION_ReverseFileDescriptorArray: { java.io.FileDescriptor[] _arg0; _arg0 = data.createRawFileDescriptorArray(); java.io.FileDescriptor[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new java.io.FileDescriptor[_arg1_length]; } data.enforceNoDataAvail(); java.io.FileDescriptor[] _result = this.ReverseFileDescriptorArray(_arg0, _arg1); reply.writeNoException(); reply.writeRawFileDescriptorArray(_result); reply.writeRawFileDescriptorArray(_arg1); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.ICppJavaTests { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public android.aidl.tests.BadParcelable RepeatBadParcelable(android.aidl.tests.BadParcelable input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.BadParcelable _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatBadParcelable, _data, _reply, 0); _reply.readException(); _result = _reply.readTypedObject(android.aidl.tests.BadParcelable.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.tests.GenericStructuredParcelable RepeatGenericParcelable(android.aidl.tests.GenericStructuredParcelable input, android.aidl.tests.GenericStructuredParcelable repeat) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.GenericStructuredParcelable _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatGenericParcelable, _data, _reply, 0); _reply.readException(); _result = _reply.readTypedObject(android.aidl.tests.GenericStructuredParcelable.CREATOR); if ((0!=_reply.readInt())) { repeat.readFromParcel(_reply); } } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.os.PersistableBundle RepeatPersistableBundle(android.os.PersistableBundle input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.os.PersistableBundle _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatPersistableBundle, _data, _reply, 0); _reply.readException(); _result = _reply.readTypedObject(android.os.PersistableBundle.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.os.PersistableBundle[] ReversePersistableBundles(android.os.PersistableBundle[] input, android.os.PersistableBundle[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.os.PersistableBundle[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedArray(input, 0); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReversePersistableBundles, _data, _reply, 0); _reply.readException(); _result = _reply.createTypedArray(android.os.PersistableBundle.CREATOR); _reply.readTypedArray(repeated, android.os.PersistableBundle.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.tests.Union ReverseUnion(android.aidl.tests.Union input, android.aidl.tests.Union repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.Union _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseUnion, _data, _reply, 0); _reply.readException(); _result = _reply.readTypedObject(android.aidl.tests.Union.CREATOR); if ((0!=_reply.readInt())) { repeated.readFromParcel(_reply); } } finally { _reply.recycle(); _data.recycle(); } return _result; } // Test that List types work correctly. @Override public java.util.List ReverseNamedCallbackList(java.util.List input, java.util.List repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.util.List _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeBinderList(input); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseNamedCallbackList, _data, _reply, 0); _reply.readException(); _result = _reply.createBinderArrayList(); _reply.readBinderList(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.io.FileDescriptor RepeatFileDescriptor(java.io.FileDescriptor read) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.io.FileDescriptor _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeRawFileDescriptor(read); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatFileDescriptor, _data, _reply, 0); _reply.readException(); _result = _reply.readRawFileDescriptor(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.io.FileDescriptor[] ReverseFileDescriptorArray(java.io.FileDescriptor[] input, java.io.FileDescriptor[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.io.FileDescriptor[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeRawFileDescriptorArray(input); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseFileDescriptorArray, _data, _reply, 0); _reply.readException(); _result = _reply.createRawFileDescriptorArray(); _reply.readRawFileDescriptorArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } } static final int TRANSACTION_RepeatBadParcelable = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); static final int TRANSACTION_RepeatGenericParcelable = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1); static final int TRANSACTION_RepeatPersistableBundle = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2); static final int TRANSACTION_ReversePersistableBundles = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3); static final int TRANSACTION_ReverseUnion = (android.os.IBinder.FIRST_CALL_TRANSACTION + 4); static final int TRANSACTION_ReverseNamedCallbackList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 5); static final int TRANSACTION_RepeatFileDescriptor = (android.os.IBinder.FIRST_CALL_TRANSACTION + 6); static final int TRANSACTION_ReverseFileDescriptorArray = (android.os.IBinder.FIRST_CALL_TRANSACTION + 7); /** @hide */ public int getMaxTransactionId() { return 7; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.ICppJavaTests"; public android.aidl.tests.BadParcelable RepeatBadParcelable(android.aidl.tests.BadParcelable input) throws android.os.RemoteException; public android.aidl.tests.GenericStructuredParcelable RepeatGenericParcelable(android.aidl.tests.GenericStructuredParcelable input, android.aidl.tests.GenericStructuredParcelable repeat) throws android.os.RemoteException; public android.os.PersistableBundle RepeatPersistableBundle(android.os.PersistableBundle input) throws android.os.RemoteException; public android.os.PersistableBundle[] ReversePersistableBundles(android.os.PersistableBundle[] input, android.os.PersistableBundle[] repeated) throws android.os.RemoteException; public android.aidl.tests.Union ReverseUnion(android.aidl.tests.Union input, android.aidl.tests.Union repeated) throws android.os.RemoteException; // Test that List types work correctly. public java.util.List ReverseNamedCallbackList(java.util.List input, java.util.List repeated) throws android.os.RemoteException; public java.io.FileDescriptor RepeatFileDescriptor(java.io.FileDescriptor read) throws android.os.RemoteException; public java.io.FileDescriptor[] ReverseFileDescriptorArray(java.io.FileDescriptor[] input, java.io.FileDescriptor[] repeated) throws android.os.RemoteException; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-cpp-java-test-interface-java-source_gen_android_aidl0100644 0000000 0000000 00000000225 15172120304 033060 xustar000000000 0000000 121 path=tests/golden_output/frozen/aidl-cpp-java-test-interface-java-source/gen/android/aidl/tests/ICppJavaTests.java.d 28 mtime=1776853188.5480000 tests/golden_output/frozen/aidl-cpp-java-test-interface-java-source/gen/android/aidl/tests/ICppJavaT0100644 0000000 0000000 00000000510 15172120304 032641 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-cpp-java-test-interface-java-source/gen/android/aidl/tests/ICppJavaTests.java : \ system/tools/aidl/tests/android/aidl/tests/ICppJavaTests.aidl \ system/tools/aidl/tests/android/aidl/tests/BadParcelable.aidl \ frameworks/native/aidl/binder/android/os/PersistableBundle.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-cpp-java-test-interface-java-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 032450 xustar000000000 0000000 28 mtime=1776853188.5490000 tests/golden_output/frozen/aidl-cpp-java-test-interface-java-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 027362 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-extras-java-source_0100644 0000000 0000000 00000000034 15172120304 025542 xustar000000000 0000000 28 mtime=1776853188.5490000 tests/golden_output/frozen/aidl-test-extras-java-source/0040755 0000000 0000000 00000000000 15172120304 022547 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-extras-java-source_gen_0100644 0000000 0000000 00000000034 15172120304 026373 xustar000000000 0000000 28 mtime=1776853188.5490000 tests/golden_output/frozen/aidl-test-extras-java-source/gen/0040755 0000000 0000000 00000000000 15172120304 023320 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-extras-java-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 030073 xustar000000000 0000000 28 mtime=1776853188.5510000 tests/golden_output/frozen/aidl-test-extras-java-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 024740 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-extras-java-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 031064 xustar000000000 0000000 28 mtime=1776853188.5510000 tests/golden_output/frozen/aidl-test-extras-java-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 025651 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-extras-java-source_gen_android_aidl_tests_0100644 0000000 0000000 00000000034 15172120304 032306 xustar000000000 0000000 28 mtime=1776853188.5510000 tests/golden_output/frozen/aidl-test-extras-java-source/gen/android/aidl/tests/0040755 0000000 0000000 00000000000 15172120304 027013 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-extras-java-source_gen_android_aidl_tests_gener0100644 0000000 0000000 00000000034 15172120304 033327 xustar000000000 0000000 28 mtime=1776853188.5510000 tests/golden_output/frozen/aidl-test-extras-java-source/gen/android/aidl/tests/generic/0040755 0000000 0000000 00000000000 15172120304 030427 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-extras-java-source_gen_android_aidl_tests_gener0100644 0000000 0000000 00000000034 15172120304 033327 xustar000000000 0000000 28 mtime=1776853188.5510000 tests/golden_output/frozen/aidl-test-extras-java-source/gen/android/aidl/tests/generic/Baz.java0100644 0000000 0000000 00000004245 15172120304 032010 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/generic/Baz.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/generic/Baz.aidl */ package android.aidl.tests.generic; public class Baz implements android.os.Parcelable { public int a = 0; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public Baz createFromParcel(android.os.Parcel _aidl_source) { Baz _aidl_out = new Baz(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public Baz[] newArray(int _aidl_size) { return new Baz[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(a); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; a = _aidl_parcel.readInt(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-extras-java-source_gen_android_aidl_tests_gener0100644 0000000 0000000 00000000034 15172120304 033327 xustar000000000 0000000 28 mtime=1776853188.5510000 tests/golden_output/frozen/aidl-test-extras-java-source/gen/android/aidl/tests/generic/Baz.java.d0100644 0000000 0000000 00000000262 15172120304 032225 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/generic/Baz.java : \ system/tools/aidl/tests/android/aidl/tests/generic/Baz.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-extras-java-source_gen_android_aidl_tests_gener0100644 0000000 0000000 00000000034 15172120304 033327 xustar000000000 0000000 28 mtime=1776853188.5510000 tests/golden_output/frozen/aidl-test-extras-java-source/gen/android/aidl/tests/generic/IFaz.java0100644 0000000 0000000 00000017420 15172120304 032124 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/generic/IFaz.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/generic/IFaz.aidl */ package android.aidl.tests.generic; public interface IFaz extends android.os.IInterface { /** Default implementation for IFaz. */ public static class Default implements android.aidl.tests.generic.IFaz { @Override public android.aidl.tests.generic.Pair getPair() throws android.os.RemoteException { return null; } @Override public android.aidl.tests.generic.Pair getPair2() throws android.os.RemoteException { return null; } @Override public android.aidl.tests.generic.Pair getPair3() throws android.os.RemoteException { return null; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.generic.IFaz { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.generic.IFaz interface, * generating a proxy if needed. */ public static android.aidl.tests.generic.IFaz asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.generic.IFaz))) { return ((android.aidl.tests.generic.IFaz)iin); } return new android.aidl.tests.generic.IFaz.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_getPair: { return "getPair"; } case TRANSACTION_getPair2: { return "getPair2"; } case TRANSACTION_getPair3: { return "getPair3"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_getPair: { android.aidl.tests.generic.Pair _result = this.getPair(); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_getPair2: { android.aidl.tests.generic.Pair _result = this.getPair2(); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_getPair3: { android.aidl.tests.generic.Pair _result = this.getPair3(); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.generic.IFaz { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public android.aidl.tests.generic.Pair getPair() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.generic.Pair _result; try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getPair, _data, _reply, 0); _reply.readException(); _result = _reply.readTypedObject(android.aidl.tests.generic.Pair.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.tests.generic.Pair getPair2() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.generic.Pair _result; try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getPair2, _data, _reply, 0); _reply.readException(); _result = _reply.readTypedObject(android.aidl.tests.generic.Pair.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.tests.generic.Pair getPair3() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.generic.Pair _result; try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getPair3, _data, _reply, 0); _reply.readException(); _result = _reply.readTypedObject(android.aidl.tests.generic.Pair.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } } static final int TRANSACTION_getPair = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); static final int TRANSACTION_getPair2 = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1); static final int TRANSACTION_getPair3 = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2); /** @hide */ public int getMaxTransactionId() { return 2; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.generic.IFaz"; public android.aidl.tests.generic.Pair getPair() throws android.os.RemoteException; public android.aidl.tests.generic.Pair getPair2() throws android.os.RemoteException; public android.aidl.tests.generic.Pair getPair3() throws android.os.RemoteException; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-extras-java-source_gen_android_aidl_tests_gener0100644 0000000 0000000 00000000034 15172120304 033327 xustar000000000 0000000 28 mtime=1776853188.5520000 tests/golden_output/frozen/aidl-test-extras-java-source/gen/android/aidl/tests/generic/IFaz.java.d0100644 0000000 0000000 00000000561 15172120304 032344 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/generic/IFaz.java : \ system/tools/aidl/tests/android/aidl/tests/generic/IFaz.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/generic/Baz.aidl \ system/tools/aidl/tests/android/aidl/tests/generic/Pair.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-extras-java-source_gen_android_aidl_tests_gener0100644 0000000 0000000 00000000034 15172120304 033327 xustar000000000 0000000 28 mtime=1776853188.5520000 tests/golden_output/frozen/aidl-test-extras-java-source/gen/android/aidl/tests/generic/Pair.java0100644 0000000 0000000 00000000000 15172120304 032150 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-extras-java-source_gen_android_aidl_tests_gener0100644 0000000 0000000 00000000034 15172120304 033327 xustar000000000 0000000 28 mtime=1776853188.5520000 tests/golden_output/frozen/aidl-test-extras-java-source/gen/android/aidl/tests/generic/Pair.java.d0100644 0000000 0000000 00000000104 15172120304 032377 0ustar000000000 0000000 : \ system/tools/aidl/tests/android/aidl/tests/generic/Pair.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-extras-java-source_gen_android_aidl_tests_immut0100644 0000000 0000000 00000000034 15172120304 033362 xustar000000000 0000000 28 mtime=1776853188.5520000 tests/golden_output/frozen/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/0040755 0000000 0000000 00000000000 15172120304 030772 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-extras-java-source_gen_android_aidl_tests_immut0100644 0000000 0000000 00000000034 15172120304 033362 xustar000000000 0000000 28 mtime=1776853188.5520000 tests/golden_output/frozen/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/Bar.java0100644 0000000 0000000 00000005373 15172120304 032346 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/Bar.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/immutable/Bar.aidl */ package android.aidl.tests.immutable; public class Bar implements android.os.Parcelable { public final java.lang.String s; public static final class Builder { private java.lang.String s = "bar"; public Builder setS(java.lang.String s) { this.s = s; return this; } public android.aidl.tests.immutable.Bar build() { return new android.aidl.tests.immutable.Bar(s); } } public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public Bar createFromParcel(android.os.Parcel _aidl_source) { return internalCreateFromParcel(_aidl_source); } @Override public Bar[] newArray(int _aidl_size) { return new Bar[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeString(s); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public Bar(java.lang.String s) { this.s = s; } private static Bar internalCreateFromParcel(android.os.Parcel _aidl_parcel) { Builder _aidl_parcelable_builder = new Builder(); int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small"); _aidl_parcelable_builder.build(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return _aidl_parcelable_builder.build(); java.lang.String _aidl_temp_s; _aidl_temp_s = _aidl_parcel.readString(); _aidl_parcelable_builder.setS(_aidl_temp_s); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_parcelable_builder.build(); } } @Override public int describeContents() { int _mask = 0; return _mask; } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-extras-java-source_gen_android_aidl_tests_immut0100644 0000000 0000000 00000000034 15172120304 033362 xustar000000000 0000000 28 mtime=1776853188.5520000 tests/golden_output/frozen/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/Bar.java.d0100644 0000000 0000000 00000000266 15172120304 032564 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/Bar.java : \ system/tools/aidl/tests/android/aidl/tests/immutable/Bar.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-extras-java-source_gen_android_aidl_tests_immut0100644 0000000 0000000 00000000034 15172120304 033362 xustar000000000 0000000 28 mtime=1776853188.5520000 tests/golden_output/frozen/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/Foo.java0100644 0000000 0000000 00000016673 15172120304 032372 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/Foo.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/immutable/Foo.aidl */ package android.aidl.tests.immutable; public class Foo implements android.os.Parcelable { public final int a; public final android.aidl.tests.immutable.Bar b; public final java.util.List c; public final java.util.Map d; public final android.aidl.tests.immutable.Bar[] e; public final android.aidl.tests.immutable.Union u; public static final class Builder { private int a = 10; public Builder setA(int a) { this.a = a; return this; } private android.aidl.tests.immutable.Bar b; public Builder setB(android.aidl.tests.immutable.Bar b) { this.b = b; return this; } private java.util.List c; public Builder setC(java.util.List c) { this.c = c; return this; } private java.util.Map d; public Builder setD(java.util.Map d) { this.d = d; return this; } private android.aidl.tests.immutable.Bar[] e; public Builder setE(android.aidl.tests.immutable.Bar[] e) { this.e = e; return this; } private android.aidl.tests.immutable.Union u; public Builder setU(android.aidl.tests.immutable.Union u) { this.u = u; return this; } public android.aidl.tests.immutable.Foo build() { return new android.aidl.tests.immutable.Foo(a, b, c, d, e, u); } } public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public Foo createFromParcel(android.os.Parcel _aidl_source) { return internalCreateFromParcel(_aidl_source); } @Override public Foo[] newArray(int _aidl_size) { return new Foo[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(a); _aidl_parcel.writeTypedObject(b, _aidl_flag); _aidl_parcel.writeTypedList(c, _aidl_flag); if (d == null) { _aidl_parcel.writeInt(-1); } else { _aidl_parcel.writeInt(d.size()); d.forEach((k, v) -> { _aidl_parcel.writeString(k); _aidl_parcel.writeTypedObject(v, _aidl_flag); }); } _aidl_parcel.writeTypedArray(e, _aidl_flag); _aidl_parcel.writeTypedObject(u, _aidl_flag); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public Foo(int a, android.aidl.tests.immutable.Bar b, java.util.List c, java.util.Map d, android.aidl.tests.immutable.Bar[] e, android.aidl.tests.immutable.Union u) { this.a = a; this.b = b; this.c = c == null ? null : java.util.Collections.unmodifiableList(c); this.d = d == null ? null : java.util.Collections.unmodifiableMap(d); this.e = e; this.u = u; } private static Foo internalCreateFromParcel(android.os.Parcel _aidl_parcel) { Builder _aidl_parcelable_builder = new Builder(); int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small"); _aidl_parcelable_builder.build(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return _aidl_parcelable_builder.build(); int _aidl_temp_a; _aidl_temp_a = _aidl_parcel.readInt(); _aidl_parcelable_builder.setA(_aidl_temp_a); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return _aidl_parcelable_builder.build(); android.aidl.tests.immutable.Bar _aidl_temp_b; _aidl_temp_b = _aidl_parcel.readTypedObject(android.aidl.tests.immutable.Bar.CREATOR); _aidl_parcelable_builder.setB(_aidl_temp_b); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return _aidl_parcelable_builder.build(); java.util.List _aidl_temp_c; _aidl_temp_c = _aidl_parcel.createTypedArrayList(android.aidl.tests.immutable.Bar.CREATOR); _aidl_parcelable_builder.setC(_aidl_temp_c); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return _aidl_parcelable_builder.build(); java.util.Map _aidl_temp_d; { int N = _aidl_parcel.readInt(); _aidl_temp_d = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = _aidl_parcel.readString(); android.aidl.tests.immutable.Bar v; v = _aidl_parcel.readTypedObject(android.aidl.tests.immutable.Bar.CREATOR); _aidl_temp_d.put(k, v); }); } _aidl_parcelable_builder.setD(_aidl_temp_d); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return _aidl_parcelable_builder.build(); android.aidl.tests.immutable.Bar[] _aidl_temp_e; _aidl_temp_e = _aidl_parcel.createTypedArray(android.aidl.tests.immutable.Bar.CREATOR); _aidl_parcelable_builder.setE(_aidl_temp_e); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return _aidl_parcelable_builder.build(); android.aidl.tests.immutable.Union _aidl_temp_u; _aidl_temp_u = _aidl_parcel.readTypedObject(android.aidl.tests.immutable.Union.CREATOR); _aidl_parcelable_builder.setU(_aidl_temp_u); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_parcelable_builder.build(); } } @Override public int describeContents() { int _mask = 0; _mask |= describeContents(b); _mask |= describeContents(c); _mask |= describeContents(d); _mask |= describeContents(e); _mask |= describeContents(u); return _mask; } private int describeContents(Object _v) { if (_v == null) return 0; if (_v instanceof Object[]) { int _mask = 0; for (Object o : (Object[]) _v) { _mask |= describeContents(o); } return _mask; } if (_v instanceof java.util.Collection) { int _mask = 0; for (Object o : (java.util.Collection) _v) { _mask |= describeContents(o); } return _mask; } if (_v instanceof java.util.Map) { return describeContents(((java.util.Map) _v).values()); } if (_v instanceof android.os.Parcelable) { return ((android.os.Parcelable) _v).describeContents(); } return 0; } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-extras-java-source_gen_android_aidl_tests_immut0100644 0000000 0000000 00000000034 15172120304 033362 xustar000000000 0000000 28 mtime=1776853188.5530000 tests/golden_output/frozen/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/Foo.java.d0100644 0000000 0000000 00000000474 15172120304 032604 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/Foo.java : \ system/tools/aidl/tests/android/aidl/tests/immutable/Foo.aidl \ system/tools/aidl/tests/android/aidl/tests/immutable/Bar.aidl \ system/tools/aidl/tests/android/aidl/tests/immutable/Union.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-extras-java-source_gen_android_aidl_tests_immut0100644 0000000 0000000 00000000034 15172120304 033362 xustar000000000 0000000 28 mtime=1776853188.5530000 tests/golden_output/frozen/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/IBaz.java0100644 0000000 0000000 00000011722 15172120304 032462 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/IBaz.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/immutable/IBaz.aidl */ package android.aidl.tests.immutable; public interface IBaz extends android.os.IInterface { /** Default implementation for IBaz. */ public static class Default implements android.aidl.tests.immutable.IBaz { @Override public android.aidl.tests.immutable.Foo RepeatFoo(android.aidl.tests.immutable.Foo a) throws android.os.RemoteException { return null; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.immutable.IBaz { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.immutable.IBaz interface, * generating a proxy if needed. */ public static android.aidl.tests.immutable.IBaz asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.immutable.IBaz))) { return ((android.aidl.tests.immutable.IBaz)iin); } return new android.aidl.tests.immutable.IBaz.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_RepeatFoo: { return "RepeatFoo"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_RepeatFoo: { android.aidl.tests.immutable.Foo _arg0; _arg0 = data.readTypedObject(android.aidl.tests.immutable.Foo.CREATOR); data.enforceNoDataAvail(); android.aidl.tests.immutable.Foo _result = this.RepeatFoo(_arg0); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.immutable.IBaz { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public android.aidl.tests.immutable.Foo RepeatFoo(android.aidl.tests.immutable.Foo a) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.immutable.Foo _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(a, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatFoo, _data, _reply, 0); _reply.readException(); _result = _reply.readTypedObject(android.aidl.tests.immutable.Foo.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } } static final int TRANSACTION_RepeatFoo = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.immutable.IBaz"; public android.aidl.tests.immutable.Foo RepeatFoo(android.aidl.tests.immutable.Foo a) throws android.os.RemoteException; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-extras-java-source_gen_android_aidl_tests_immut0100644 0000000 0000000 00000000212 15172120304 033360 xustar000000000 0000000 110 path=tests/golden_output/frozen/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/IBaz.java.d 28 mtime=1776853188.5540000 tests/golden_output/frozen/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/IBaz.java.d0100644 0000000 0000000 00000000600 15172120304 032675 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/IBaz.java : \ system/tools/aidl/tests/android/aidl/tests/immutable/IBaz.aidl \ system/tools/aidl/tests/android/aidl/tests/immutable/Foo.aidl \ system/tools/aidl/tests/android/aidl/tests/immutable/Bar.aidl \ system/tools/aidl/tests/android/aidl/tests/immutable/Union.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-extras-java-source_gen_android_aidl_tests_immut0100644 0000000 0000000 00000000034 15172120304 033362 xustar000000000 0000000 28 mtime=1776853188.5540000 tests/golden_output/frozen/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/Union.java0100644 0000000 0000000 00000010203 15172120304 032716 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/Union.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/immutable/Union.aidl */ package android.aidl.tests.immutable; public final class Union implements android.os.Parcelable { // tags for union fields public final static int num = 0; // int num; public final static int str = 1; // String[] str; public final static int bar = 2; // android.aidl.tests.immutable.Bar bar; private final int _tag; private final Object _value; public Union() { int _value = 0; this._tag = num; this._value = _value; } private Union(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public int getTag() { return _tag; } // int num; public static Union num(int _value) { return new Union(num, _value); } public int getNum() { _assertTag(num); return (int) _value; } // String[] str; public static Union str(java.lang.String[] _value) { return new Union(str, _value); } public java.lang.String[] getStr() { _assertTag(str); return (java.lang.String[]) _value; } // android.aidl.tests.immutable.Bar bar; public static Union bar(android.aidl.tests.immutable.Bar _value) { return new Union(bar, _value); } public android.aidl.tests.immutable.Bar getBar() { _assertTag(bar); return (android.aidl.tests.immutable.Bar) _value; } public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public Union createFromParcel(android.os.Parcel _aidl_source) { return internalCreateFromParcel(_aidl_source); } @Override public Union[] newArray(int _aidl_size) { return new Union[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { _aidl_parcel.writeInt(_tag); switch (_tag) { case num: _aidl_parcel.writeInt(getNum()); break; case str: _aidl_parcel.writeStringArray(getStr()); break; case bar: _aidl_parcel.writeTypedObject(getBar(), _aidl_flag); break; } } private static Union internalCreateFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_tag; _aidl_tag = _aidl_parcel.readInt(); switch (_aidl_tag) { case num: { int _aidl_value; _aidl_value = _aidl_parcel.readInt(); return new Union(_aidl_tag, _aidl_value); } case str: { java.lang.String[] _aidl_value; _aidl_value = _aidl_parcel.createStringArray(); return new Union(_aidl_tag, _aidl_value); } case bar: { android.aidl.tests.immutable.Bar _aidl_value; _aidl_value = _aidl_parcel.readTypedObject(android.aidl.tests.immutable.Bar.CREATOR); return new Union(_aidl_tag, _aidl_value); } } throw new IllegalArgumentException("union: unknown tag: " + _aidl_tag); } @Override public int describeContents() { int _mask = 0; switch (getTag()) { case bar: _mask |= describeContents(getBar()); break; } return _mask; } private int describeContents(Object _v) { if (_v == null) return 0; if (_v instanceof android.os.Parcelable) { return ((android.os.Parcelable) _v).describeContents(); } return 0; } private void _assertTag(int tag) { if (getTag() != tag) { throw new IllegalStateException("bad access: " + _tagString(tag) + ", " + _tagString(getTag()) + " is available."); } } private String _tagString(int _tag) { switch (_tag) { case num: return "num"; case str: return "str"; case bar: return "bar"; } throw new IllegalStateException("unknown field: " + _tag); } public static @interface Tag { public static final int num = 0; public static final int str = 1; public static final int bar = 2; } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-extras-java-source_gen_android_aidl_tests_immut0100644 0000000 0000000 00000000213 15172120304 033361 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/Union.java.d 28 mtime=1776853188.5540000 tests/golden_output/frozen/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/Union.java.0100644 0000000 0000000 00000000374 15172120304 033004 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/immutable/Union.java : \ system/tools/aidl/tests/android/aidl/tests/immutable/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/immutable/Bar.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-extras-java-source_gen_android_aidl_tests_map_0100644 0000000 0000000 00000000034 15172120304 033143 xustar000000000 0000000 28 mtime=1776853188.5540000 tests/golden_output/frozen/aidl-test-extras-java-source/gen/android/aidl/tests/map/0040755 0000000 0000000 00000000000 15172120304 027570 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-extras-java-source_gen_android_aidl_tests_map_B0100644 0000000 0000000 00000000034 15172120304 033245 xustar000000000 0000000 28 mtime=1776853188.5540000 tests/golden_output/frozen/aidl-test-extras-java-source/gen/android/aidl/tests/map/Bar.java0100644 0000000 0000000 00000004526 15172120304 031143 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/map/Bar.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/map/Bar.aidl */ package android.aidl.tests.map; public class Bar implements android.os.Parcelable { public int a = 0; public java.lang.String b; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public Bar createFromParcel(android.os.Parcel _aidl_source) { Bar _aidl_out = new Bar(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public Bar[] newArray(int _aidl_size) { return new Bar[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(a); _aidl_parcel.writeString(b); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; a = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; b = _aidl_parcel.readString(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-extras-java-source_gen_android_aidl_tests_map_B0100644 0000000 0000000 00000000034 15172120304 033245 xustar000000000 0000000 28 mtime=1776853188.5540000 tests/golden_output/frozen/aidl-test-extras-java-source/gen/android/aidl/tests/map/Bar.java.d0100644 0000000 0000000 00000000252 15172120304 031355 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/map/Bar.java : \ system/tools/aidl/tests/android/aidl/tests/map/Bar.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-extras-java-source_gen_android_aidl_tests_map_F0100644 0000000 0000000 00000000034 15172120304 033251 xustar000000000 0000000 28 mtime=1776853188.5550000 tests/golden_output/frozen/aidl-test-extras-java-source/gen/android/aidl/tests/map/Foo.java0100644 0000000 0000000 00000021631 15172120304 031156 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/map/Foo.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/map/Foo.aidl */ package android.aidl.tests.map; public class Foo implements android.os.Parcelable { public java.util.Map intEnumArrayMap; public java.util.Map intArrayMap; public java.util.Map barMap; public java.util.Map barArrayMap; public java.util.Map stringMap; public java.util.Map stringArrayMap; public java.util.Map interfaceMap; public java.util.Map ibinderMap; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public Foo createFromParcel(android.os.Parcel _aidl_source) { Foo _aidl_out = new Foo(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public Foo[] newArray(int _aidl_size) { return new Foo[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); if (intEnumArrayMap == null) { _aidl_parcel.writeInt(-1); } else { _aidl_parcel.writeInt(intEnumArrayMap.size()); intEnumArrayMap.forEach((k, v) -> { _aidl_parcel.writeString(k); _aidl_parcel.writeIntArray(v); }); } if (intArrayMap == null) { _aidl_parcel.writeInt(-1); } else { _aidl_parcel.writeInt(intArrayMap.size()); intArrayMap.forEach((k, v) -> { _aidl_parcel.writeString(k); _aidl_parcel.writeIntArray(v); }); } if (barMap == null) { _aidl_parcel.writeInt(-1); } else { _aidl_parcel.writeInt(barMap.size()); barMap.forEach((k, v) -> { _aidl_parcel.writeString(k); _aidl_parcel.writeTypedObject(v, _aidl_flag); }); } if (barArrayMap == null) { _aidl_parcel.writeInt(-1); } else { _aidl_parcel.writeInt(barArrayMap.size()); barArrayMap.forEach((k, v) -> { _aidl_parcel.writeString(k); _aidl_parcel.writeTypedArray(v, _aidl_flag); }); } if (stringMap == null) { _aidl_parcel.writeInt(-1); } else { _aidl_parcel.writeInt(stringMap.size()); stringMap.forEach((k, v) -> { _aidl_parcel.writeString(k); _aidl_parcel.writeString(v); }); } if (stringArrayMap == null) { _aidl_parcel.writeInt(-1); } else { _aidl_parcel.writeInt(stringArrayMap.size()); stringArrayMap.forEach((k, v) -> { _aidl_parcel.writeString(k); _aidl_parcel.writeStringArray(v); }); } if (interfaceMap == null) { _aidl_parcel.writeInt(-1); } else { _aidl_parcel.writeInt(interfaceMap.size()); interfaceMap.forEach((k, v) -> { _aidl_parcel.writeString(k); _aidl_parcel.writeStrongInterface(v); }); } if (ibinderMap == null) { _aidl_parcel.writeInt(-1); } else { _aidl_parcel.writeInt(ibinderMap.size()); ibinderMap.forEach((k, v) -> { _aidl_parcel.writeString(k); _aidl_parcel.writeStrongBinder(v); }); } int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; { int N = _aidl_parcel.readInt(); intEnumArrayMap = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = _aidl_parcel.readString(); int[] v; v = _aidl_parcel.createIntArray(); intEnumArrayMap.put(k, v); }); } if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; { int N = _aidl_parcel.readInt(); intArrayMap = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = _aidl_parcel.readString(); int[] v; v = _aidl_parcel.createIntArray(); intArrayMap.put(k, v); }); } if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; { int N = _aidl_parcel.readInt(); barMap = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = _aidl_parcel.readString(); android.aidl.tests.map.Bar v; v = _aidl_parcel.readTypedObject(android.aidl.tests.map.Bar.CREATOR); barMap.put(k, v); }); } if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; { int N = _aidl_parcel.readInt(); barArrayMap = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = _aidl_parcel.readString(); android.aidl.tests.map.Bar[] v; v = _aidl_parcel.createTypedArray(android.aidl.tests.map.Bar.CREATOR); barArrayMap.put(k, v); }); } if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; { int N = _aidl_parcel.readInt(); stringMap = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = _aidl_parcel.readString(); java.lang.String v; v = _aidl_parcel.readString(); stringMap.put(k, v); }); } if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; { int N = _aidl_parcel.readInt(); stringArrayMap = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = _aidl_parcel.readString(); java.lang.String[] v; v = _aidl_parcel.createStringArray(); stringArrayMap.put(k, v); }); } if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; { int N = _aidl_parcel.readInt(); interfaceMap = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = _aidl_parcel.readString(); android.aidl.tests.map.IEmpty v; v = android.aidl.tests.map.IEmpty.Stub.asInterface(_aidl_parcel.readStrongBinder()); interfaceMap.put(k, v); }); } if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; { int N = _aidl_parcel.readInt(); ibinderMap = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = _aidl_parcel.readString(); android.os.IBinder v; v = _aidl_parcel.readStrongBinder(); ibinderMap.put(k, v); }); } } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; _mask |= describeContents(barMap); _mask |= describeContents(barArrayMap); return _mask; } private int describeContents(Object _v) { if (_v == null) return 0; if (_v instanceof Object[]) { int _mask = 0; for (Object o : (Object[]) _v) { _mask |= describeContents(o); } return _mask; } if (_v instanceof java.util.Collection) { int _mask = 0; for (Object o : (java.util.Collection) _v) { _mask |= describeContents(o); } return _mask; } if (_v instanceof java.util.Map) { return describeContents(((java.util.Map) _v).values()); } if (_v instanceof android.os.Parcelable) { return ((android.os.Parcelable) _v).describeContents(); } return 0; } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-extras-java-source_gen_android_aidl_tests_map_F0100644 0000000 0000000 00000000034 15172120304 033251 xustar000000000 0000000 28 mtime=1776853188.5550000 tests/golden_output/frozen/aidl-test-extras-java-source/gen/android/aidl/tests/map/Foo.java.d0100644 0000000 0000000 00000000545 15172120304 031401 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/map/Foo.java : \ system/tools/aidl/tests/android/aidl/tests/map/Foo.aidl \ system/tools/aidl/tests/android/aidl/tests/map/Bar.aidl \ system/tools/aidl/tests/android/aidl/tests/map/IEmpty.aidl \ system/tools/aidl/tests/android/aidl/tests/map/IntEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-extras-java-source_gen_android_aidl_tests_map_I0100644 0000000 0000000 00000000034 15172120304 033254 xustar000000000 0000000 28 mtime=1776853188.5550000 tests/golden_output/frozen/aidl-test-extras-java-source/gen/android/aidl/tests/map/IEmpty.java0100644 0000000 0000000 00000006124 15172120304 031642 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/map/IEmpty.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/map/IEmpty.aidl */ package android.aidl.tests.map; public interface IEmpty extends android.os.IInterface { /** Default implementation for IEmpty. */ public static class Default implements android.aidl.tests.map.IEmpty { @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.map.IEmpty { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.map.IEmpty interface, * generating a proxy if needed. */ public static android.aidl.tests.map.IEmpty asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.map.IEmpty))) { return ((android.aidl.tests.map.IEmpty)iin); } return new android.aidl.tests.map.IEmpty.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { default: { return super.onTransact(code, data, reply, flags); } } } private static class Proxy implements android.aidl.tests.map.IEmpty { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } } /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.map.IEmpty"; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-extras-java-source_gen_android_aidl_tests_map_I0100644 0000000 0000000 00000000034 15172120304 033254 xustar000000000 0000000 28 mtime=1776853188.5550000 tests/golden_output/frozen/aidl-test-extras-java-source/gen/android/aidl/tests/map/IEmpty.java.d0100644 0000000 0000000 00000000260 15172120304 032057 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/map/IEmpty.java : \ system/tools/aidl/tests/android/aidl/tests/map/IEmpty.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-extras-java-source_gen_android_aidl_tests_map_I0100644 0000000 0000000 00000000034 15172120304 033254 xustar000000000 0000000 28 mtime=1776853188.5550000 tests/golden_output/frozen/aidl-test-extras-java-source/gen/android/aidl/tests/map/IMapTest.java0100644 0000000 0000000 00000102573 15172120304 032126 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/map/IMapTest.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/map/IMapTest.aidl */ package android.aidl.tests.map; public interface IMapTest extends android.os.IInterface { /** Default implementation for IMapTest. */ public static class Default implements android.aidl.tests.map.IMapTest { @Override public java.util.Map repeatIntEnumArrayMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException { return null; } @Override public java.util.Map repeatIntArrayMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException { return null; } @Override public java.util.Map repeatBarMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException { return null; } @Override public java.util.Map repeatBarArrayMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException { return null; } @Override public java.util.Map repeatStringMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException { return null; } @Override public java.util.Map repeatStringArrayMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException { return null; } @Override public java.util.Map repeatInterfaceMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException { return null; } @Override public java.util.Map repeatIbinderMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException { return null; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.map.IMapTest { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.map.IMapTest interface, * generating a proxy if needed. */ public static android.aidl.tests.map.IMapTest asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.map.IMapTest))) { return ((android.aidl.tests.map.IMapTest)iin); } return new android.aidl.tests.map.IMapTest.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_repeatIntEnumArrayMap: { return "repeatIntEnumArrayMap"; } case TRANSACTION_repeatIntArrayMap: { return "repeatIntArrayMap"; } case TRANSACTION_repeatBarMap: { return "repeatBarMap"; } case TRANSACTION_repeatBarArrayMap: { return "repeatBarArrayMap"; } case TRANSACTION_repeatStringMap: { return "repeatStringMap"; } case TRANSACTION_repeatStringArrayMap: { return "repeatStringArrayMap"; } case TRANSACTION_repeatInterfaceMap: { return "repeatInterfaceMap"; } case TRANSACTION_repeatIbinderMap: { return "repeatIbinderMap"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_repeatIntEnumArrayMap: { java.util.Map _arg0; { int N = data.readInt(); _arg0 = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = data.readString(); int[] v; v = data.createIntArray(); _arg0.put(k, v); }); } java.util.Map _arg1; _arg1 = new java.util.HashMap(); data.enforceNoDataAvail(); java.util.Map _result = this.repeatIntEnumArrayMap(_arg0, _arg1); reply.writeNoException(); if (_result == null) { reply.writeInt(-1); } else { reply.writeInt(_result.size()); _result.forEach((k, v) -> { reply.writeString(k); reply.writeIntArray(v); }); } if (_arg1 == null) { reply.writeInt(-1); } else { reply.writeInt(_arg1.size()); _arg1.forEach((k, v) -> { reply.writeString(k); reply.writeIntArray(v); }); } break; } case TRANSACTION_repeatIntArrayMap: { java.util.Map _arg0; { int N = data.readInt(); _arg0 = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = data.readString(); int[] v; v = data.createIntArray(); _arg0.put(k, v); }); } java.util.Map _arg1; _arg1 = new java.util.HashMap(); data.enforceNoDataAvail(); java.util.Map _result = this.repeatIntArrayMap(_arg0, _arg1); reply.writeNoException(); if (_result == null) { reply.writeInt(-1); } else { reply.writeInt(_result.size()); _result.forEach((k, v) -> { reply.writeString(k); reply.writeIntArray(v); }); } if (_arg1 == null) { reply.writeInt(-1); } else { reply.writeInt(_arg1.size()); _arg1.forEach((k, v) -> { reply.writeString(k); reply.writeIntArray(v); }); } break; } case TRANSACTION_repeatBarMap: { java.util.Map _arg0; { int N = data.readInt(); _arg0 = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = data.readString(); android.aidl.tests.map.Bar v; v = data.readTypedObject(android.aidl.tests.map.Bar.CREATOR); _arg0.put(k, v); }); } java.util.Map _arg1; _arg1 = new java.util.HashMap(); data.enforceNoDataAvail(); java.util.Map _result = this.repeatBarMap(_arg0, _arg1); reply.writeNoException(); if (_result == null) { reply.writeInt(-1); } else { reply.writeInt(_result.size()); _result.forEach((k, v) -> { reply.writeString(k); reply.writeTypedObject(v, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); }); } if (_arg1 == null) { reply.writeInt(-1); } else { reply.writeInt(_arg1.size()); _arg1.forEach((k, v) -> { reply.writeString(k); reply.writeTypedObject(v, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); }); } break; } case TRANSACTION_repeatBarArrayMap: { java.util.Map _arg0; { int N = data.readInt(); _arg0 = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = data.readString(); android.aidl.tests.map.Bar[] v; v = data.createTypedArray(android.aidl.tests.map.Bar.CREATOR); _arg0.put(k, v); }); } java.util.Map _arg1; _arg1 = new java.util.HashMap(); data.enforceNoDataAvail(); java.util.Map _result = this.repeatBarArrayMap(_arg0, _arg1); reply.writeNoException(); if (_result == null) { reply.writeInt(-1); } else { reply.writeInt(_result.size()); _result.forEach((k, v) -> { reply.writeString(k); reply.writeTypedArray(v, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); }); } if (_arg1 == null) { reply.writeInt(-1); } else { reply.writeInt(_arg1.size()); _arg1.forEach((k, v) -> { reply.writeString(k); reply.writeTypedArray(v, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); }); } break; } case TRANSACTION_repeatStringMap: { java.util.Map _arg0; { int N = data.readInt(); _arg0 = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = data.readString(); java.lang.String v; v = data.readString(); _arg0.put(k, v); }); } java.util.Map _arg1; _arg1 = new java.util.HashMap(); data.enforceNoDataAvail(); java.util.Map _result = this.repeatStringMap(_arg0, _arg1); reply.writeNoException(); if (_result == null) { reply.writeInt(-1); } else { reply.writeInt(_result.size()); _result.forEach((k, v) -> { reply.writeString(k); reply.writeString(v); }); } if (_arg1 == null) { reply.writeInt(-1); } else { reply.writeInt(_arg1.size()); _arg1.forEach((k, v) -> { reply.writeString(k); reply.writeString(v); }); } break; } case TRANSACTION_repeatStringArrayMap: { java.util.Map _arg0; { int N = data.readInt(); _arg0 = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = data.readString(); java.lang.String[] v; v = data.createStringArray(); _arg0.put(k, v); }); } java.util.Map _arg1; _arg1 = new java.util.HashMap(); data.enforceNoDataAvail(); java.util.Map _result = this.repeatStringArrayMap(_arg0, _arg1); reply.writeNoException(); if (_result == null) { reply.writeInt(-1); } else { reply.writeInt(_result.size()); _result.forEach((k, v) -> { reply.writeString(k); reply.writeStringArray(v); }); } if (_arg1 == null) { reply.writeInt(-1); } else { reply.writeInt(_arg1.size()); _arg1.forEach((k, v) -> { reply.writeString(k); reply.writeStringArray(v); }); } break; } case TRANSACTION_repeatInterfaceMap: { java.util.Map _arg0; { int N = data.readInt(); _arg0 = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = data.readString(); android.aidl.tests.map.IEmpty v; v = android.aidl.tests.map.IEmpty.Stub.asInterface(data.readStrongBinder()); _arg0.put(k, v); }); } java.util.Map _arg1; _arg1 = new java.util.HashMap(); data.enforceNoDataAvail(); java.util.Map _result = this.repeatInterfaceMap(_arg0, _arg1); reply.writeNoException(); if (_result == null) { reply.writeInt(-1); } else { reply.writeInt(_result.size()); _result.forEach((k, v) -> { reply.writeString(k); reply.writeStrongInterface(v); }); } if (_arg1 == null) { reply.writeInt(-1); } else { reply.writeInt(_arg1.size()); _arg1.forEach((k, v) -> { reply.writeString(k); reply.writeStrongInterface(v); }); } break; } case TRANSACTION_repeatIbinderMap: { java.util.Map _arg0; { int N = data.readInt(); _arg0 = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = data.readString(); android.os.IBinder v; v = data.readStrongBinder(); _arg0.put(k, v); }); } java.util.Map _arg1; _arg1 = new java.util.HashMap(); data.enforceNoDataAvail(); java.util.Map _result = this.repeatIbinderMap(_arg0, _arg1); reply.writeNoException(); if (_result == null) { reply.writeInt(-1); } else { reply.writeInt(_result.size()); _result.forEach((k, v) -> { reply.writeString(k); reply.writeStrongBinder(v); }); } if (_arg1 == null) { reply.writeInt(-1); } else { reply.writeInt(_arg1.size()); _arg1.forEach((k, v) -> { reply.writeString(k); reply.writeStrongBinder(v); }); } break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.map.IMapTest { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public java.util.Map repeatIntEnumArrayMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.util.Map _result; try { _data.writeInterfaceToken(DESCRIPTOR); if (input == null) { _data.writeInt(-1); } else { _data.writeInt(input.size()); input.forEach((k, v) -> { _data.writeString(k); _data.writeIntArray(v); }); } boolean _status = mRemote.transact(Stub.TRANSACTION_repeatIntEnumArrayMap, _data, _reply, 0); _reply.readException(); { int N = _reply.readInt(); _result = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = _reply.readString(); int[] v; v = _reply.createIntArray(); _result.put(k, v); }); } if (output != null) output.clear(); java.util.stream.IntStream.range(0, _reply.readInt()).forEach(i -> { String k = _reply.readString(); int[] v; v = _reply.createIntArray(); output.put(k, v); }); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.util.Map repeatIntArrayMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.util.Map _result; try { _data.writeInterfaceToken(DESCRIPTOR); if (input == null) { _data.writeInt(-1); } else { _data.writeInt(input.size()); input.forEach((k, v) -> { _data.writeString(k); _data.writeIntArray(v); }); } boolean _status = mRemote.transact(Stub.TRANSACTION_repeatIntArrayMap, _data, _reply, 0); _reply.readException(); { int N = _reply.readInt(); _result = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = _reply.readString(); int[] v; v = _reply.createIntArray(); _result.put(k, v); }); } if (output != null) output.clear(); java.util.stream.IntStream.range(0, _reply.readInt()).forEach(i -> { String k = _reply.readString(); int[] v; v = _reply.createIntArray(); output.put(k, v); }); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.util.Map repeatBarMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.util.Map _result; try { _data.writeInterfaceToken(DESCRIPTOR); if (input == null) { _data.writeInt(-1); } else { _data.writeInt(input.size()); input.forEach((k, v) -> { _data.writeString(k); _data.writeTypedObject(v, 0); }); } boolean _status = mRemote.transact(Stub.TRANSACTION_repeatBarMap, _data, _reply, 0); _reply.readException(); { int N = _reply.readInt(); _result = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = _reply.readString(); android.aidl.tests.map.Bar v; v = _reply.readTypedObject(android.aidl.tests.map.Bar.CREATOR); _result.put(k, v); }); } if (output != null) output.clear(); java.util.stream.IntStream.range(0, _reply.readInt()).forEach(i -> { String k = _reply.readString(); android.aidl.tests.map.Bar v; v = _reply.readTypedObject(android.aidl.tests.map.Bar.CREATOR); output.put(k, v); }); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.util.Map repeatBarArrayMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.util.Map _result; try { _data.writeInterfaceToken(DESCRIPTOR); if (input == null) { _data.writeInt(-1); } else { _data.writeInt(input.size()); input.forEach((k, v) -> { _data.writeString(k); _data.writeTypedArray(v, 0); }); } boolean _status = mRemote.transact(Stub.TRANSACTION_repeatBarArrayMap, _data, _reply, 0); _reply.readException(); { int N = _reply.readInt(); _result = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = _reply.readString(); android.aidl.tests.map.Bar[] v; v = _reply.createTypedArray(android.aidl.tests.map.Bar.CREATOR); _result.put(k, v); }); } if (output != null) output.clear(); java.util.stream.IntStream.range(0, _reply.readInt()).forEach(i -> { String k = _reply.readString(); android.aidl.tests.map.Bar[] v; v = _reply.createTypedArray(android.aidl.tests.map.Bar.CREATOR); output.put(k, v); }); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.util.Map repeatStringMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.util.Map _result; try { _data.writeInterfaceToken(DESCRIPTOR); if (input == null) { _data.writeInt(-1); } else { _data.writeInt(input.size()); input.forEach((k, v) -> { _data.writeString(k); _data.writeString(v); }); } boolean _status = mRemote.transact(Stub.TRANSACTION_repeatStringMap, _data, _reply, 0); _reply.readException(); { int N = _reply.readInt(); _result = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = _reply.readString(); java.lang.String v; v = _reply.readString(); _result.put(k, v); }); } if (output != null) output.clear(); java.util.stream.IntStream.range(0, _reply.readInt()).forEach(i -> { String k = _reply.readString(); java.lang.String v; v = _reply.readString(); output.put(k, v); }); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.util.Map repeatStringArrayMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.util.Map _result; try { _data.writeInterfaceToken(DESCRIPTOR); if (input == null) { _data.writeInt(-1); } else { _data.writeInt(input.size()); input.forEach((k, v) -> { _data.writeString(k); _data.writeStringArray(v); }); } boolean _status = mRemote.transact(Stub.TRANSACTION_repeatStringArrayMap, _data, _reply, 0); _reply.readException(); { int N = _reply.readInt(); _result = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = _reply.readString(); java.lang.String[] v; v = _reply.createStringArray(); _result.put(k, v); }); } if (output != null) output.clear(); java.util.stream.IntStream.range(0, _reply.readInt()).forEach(i -> { String k = _reply.readString(); java.lang.String[] v; v = _reply.createStringArray(); output.put(k, v); }); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.util.Map repeatInterfaceMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.util.Map _result; try { _data.writeInterfaceToken(DESCRIPTOR); if (input == null) { _data.writeInt(-1); } else { _data.writeInt(input.size()); input.forEach((k, v) -> { _data.writeString(k); _data.writeStrongInterface(v); }); } boolean _status = mRemote.transact(Stub.TRANSACTION_repeatInterfaceMap, _data, _reply, 0); _reply.readException(); { int N = _reply.readInt(); _result = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = _reply.readString(); android.aidl.tests.map.IEmpty v; v = android.aidl.tests.map.IEmpty.Stub.asInterface(_reply.readStrongBinder()); _result.put(k, v); }); } if (output != null) output.clear(); java.util.stream.IntStream.range(0, _reply.readInt()).forEach(i -> { String k = _reply.readString(); android.aidl.tests.map.IEmpty v; v = android.aidl.tests.map.IEmpty.Stub.asInterface(_reply.readStrongBinder()); output.put(k, v); }); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.util.Map repeatIbinderMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.util.Map _result; try { _data.writeInterfaceToken(DESCRIPTOR); if (input == null) { _data.writeInt(-1); } else { _data.writeInt(input.size()); input.forEach((k, v) -> { _data.writeString(k); _data.writeStrongBinder(v); }); } boolean _status = mRemote.transact(Stub.TRANSACTION_repeatIbinderMap, _data, _reply, 0); _reply.readException(); { int N = _reply.readInt(); _result = N < 0 ? null : new java.util.HashMap<>(); java.util.stream.IntStream.range(0, N).forEach(i -> { String k = _reply.readString(); android.os.IBinder v; v = _reply.readStrongBinder(); _result.put(k, v); }); } if (output != null) output.clear(); java.util.stream.IntStream.range(0, _reply.readInt()).forEach(i -> { String k = _reply.readString(); android.os.IBinder v; v = _reply.readStrongBinder(); output.put(k, v); }); } finally { _reply.recycle(); _data.recycle(); } return _result; } } static final int TRANSACTION_repeatIntEnumArrayMap = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); static final int TRANSACTION_repeatIntArrayMap = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1); static final int TRANSACTION_repeatBarMap = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2); static final int TRANSACTION_repeatBarArrayMap = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3); static final int TRANSACTION_repeatStringMap = (android.os.IBinder.FIRST_CALL_TRANSACTION + 4); static final int TRANSACTION_repeatStringArrayMap = (android.os.IBinder.FIRST_CALL_TRANSACTION + 5); static final int TRANSACTION_repeatInterfaceMap = (android.os.IBinder.FIRST_CALL_TRANSACTION + 6); static final int TRANSACTION_repeatIbinderMap = (android.os.IBinder.FIRST_CALL_TRANSACTION + 7); /** @hide */ public int getMaxTransactionId() { return 7; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.map.IMapTest"; public java.util.Map repeatIntEnumArrayMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException; public java.util.Map repeatIntArrayMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException; public java.util.Map repeatBarMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException; public java.util.Map repeatBarArrayMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException; public java.util.Map repeatStringMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException; public java.util.Map repeatStringArrayMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException; public java.util.Map repeatInterfaceMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException; public java.util.Map repeatIbinderMap(java.util.Map input, java.util.Map output) throws android.os.RemoteException; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-extras-java-source_gen_android_aidl_tests_map_I0100644 0000000 0000000 00000000034 15172120304 033254 xustar000000000 0000000 28 mtime=1776853188.5560000 tests/golden_output/frozen/aidl-test-extras-java-source/gen/android/aidl/tests/map/IMapTest.java.d0100644 0000000 0000000 00000000557 15172120304 032347 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/map/IMapTest.java : \ system/tools/aidl/tests/android/aidl/tests/map/IMapTest.aidl \ system/tools/aidl/tests/android/aidl/tests/map/Bar.aidl \ system/tools/aidl/tests/android/aidl/tests/map/IEmpty.aidl \ system/tools/aidl/tests/android/aidl/tests/map/IntEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-extras-java-source_gen_android_aidl_tests_map_I0100644 0000000 0000000 00000000034 15172120304 033254 xustar000000000 0000000 28 mtime=1776853188.5560000 tests/golden_output/frozen/aidl-test-extras-java-source/gen/android/aidl/tests/map/IntEnum.java0100644 0000000 0000000 00000001226 15172120304 032010 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/map/IntEnum.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/map/IntEnum.aidl */ package android.aidl.tests.map; public @interface IntEnum { public static final int FOO = 1000; public static final int BAR = 2000; public static final int BAZ = 2001; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-extras-java-source_gen_android_aidl_tests_map_I0100644 0000000 0000000 00000000034 15172120304 033254 xustar000000000 0000000 28 mtime=1776853188.5570000 tests/golden_output/frozen/aidl-test-extras-java-source/gen/android/aidl/tests/map/IntEnum.java.d0100644 0000000 0000000 00000000262 15172120304 032231 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-extras-java-source/gen/android/aidl/tests/map/IntEnum.java : \ system/tools/aidl/tests/android/aidl/tests/map/IntEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-extras-java-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 030317 xustar000000000 0000000 28 mtime=1776853188.5570000 tests/golden_output/frozen/aidl-test-extras-java-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 025231 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-cpp-source_0100644 0000000 0000000 00000000034 15172120304 027126 xustar000000000 0000000 28 mtime=1776853188.5570000 tests/golden_output/frozen/aidl-test-fixedsizearray-cpp-source/0040755 0000000 0000000 00000000000 15172120304 024133 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-cpp-source_gen_0100644 0000000 0000000 00000000034 15172120304 027757 xustar000000000 0000000 28 mtime=1776853188.5570000 tests/golden_output/frozen/aidl-test-fixedsizearray-cpp-source/gen/0040755 0000000 0000000 00000000000 15172120304 024704 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-cpp-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 031457 xustar000000000 0000000 28 mtime=1776853188.5570000 tests/golden_output/frozen/aidl-test-fixedsizearray-cpp-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 026324 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-cpp-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 032450 xustar000000000 0000000 28 mtime=1776853188.5570000 tests/golden_output/frozen/aidl-test-fixedsizearray-cpp-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 027235 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-cpp-source_gen_android_aidl_fixe0100644 0000000 0000000 00000000034 15172120304 033324 xustar000000000 0000000 28 mtime=1776853188.5570000 tests/golden_output/frozen/aidl-test-fixedsizearray-cpp-source/gen/android/aidl/fixedsizearray/0040755 0000000 0000000 00000000000 15172120304 032266 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-cpp-source_gen_android_aidl_fixe0100644 0000000 0000000 00000000236 15172120304 033330 xustar000000000 0000000 130 path=tests/golden_output/frozen/aidl-test-fixedsizearray-cpp-source/gen/android/aidl/fixedsizearray/FixedSizeArrayExample.cpp 28 mtime=1776853188.5580000 tests/golden_output/frozen/aidl-test-fixedsizearray-cpp-source/gen/android/aidl/fixedsizearray/Fixed0100644 0000000 0000000 00000167224 15172120304 033261 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-cpp-source/gen/staging/android/aidl/fixedsizearray/FixedSizeArrayExample.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/fixedsizearray/FixedSizeArrayExample.aidl */ #include namespace android { namespace aidl { namespace fixedsizearray { ::android::status_t FixedSizeArrayExample::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&int2x3); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&boolArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&byteArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&charArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&intArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&longArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&floatArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&doubleArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&stringArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&byteEnumArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&intEnumArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&longEnumArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&parcelableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&boolMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&byteMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&charMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&intMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&longMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&floatMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&doubleMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&stringMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&byteEnumMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&intEnumMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&longEnumMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&parcelableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&boolNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&byteNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&charNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&intNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&longNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&floatNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&doubleNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&stringNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&byteEnumNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&intEnumNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&longEnumNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&binderNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&pfdNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&parcelableNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&interfaceNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&boolNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&byteNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&charNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&intNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&longNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&floatNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&doubleNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&stringNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&byteEnumNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&intEnumNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&longEnumNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&binderNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&pfdNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&parcelableNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFixedArray(&interfaceNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t FixedSizeArrayExample::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeFixedArray(int2x3); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(boolArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(byteArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(charArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(intArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(longArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(floatArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(doubleArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(stringArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(byteEnumArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(intEnumArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(longEnumArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(parcelableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(boolMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(byteMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(charMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(intMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(longMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(floatMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(doubleMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(stringMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(byteEnumMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(intEnumMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(longEnumMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(parcelableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(boolNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(byteNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(charNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(intNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(longNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(floatNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(doubleNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(stringNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(byteEnumNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(intEnumNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(longEnumNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(binderNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(pfdNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(parcelableNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(interfaceNullableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(boolNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(byteNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(charNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(intNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(longNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(floatNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(doubleNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(stringNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(byteEnumNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(intEnumNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(longEnumNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(binderNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(pfdNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(parcelableNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFixedArray(interfaceNullableMatrix); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace fixedsizearray } // namespace aidl } // namespace android #include #include namespace android { namespace aidl { namespace fixedsizearray { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_NESTED_INTERFACE(FixedSizeArrayExample, RepeatFixedSizeArray, "android.aidl.fixedsizearray.FixedSizeArrayExample.IRepeatFixedSizeArray") } // namespace fixedsizearray } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace fixedsizearray { FixedSizeArrayExample::BpRepeatFixedSizeArray::BpRepeatFixedSizeArray(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } ::android::binder::Status FixedSizeArrayExample::BpRepeatFixedSizeArray::RepeatBytes(const std::array& input, std::array* repeated, std::array* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IRepeatFixedSizeArray::RepeatBytes::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeFixedArray(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(FixedSizeArrayExample::BnRepeatFixedSizeArray::TRANSACTION_RepeatBytes, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl()) [[unlikely]] { return IRepeatFixedSizeArray::getDefaultImpl()->RepeatBytes(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readFixedArray(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readFixedArray(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status FixedSizeArrayExample::BpRepeatFixedSizeArray::RepeatInts(const std::array& input, std::array* repeated, std::array* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IRepeatFixedSizeArray::RepeatInts::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeFixedArray(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(FixedSizeArrayExample::BnRepeatFixedSizeArray::TRANSACTION_RepeatInts, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl()) [[unlikely]] { return IRepeatFixedSizeArray::getDefaultImpl()->RepeatInts(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readFixedArray(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readFixedArray(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status FixedSizeArrayExample::BpRepeatFixedSizeArray::RepeatBinders(const std::array<::android::sp<::android::IBinder>, 3>& input, std::array<::android::sp<::android::IBinder>, 3>* repeated, std::array<::android::sp<::android::IBinder>, 3>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IRepeatFixedSizeArray::RepeatBinders::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeFixedArray(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(FixedSizeArrayExample::BnRepeatFixedSizeArray::TRANSACTION_RepeatBinders, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl()) [[unlikely]] { return IRepeatFixedSizeArray::getDefaultImpl()->RepeatBinders(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readFixedArray(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readFixedArray(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status FixedSizeArrayExample::BpRepeatFixedSizeArray::RepeatParcelables(const std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>& input, std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* repeated, std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IRepeatFixedSizeArray::RepeatParcelables::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeFixedArray(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(FixedSizeArrayExample::BnRepeatFixedSizeArray::TRANSACTION_RepeatParcelables, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl()) [[unlikely]] { return IRepeatFixedSizeArray::getDefaultImpl()->RepeatParcelables(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readFixedArray(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readFixedArray(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status FixedSizeArrayExample::BpRepeatFixedSizeArray::Repeat2dBytes(const std::array, 2>& input, std::array, 2>* repeated, std::array, 2>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IRepeatFixedSizeArray::Repeat2dBytes::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeFixedArray(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(FixedSizeArrayExample::BnRepeatFixedSizeArray::TRANSACTION_Repeat2dBytes, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl()) [[unlikely]] { return IRepeatFixedSizeArray::getDefaultImpl()->Repeat2dBytes(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readFixedArray(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readFixedArray(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status FixedSizeArrayExample::BpRepeatFixedSizeArray::Repeat2dInts(const std::array, 2>& input, std::array, 2>* repeated, std::array, 2>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IRepeatFixedSizeArray::Repeat2dInts::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeFixedArray(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(FixedSizeArrayExample::BnRepeatFixedSizeArray::TRANSACTION_Repeat2dInts, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl()) [[unlikely]] { return IRepeatFixedSizeArray::getDefaultImpl()->Repeat2dInts(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readFixedArray(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readFixedArray(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status FixedSizeArrayExample::BpRepeatFixedSizeArray::Repeat2dBinders(const std::array, 3>, 2>& input, std::array, 3>, 2>* repeated, std::array, 3>, 2>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IRepeatFixedSizeArray::Repeat2dBinders::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeFixedArray(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(FixedSizeArrayExample::BnRepeatFixedSizeArray::TRANSACTION_Repeat2dBinders, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl()) [[unlikely]] { return IRepeatFixedSizeArray::getDefaultImpl()->Repeat2dBinders(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readFixedArray(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readFixedArray(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status FixedSizeArrayExample::BpRepeatFixedSizeArray::Repeat2dParcelables(const std::array, 2>& input, std::array, 2>* repeated, std::array, 2>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IRepeatFixedSizeArray::Repeat2dParcelables::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeFixedArray(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(FixedSizeArrayExample::BnRepeatFixedSizeArray::TRANSACTION_Repeat2dParcelables, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl()) [[unlikely]] { return IRepeatFixedSizeArray::getDefaultImpl()->Repeat2dParcelables(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readFixedArray(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readFixedArray(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } } // namespace fixedsizearray } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace fixedsizearray { FixedSizeArrayExample::BnRepeatFixedSizeArray::BnRepeatFixedSizeArray() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t FixedSizeArrayExample::BnRepeatFixedSizeArray::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnRepeatFixedSizeArray::TRANSACTION_RepeatBytes: { std::array in_input; std::array out_repeated; std::array _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IRepeatFixedSizeArray::RepeatBytes::cppServer"); _aidl_ret_status = _aidl_data.readFixedArray(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatBytes(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeFixedArray(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeFixedArray(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnRepeatFixedSizeArray::TRANSACTION_RepeatInts: { std::array in_input; std::array out_repeated; std::array _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IRepeatFixedSizeArray::RepeatInts::cppServer"); _aidl_ret_status = _aidl_data.readFixedArray(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatInts(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeFixedArray(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeFixedArray(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnRepeatFixedSizeArray::TRANSACTION_RepeatBinders: { std::array<::android::sp<::android::IBinder>, 3> in_input; std::array<::android::sp<::android::IBinder>, 3> out_repeated; std::array<::android::sp<::android::IBinder>, 3> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IRepeatFixedSizeArray::RepeatBinders::cppServer"); _aidl_ret_status = _aidl_data.readFixedArray(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatBinders(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeFixedArray(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeFixedArray(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnRepeatFixedSizeArray::TRANSACTION_RepeatParcelables: { std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3> in_input; std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3> out_repeated; std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IRepeatFixedSizeArray::RepeatParcelables::cppServer"); _aidl_ret_status = _aidl_data.readFixedArray(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatParcelables(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeFixedArray(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeFixedArray(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnRepeatFixedSizeArray::TRANSACTION_Repeat2dBytes: { std::array, 2> in_input; std::array, 2> out_repeated; std::array, 2> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IRepeatFixedSizeArray::Repeat2dBytes::cppServer"); _aidl_ret_status = _aidl_data.readFixedArray(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(Repeat2dBytes(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeFixedArray(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeFixedArray(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnRepeatFixedSizeArray::TRANSACTION_Repeat2dInts: { std::array, 2> in_input; std::array, 2> out_repeated; std::array, 2> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IRepeatFixedSizeArray::Repeat2dInts::cppServer"); _aidl_ret_status = _aidl_data.readFixedArray(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(Repeat2dInts(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeFixedArray(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeFixedArray(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnRepeatFixedSizeArray::TRANSACTION_Repeat2dBinders: { std::array, 3>, 2> in_input; std::array, 3>, 2> out_repeated; std::array, 3>, 2> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IRepeatFixedSizeArray::Repeat2dBinders::cppServer"); _aidl_ret_status = _aidl_data.readFixedArray(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(Repeat2dBinders(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeFixedArray(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeFixedArray(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnRepeatFixedSizeArray::TRANSACTION_Repeat2dParcelables: { std::array, 2> in_input; std::array, 2> out_repeated; std::array, 2> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IRepeatFixedSizeArray::Repeat2dParcelables::cppServer"); _aidl_ret_status = _aidl_data.readFixedArray(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(Repeat2dParcelables(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeFixedArray(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeFixedArray(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } } // namespace fixedsizearray } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace fixedsizearray { ::android::status_t FixedSizeArrayExample::IntParcelable::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&value); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t FixedSizeArrayExample::IntParcelable::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeInt32(value); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace fixedsizearray } // namespace aidl } // namespace android #include #include namespace android { namespace aidl { namespace fixedsizearray { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_NESTED_INTERFACE(FixedSizeArrayExample, EmptyInterface, "android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface") } // namespace fixedsizearray } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace fixedsizearray { FixedSizeArrayExample::BpEmptyInterface::BpEmptyInterface(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } } // namespace fixedsizearray } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace fixedsizearray { FixedSizeArrayExample::BnEmptyInterface::BnEmptyInterface() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t FixedSizeArrayExample::BnEmptyInterface::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } } // namespace fixedsizearray } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-cpp-source_gen_android_aidl_fixe0100644 0000000 0000000 00000000240 15172120304 033323 xustar000000000 0000000 132 path=tests/golden_output/frozen/aidl-test-fixedsizearray-cpp-source/gen/android/aidl/fixedsizearray/FixedSizeArrayExample.cpp.d 28 mtime=1776853188.5590000 tests/golden_output/frozen/aidl-test-fixedsizearray-cpp-source/gen/android/aidl/fixedsizearray/Fixed0100644 0000000 0000000 00000000336 15172120304 033247 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-cpp-source/gen/android/aidl/fixedsizearray/FixedSizeArrayExample.cpp : \ system/tools/aidl/tests/android/aidl/fixedsizearray/FixedSizeArrayExample.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-cpp-source_gen_include_0100644 0000000 0000000 00000000034 15172120304 031462 xustar000000000 0000000 28 mtime=1776853188.5590000 tests/golden_output/frozen/aidl-test-fixedsizearray-cpp-source/gen/include/0040755 0000000 0000000 00000000000 15172120304 026327 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-cpp-source_gen_include_android_0100644 0000000 0000000 00000000034 15172120304 033162 xustar000000000 0000000 28 mtime=1776853188.5590000 tests/golden_output/frozen/aidl-test-fixedsizearray-cpp-source/gen/include/android/0040755 0000000 0000000 00000000000 15172120304 027747 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-cpp-source_gen_include_android_a0100644 0000000 0000000 00000000034 15172120304 033323 xustar000000000 0000000 28 mtime=1776853188.5590000 tests/golden_output/frozen/aidl-test-fixedsizearray-cpp-source/gen/include/android/aidl/0040755 0000000 0000000 00000000000 15172120304 030660 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-cpp-source_gen_include_android_a0100644 0000000 0000000 00000000215 15172120304 033324 xustar000000000 0000000 113 path=tests/golden_output/frozen/aidl-test-fixedsizearray-cpp-source/gen/include/android/aidl/fixedsizearray/ 28 mtime=1776853188.5590000 tests/golden_output/frozen/aidl-test-fixedsizearray-cpp-source/gen/include/android/aidl/fixedsizearr0040755 0000000 0000000 00000000000 15172120304 033300 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-cpp-source_gen_include_android_a0100644 0000000 0000000 00000000246 15172120304 033330 xustar000000000 0000000 138 path=tests/golden_output/frozen/aidl-test-fixedsizearray-cpp-source/gen/include/android/aidl/fixedsizearray/BnFixedSizeArrayExample.h 28 mtime=1776853188.5590000 tests/golden_output/frozen/aidl-test-fixedsizearray-cpp-source/gen/include/android/aidl/fixedsizearr0100644 0000000 0000000 00000001273 15172120304 033302 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-cpp-source/gen/staging/android/aidl/fixedsizearray/FixedSizeArrayExample.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/fixedsizearray/FixedSizeArrayExample.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-cpp-source_gen_include_android_a0100644 0000000 0000000 00000000246 15172120304 033330 xustar000000000 0000000 138 path=tests/golden_output/frozen/aidl-test-fixedsizearray-cpp-source/gen/include/android/aidl/fixedsizearray/BpFixedSizeArrayExample.h 28 mtime=1776853188.5600000 tests/golden_output/frozen/aidl-test-fixedsizearray-cpp-source/gen/include/android/aidl/fixedsizearr0100644 0000000 0000000 00000001273 15172120304 033302 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-cpp-source/gen/staging/android/aidl/fixedsizearray/FixedSizeArrayExample.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/fixedsizearray/FixedSizeArrayExample.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-cpp-source_gen_include_android_a0100644 0000000 0000000 00000000244 15172120304 033326 xustar000000000 0000000 136 path=tests/golden_output/frozen/aidl-test-fixedsizearray-cpp-source/gen/include/android/aidl/fixedsizearray/FixedSizeArrayExample.h 28 mtime=1776853188.5600000 tests/golden_output/frozen/aidl-test-fixedsizearray-cpp-source/gen/include/android/aidl/fixedsizearr0100644 0000000 0000000 00000102430 15172120304 033277 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-cpp-source/gen/staging/android/aidl/fixedsizearray/FixedSizeArrayExample.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/fixedsizearray/FixedSizeArrayExample.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace android { namespace aidl { namespace fixedsizearray { class FixedSizeArrayExample : public ::android::Parcelable { public: class IntParcelable : public ::android::Parcelable { public: int32_t value = 0; inline bool operator==(const IntParcelable& _rhs) const { return std::tie(value) == std::tie(_rhs.value); } inline bool operator<(const IntParcelable& _rhs) const { return std::tie(value) < std::tie(_rhs.value); } inline bool operator!=(const IntParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const IntParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const IntParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const IntParcelable& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "IntParcelable{"; _aidl_os << "value: " << ::android::internal::ToString(value); _aidl_os << "}"; return _aidl_os.str(); } }; // class IntParcelable class IRepeatFixedSizeArrayDelegator; class IRepeatFixedSizeArray : public ::android::IInterface { public: typedef IRepeatFixedSizeArrayDelegator DefaultDelegator; DECLARE_META_INTERFACE(RepeatFixedSizeArray) virtual ::android::binder::Status RepeatBytes(const std::array& input, std::array* repeated, std::array* _aidl_return) = 0; virtual ::android::binder::Status RepeatInts(const std::array& input, std::array* repeated, std::array* _aidl_return) = 0; virtual ::android::binder::Status RepeatBinders(const std::array<::android::sp<::android::IBinder>, 3>& input, std::array<::android::sp<::android::IBinder>, 3>* repeated, std::array<::android::sp<::android::IBinder>, 3>* _aidl_return) = 0; virtual ::android::binder::Status RepeatParcelables(const std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>& input, std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* repeated, std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* _aidl_return) = 0; virtual ::android::binder::Status Repeat2dBytes(const std::array, 2>& input, std::array, 2>* repeated, std::array, 2>* _aidl_return) = 0; virtual ::android::binder::Status Repeat2dInts(const std::array, 2>& input, std::array, 2>* repeated, std::array, 2>* _aidl_return) = 0; virtual ::android::binder::Status Repeat2dBinders(const std::array, 3>, 2>& input, std::array, 3>, 2>* repeated, std::array, 3>, 2>* _aidl_return) = 0; virtual ::android::binder::Status Repeat2dParcelables(const std::array, 2>& input, std::array, 2>* repeated, std::array, 2>* _aidl_return) = 0; }; // class IRepeatFixedSizeArray class IRepeatFixedSizeArrayDefault : public IRepeatFixedSizeArray { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status RepeatBytes(const std::array& /*input*/, std::array* /*repeated*/, std::array* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatInts(const std::array& /*input*/, std::array* /*repeated*/, std::array* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatBinders(const std::array<::android::sp<::android::IBinder>, 3>& /*input*/, std::array<::android::sp<::android::IBinder>, 3>* /*repeated*/, std::array<::android::sp<::android::IBinder>, 3>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatParcelables(const std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>& /*input*/, std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* /*repeated*/, std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status Repeat2dBytes(const std::array, 2>& /*input*/, std::array, 2>* /*repeated*/, std::array, 2>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status Repeat2dInts(const std::array, 2>& /*input*/, std::array, 2>* /*repeated*/, std::array, 2>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status Repeat2dBinders(const std::array, 3>, 2>& /*input*/, std::array, 3>, 2>* /*repeated*/, std::array, 3>, 2>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status Repeat2dParcelables(const std::array, 2>& /*input*/, std::array, 2>* /*repeated*/, std::array, 2>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } }; // class IRepeatFixedSizeArrayDefault class BpRepeatFixedSizeArray : public ::android::BpInterface { public: explicit BpRepeatFixedSizeArray(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpRepeatFixedSizeArray() = default; ::android::binder::Status RepeatBytes(const std::array& input, std::array* repeated, std::array* _aidl_return) override; ::android::binder::Status RepeatInts(const std::array& input, std::array* repeated, std::array* _aidl_return) override; ::android::binder::Status RepeatBinders(const std::array<::android::sp<::android::IBinder>, 3>& input, std::array<::android::sp<::android::IBinder>, 3>* repeated, std::array<::android::sp<::android::IBinder>, 3>* _aidl_return) override; ::android::binder::Status RepeatParcelables(const std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>& input, std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* repeated, std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* _aidl_return) override; ::android::binder::Status Repeat2dBytes(const std::array, 2>& input, std::array, 2>* repeated, std::array, 2>* _aidl_return) override; ::android::binder::Status Repeat2dInts(const std::array, 2>& input, std::array, 2>* repeated, std::array, 2>* _aidl_return) override; ::android::binder::Status Repeat2dBinders(const std::array, 3>, 2>& input, std::array, 3>, 2>* repeated, std::array, 3>, 2>* _aidl_return) override; ::android::binder::Status Repeat2dParcelables(const std::array, 2>& input, std::array, 2>* repeated, std::array, 2>* _aidl_return) override; }; // class BpRepeatFixedSizeArray class BnRepeatFixedSizeArray : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_RepeatBytes = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_RepeatInts = ::android::IBinder::FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_RepeatBinders = ::android::IBinder::FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_RepeatParcelables = ::android::IBinder::FIRST_CALL_TRANSACTION + 3; static constexpr uint32_t TRANSACTION_Repeat2dBytes = ::android::IBinder::FIRST_CALL_TRANSACTION + 4; static constexpr uint32_t TRANSACTION_Repeat2dInts = ::android::IBinder::FIRST_CALL_TRANSACTION + 5; static constexpr uint32_t TRANSACTION_Repeat2dBinders = ::android::IBinder::FIRST_CALL_TRANSACTION + 6; static constexpr uint32_t TRANSACTION_Repeat2dParcelables = ::android::IBinder::FIRST_CALL_TRANSACTION + 7; explicit BnRepeatFixedSizeArray(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnRepeatFixedSizeArray class IRepeatFixedSizeArrayDelegator : public BnRepeatFixedSizeArray { public: explicit IRepeatFixedSizeArrayDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status RepeatBytes(const std::array& input, std::array* repeated, std::array* _aidl_return) override { return _aidl_delegate->RepeatBytes(input, repeated, _aidl_return); } ::android::binder::Status RepeatInts(const std::array& input, std::array* repeated, std::array* _aidl_return) override { return _aidl_delegate->RepeatInts(input, repeated, _aidl_return); } ::android::binder::Status RepeatBinders(const std::array<::android::sp<::android::IBinder>, 3>& input, std::array<::android::sp<::android::IBinder>, 3>* repeated, std::array<::android::sp<::android::IBinder>, 3>* _aidl_return) override { return _aidl_delegate->RepeatBinders(input, repeated, _aidl_return); } ::android::binder::Status RepeatParcelables(const std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>& input, std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* repeated, std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* _aidl_return) override { return _aidl_delegate->RepeatParcelables(input, repeated, _aidl_return); } ::android::binder::Status Repeat2dBytes(const std::array, 2>& input, std::array, 2>* repeated, std::array, 2>* _aidl_return) override { return _aidl_delegate->Repeat2dBytes(input, repeated, _aidl_return); } ::android::binder::Status Repeat2dInts(const std::array, 2>& input, std::array, 2>* repeated, std::array, 2>* _aidl_return) override { return _aidl_delegate->Repeat2dInts(input, repeated, _aidl_return); } ::android::binder::Status Repeat2dBinders(const std::array, 3>, 2>& input, std::array, 3>, 2>* repeated, std::array, 3>, 2>* _aidl_return) override { return _aidl_delegate->Repeat2dBinders(input, repeated, _aidl_return); } ::android::binder::Status Repeat2dParcelables(const std::array, 2>& input, std::array, 2>* repeated, std::array, 2>* _aidl_return) override { return _aidl_delegate->Repeat2dParcelables(input, repeated, _aidl_return); } private: ::android::sp _aidl_delegate; }; // class IRepeatFixedSizeArrayDelegator enum class ByteEnum : int8_t { A = 0, }; enum class IntEnum : int32_t { A = 0, }; enum class LongEnum : int64_t { A = 0L, }; class IEmptyInterfaceDelegator; class IEmptyInterface : public ::android::IInterface { public: typedef IEmptyInterfaceDelegator DefaultDelegator; DECLARE_META_INTERFACE(EmptyInterface) }; // class IEmptyInterface class IEmptyInterfaceDefault : public IEmptyInterface { public: ::android::IBinder* onAsBinder() override { return nullptr; } }; // class IEmptyInterfaceDefault class BpEmptyInterface : public ::android::BpInterface { public: explicit BpEmptyInterface(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpEmptyInterface() = default; }; // class BpEmptyInterface class BnEmptyInterface : public ::android::BnInterface { public: explicit BnEmptyInterface(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnEmptyInterface class IEmptyInterfaceDelegator : public BnEmptyInterface { public: explicit IEmptyInterfaceDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } private: ::android::sp _aidl_delegate; }; // class IEmptyInterfaceDelegator std::array, 2> int2x3 = {{{{1, 2, 3}}, {{4, 5, 6}}}}; std::array boolArray = {{}}; std::array byteArray = {{}}; std::array charArray = {{}}; std::array intArray = {{}}; std::array longArray = {{}}; std::array floatArray = {{}}; std::array doubleArray = {{}}; std::array<::std::string, 2> stringArray = {{"hello", "world"}}; std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::ByteEnum, 2> byteEnumArray = {{}}; std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntEnum, 2> intEnumArray = {{}}; std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::LongEnum, 2> longEnumArray = {{}}; std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 2> parcelableArray = {{}}; std::array, 2> boolMatrix = {{}}; std::array, 2> byteMatrix = {{}}; std::array, 2> charMatrix = {{}}; std::array, 2> intMatrix = {{}}; std::array, 2> longMatrix = {{}}; std::array, 2> floatMatrix = {{}}; std::array, 2> doubleMatrix = {{}}; std::array, 2> stringMatrix = {{{{"hello", "world"}}, {{"Ciao", "mondo"}}}}; std::array, 2> byteEnumMatrix = {{}}; std::array, 2> intEnumMatrix = {{}}; std::array, 2> longEnumMatrix = {{}}; std::array, 2> parcelableMatrix = {{}}; ::std::optional> boolNullableArray; ::std::optional> byteNullableArray; ::std::optional> charNullableArray; ::std::optional> intNullableArray; ::std::optional> longNullableArray; ::std::optional> floatNullableArray; ::std::optional> doubleNullableArray; ::std::optional, 2>> stringNullableArray = {{{"hello", "world"}}}; ::std::optional> byteEnumNullableArray; ::std::optional> intEnumNullableArray; ::std::optional> longEnumNullableArray; ::std::optional, 2>> binderNullableArray; ::std::optional, 2>> pfdNullableArray; ::std::optional, 2>> parcelableNullableArray; ::std::optional, 2>> interfaceNullableArray; ::std::optional, 2>> boolNullableMatrix; ::std::optional, 2>> byteNullableMatrix; ::std::optional, 2>> charNullableMatrix; ::std::optional, 2>> intNullableMatrix; ::std::optional, 2>> longNullableMatrix; ::std::optional, 2>> floatNullableMatrix; ::std::optional, 2>> doubleNullableMatrix; ::std::optional, 2>, 2>> stringNullableMatrix = {{{{{"hello", "world"}}, {{"Ciao", "mondo"}}}}}; ::std::optional, 2>> byteEnumNullableMatrix; ::std::optional, 2>> intEnumNullableMatrix; ::std::optional, 2>> longEnumNullableMatrix; ::std::optional, 2>, 2>> binderNullableMatrix; ::std::optional, 2>, 2>> pfdNullableMatrix; ::std::optional, 2>, 2>> parcelableNullableMatrix; ::std::optional, 2>, 2>> interfaceNullableMatrix; inline bool operator==(const FixedSizeArrayExample& _rhs) const { return std::tie(int2x3, boolArray, byteArray, charArray, intArray, longArray, floatArray, doubleArray, stringArray, byteEnumArray, intEnumArray, longEnumArray, parcelableArray, boolMatrix, byteMatrix, charMatrix, intMatrix, longMatrix, floatMatrix, doubleMatrix, stringMatrix, byteEnumMatrix, intEnumMatrix, longEnumMatrix, parcelableMatrix, boolNullableArray, byteNullableArray, charNullableArray, intNullableArray, longNullableArray, floatNullableArray, doubleNullableArray, stringNullableArray, byteEnumNullableArray, intEnumNullableArray, longEnumNullableArray, binderNullableArray, pfdNullableArray, parcelableNullableArray, interfaceNullableArray, boolNullableMatrix, byteNullableMatrix, charNullableMatrix, intNullableMatrix, longNullableMatrix, floatNullableMatrix, doubleNullableMatrix, stringNullableMatrix, byteEnumNullableMatrix, intEnumNullableMatrix, longEnumNullableMatrix, binderNullableMatrix, pfdNullableMatrix, parcelableNullableMatrix, interfaceNullableMatrix) == std::tie(_rhs.int2x3, _rhs.boolArray, _rhs.byteArray, _rhs.charArray, _rhs.intArray, _rhs.longArray, _rhs.floatArray, _rhs.doubleArray, _rhs.stringArray, _rhs.byteEnumArray, _rhs.intEnumArray, _rhs.longEnumArray, _rhs.parcelableArray, _rhs.boolMatrix, _rhs.byteMatrix, _rhs.charMatrix, _rhs.intMatrix, _rhs.longMatrix, _rhs.floatMatrix, _rhs.doubleMatrix, _rhs.stringMatrix, _rhs.byteEnumMatrix, _rhs.intEnumMatrix, _rhs.longEnumMatrix, _rhs.parcelableMatrix, _rhs.boolNullableArray, _rhs.byteNullableArray, _rhs.charNullableArray, _rhs.intNullableArray, _rhs.longNullableArray, _rhs.floatNullableArray, _rhs.doubleNullableArray, _rhs.stringNullableArray, _rhs.byteEnumNullableArray, _rhs.intEnumNullableArray, _rhs.longEnumNullableArray, _rhs.binderNullableArray, _rhs.pfdNullableArray, _rhs.parcelableNullableArray, _rhs.interfaceNullableArray, _rhs.boolNullableMatrix, _rhs.byteNullableMatrix, _rhs.charNullableMatrix, _rhs.intNullableMatrix, _rhs.longNullableMatrix, _rhs.floatNullableMatrix, _rhs.doubleNullableMatrix, _rhs.stringNullableMatrix, _rhs.byteEnumNullableMatrix, _rhs.intEnumNullableMatrix, _rhs.longEnumNullableMatrix, _rhs.binderNullableMatrix, _rhs.pfdNullableMatrix, _rhs.parcelableNullableMatrix, _rhs.interfaceNullableMatrix); } inline bool operator<(const FixedSizeArrayExample& _rhs) const { return std::tie(int2x3, boolArray, byteArray, charArray, intArray, longArray, floatArray, doubleArray, stringArray, byteEnumArray, intEnumArray, longEnumArray, parcelableArray, boolMatrix, byteMatrix, charMatrix, intMatrix, longMatrix, floatMatrix, doubleMatrix, stringMatrix, byteEnumMatrix, intEnumMatrix, longEnumMatrix, parcelableMatrix, boolNullableArray, byteNullableArray, charNullableArray, intNullableArray, longNullableArray, floatNullableArray, doubleNullableArray, stringNullableArray, byteEnumNullableArray, intEnumNullableArray, longEnumNullableArray, binderNullableArray, pfdNullableArray, parcelableNullableArray, interfaceNullableArray, boolNullableMatrix, byteNullableMatrix, charNullableMatrix, intNullableMatrix, longNullableMatrix, floatNullableMatrix, doubleNullableMatrix, stringNullableMatrix, byteEnumNullableMatrix, intEnumNullableMatrix, longEnumNullableMatrix, binderNullableMatrix, pfdNullableMatrix, parcelableNullableMatrix, interfaceNullableMatrix) < std::tie(_rhs.int2x3, _rhs.boolArray, _rhs.byteArray, _rhs.charArray, _rhs.intArray, _rhs.longArray, _rhs.floatArray, _rhs.doubleArray, _rhs.stringArray, _rhs.byteEnumArray, _rhs.intEnumArray, _rhs.longEnumArray, _rhs.parcelableArray, _rhs.boolMatrix, _rhs.byteMatrix, _rhs.charMatrix, _rhs.intMatrix, _rhs.longMatrix, _rhs.floatMatrix, _rhs.doubleMatrix, _rhs.stringMatrix, _rhs.byteEnumMatrix, _rhs.intEnumMatrix, _rhs.longEnumMatrix, _rhs.parcelableMatrix, _rhs.boolNullableArray, _rhs.byteNullableArray, _rhs.charNullableArray, _rhs.intNullableArray, _rhs.longNullableArray, _rhs.floatNullableArray, _rhs.doubleNullableArray, _rhs.stringNullableArray, _rhs.byteEnumNullableArray, _rhs.intEnumNullableArray, _rhs.longEnumNullableArray, _rhs.binderNullableArray, _rhs.pfdNullableArray, _rhs.parcelableNullableArray, _rhs.interfaceNullableArray, _rhs.boolNullableMatrix, _rhs.byteNullableMatrix, _rhs.charNullableMatrix, _rhs.intNullableMatrix, _rhs.longNullableMatrix, _rhs.floatNullableMatrix, _rhs.doubleNullableMatrix, _rhs.stringNullableMatrix, _rhs.byteEnumNullableMatrix, _rhs.intEnumNullableMatrix, _rhs.longEnumNullableMatrix, _rhs.binderNullableMatrix, _rhs.pfdNullableMatrix, _rhs.parcelableNullableMatrix, _rhs.interfaceNullableMatrix); } inline bool operator!=(const FixedSizeArrayExample& _rhs) const { return !(*this == _rhs); } inline bool operator>(const FixedSizeArrayExample& _rhs) const { return _rhs < *this; } inline bool operator>=(const FixedSizeArrayExample& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const FixedSizeArrayExample& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.fixedsizearray.FixedSizeArrayExample"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "FixedSizeArrayExample{"; _aidl_os << "int2x3: " << ::android::internal::ToString(int2x3); _aidl_os << ", boolArray: " << ::android::internal::ToString(boolArray); _aidl_os << ", byteArray: " << ::android::internal::ToString(byteArray); _aidl_os << ", charArray: " << ::android::internal::ToString(charArray); _aidl_os << ", intArray: " << ::android::internal::ToString(intArray); _aidl_os << ", longArray: " << ::android::internal::ToString(longArray); _aidl_os << ", floatArray: " << ::android::internal::ToString(floatArray); _aidl_os << ", doubleArray: " << ::android::internal::ToString(doubleArray); _aidl_os << ", stringArray: " << ::android::internal::ToString(stringArray); _aidl_os << ", byteEnumArray: " << ::android::internal::ToString(byteEnumArray); _aidl_os << ", intEnumArray: " << ::android::internal::ToString(intEnumArray); _aidl_os << ", longEnumArray: " << ::android::internal::ToString(longEnumArray); _aidl_os << ", parcelableArray: " << ::android::internal::ToString(parcelableArray); _aidl_os << ", boolMatrix: " << ::android::internal::ToString(boolMatrix); _aidl_os << ", byteMatrix: " << ::android::internal::ToString(byteMatrix); _aidl_os << ", charMatrix: " << ::android::internal::ToString(charMatrix); _aidl_os << ", intMatrix: " << ::android::internal::ToString(intMatrix); _aidl_os << ", longMatrix: " << ::android::internal::ToString(longMatrix); _aidl_os << ", floatMatrix: " << ::android::internal::ToString(floatMatrix); _aidl_os << ", doubleMatrix: " << ::android::internal::ToString(doubleMatrix); _aidl_os << ", stringMatrix: " << ::android::internal::ToString(stringMatrix); _aidl_os << ", byteEnumMatrix: " << ::android::internal::ToString(byteEnumMatrix); _aidl_os << ", intEnumMatrix: " << ::android::internal::ToString(intEnumMatrix); _aidl_os << ", longEnumMatrix: " << ::android::internal::ToString(longEnumMatrix); _aidl_os << ", parcelableMatrix: " << ::android::internal::ToString(parcelableMatrix); _aidl_os << ", boolNullableArray: " << ::android::internal::ToString(boolNullableArray); _aidl_os << ", byteNullableArray: " << ::android::internal::ToString(byteNullableArray); _aidl_os << ", charNullableArray: " << ::android::internal::ToString(charNullableArray); _aidl_os << ", intNullableArray: " << ::android::internal::ToString(intNullableArray); _aidl_os << ", longNullableArray: " << ::android::internal::ToString(longNullableArray); _aidl_os << ", floatNullableArray: " << ::android::internal::ToString(floatNullableArray); _aidl_os << ", doubleNullableArray: " << ::android::internal::ToString(doubleNullableArray); _aidl_os << ", stringNullableArray: " << ::android::internal::ToString(stringNullableArray); _aidl_os << ", byteEnumNullableArray: " << ::android::internal::ToString(byteEnumNullableArray); _aidl_os << ", intEnumNullableArray: " << ::android::internal::ToString(intEnumNullableArray); _aidl_os << ", longEnumNullableArray: " << ::android::internal::ToString(longEnumNullableArray); _aidl_os << ", binderNullableArray: " << ::android::internal::ToString(binderNullableArray); _aidl_os << ", pfdNullableArray: " << ::android::internal::ToString(pfdNullableArray); _aidl_os << ", parcelableNullableArray: " << ::android::internal::ToString(parcelableNullableArray); _aidl_os << ", interfaceNullableArray: " << ::android::internal::ToString(interfaceNullableArray); _aidl_os << ", boolNullableMatrix: " << ::android::internal::ToString(boolNullableMatrix); _aidl_os << ", byteNullableMatrix: " << ::android::internal::ToString(byteNullableMatrix); _aidl_os << ", charNullableMatrix: " << ::android::internal::ToString(charNullableMatrix); _aidl_os << ", intNullableMatrix: " << ::android::internal::ToString(intNullableMatrix); _aidl_os << ", longNullableMatrix: " << ::android::internal::ToString(longNullableMatrix); _aidl_os << ", floatNullableMatrix: " << ::android::internal::ToString(floatNullableMatrix); _aidl_os << ", doubleNullableMatrix: " << ::android::internal::ToString(doubleNullableMatrix); _aidl_os << ", stringNullableMatrix: " << ::android::internal::ToString(stringNullableMatrix); _aidl_os << ", byteEnumNullableMatrix: " << ::android::internal::ToString(byteEnumNullableMatrix); _aidl_os << ", intEnumNullableMatrix: " << ::android::internal::ToString(intEnumNullableMatrix); _aidl_os << ", longEnumNullableMatrix: " << ::android::internal::ToString(longEnumNullableMatrix); _aidl_os << ", binderNullableMatrix: " << ::android::internal::ToString(binderNullableMatrix); _aidl_os << ", pfdNullableMatrix: " << ::android::internal::ToString(pfdNullableMatrix); _aidl_os << ", parcelableNullableMatrix: " << ::android::internal::ToString(parcelableNullableMatrix); _aidl_os << ", interfaceNullableMatrix: " << ::android::internal::ToString(interfaceNullableMatrix); _aidl_os << "}"; return _aidl_os.str(); } }; // class FixedSizeArrayExample } // namespace fixedsizearray } // namespace aidl } // namespace android namespace android { namespace aidl { namespace fixedsizearray { [[nodiscard]] static inline std::string toString(FixedSizeArrayExample::ByteEnum val) { switch(val) { case FixedSizeArrayExample::ByteEnum::A: return "A"; default: return std::to_string(static_cast(val)); } } } // namespace fixedsizearray } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::ByteEnum, 1> enum_values<::android::aidl::fixedsizearray::FixedSizeArrayExample::ByteEnum> = { ::android::aidl::fixedsizearray::FixedSizeArrayExample::ByteEnum::A, }; #pragma clang diagnostic pop } // namespace internal } // namespace android namespace android { namespace aidl { namespace fixedsizearray { [[nodiscard]] static inline std::string toString(FixedSizeArrayExample::IntEnum val) { switch(val) { case FixedSizeArrayExample::IntEnum::A: return "A"; default: return std::to_string(static_cast(val)); } } } // namespace fixedsizearray } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntEnum, 1> enum_values<::android::aidl::fixedsizearray::FixedSizeArrayExample::IntEnum> = { ::android::aidl::fixedsizearray::FixedSizeArrayExample::IntEnum::A, }; #pragma clang diagnostic pop } // namespace internal } // namespace android namespace android { namespace aidl { namespace fixedsizearray { [[nodiscard]] static inline std::string toString(FixedSizeArrayExample::LongEnum val) { switch(val) { case FixedSizeArrayExample::LongEnum::A: return "A"; default: return std::to_string(static_cast(val)); } } } // namespace fixedsizearray } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::fixedsizearray::FixedSizeArrayExample::LongEnum, 1> enum_values<::android::aidl::fixedsizearray::FixedSizeArrayExample::LongEnum> = { ::android::aidl::fixedsizearray::FixedSizeArrayExample::LongEnum::A, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-cpp-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 031703 xustar000000000 0000000 28 mtime=1776853188.5610000 tests/golden_output/frozen/aidl-test-fixedsizearray-cpp-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 026615 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-java-source_0100644 0000000 0000000 00000000034 15172120304 027265 xustar000000000 0000000 28 mtime=1776853188.5630000 tests/golden_output/frozen/aidl-test-fixedsizearray-java-source/0040755 0000000 0000000 00000000000 15172120304 024272 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-java-source_gen_0100644 0000000 0000000 00000000034 15172120304 030116 xustar000000000 0000000 28 mtime=1776853188.5630000 tests/golden_output/frozen/aidl-test-fixedsizearray-java-source/gen/0040755 0000000 0000000 00000000000 15172120304 025043 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-java-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 031616 xustar000000000 0000000 28 mtime=1776853188.5630000 tests/golden_output/frozen/aidl-test-fixedsizearray-java-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 026463 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-java-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 032607 xustar000000000 0000000 28 mtime=1776853188.5640000 tests/golden_output/frozen/aidl-test-fixedsizearray-java-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 027374 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-java-source_gen_android_aidl_fix0100644 0000000 0000000 00000000034 15172120304 033316 xustar000000000 0000000 28 mtime=1776853188.5640000 tests/golden_output/frozen/aidl-test-fixedsizearray-java-source/gen/android/aidl/fixedsizearray/0040755 0000000 0000000 00000000000 15172120304 032425 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-java-source_gen_android_aidl_fix0100644 0000000 0000000 00000000240 15172120304 033315 xustar000000000 0000000 132 path=tests/golden_output/frozen/aidl-test-fixedsizearray-java-source/gen/android/aidl/fixedsizearray/FixedSizeArrayExample.java 28 mtime=1776853188.5640000 tests/golden_output/frozen/aidl-test-fixedsizearray-java-source/gen/android/aidl/fixedsizearray/Fixe0100644 0000000 0000000 00000140660 15172120304 033247 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-java-source/gen/android/aidl/fixedsizearray/FixedSizeArrayExample.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/fixedsizearray/FixedSizeArrayExample.aidl */ package android.aidl.fixedsizearray; public class FixedSizeArrayExample implements android.os.Parcelable { // to see if NxM array works public int[][] int2x3 = {{1, 2, 3}, {4, 5, 6}}; public boolean[] boolArray; public byte[] byteArray; public char[] charArray; public int[] intArray; public long[] longArray; public float[] floatArray; public double[] doubleArray; public java.lang.String[] stringArray = {"hello", "world"}; public byte[] byteEnumArray; public int[] intEnumArray; public long[] longEnumArray; public android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[] parcelableArray; // Following fields are not test-friendly because they should be initialized as non-null. // IBinder[2] binderArray; // ParcelFileDescriptor[2] pfdArray; // IEmptyInterface[2] interfaceArray; public boolean[][] boolMatrix; public byte[][] byteMatrix; public char[][] charMatrix; public int[][] intMatrix; public long[][] longMatrix; public float[][] floatMatrix; public double[][] doubleMatrix; public java.lang.String[][] stringMatrix = {{"hello", "world"}, {"Ciao", "mondo"}}; public byte[][] byteEnumMatrix; public int[][] intEnumMatrix; public long[][] longEnumMatrix; public android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][] parcelableMatrix; // Following fields are not test-friendly because they should be initialized as non-null. // ParcelFileDescriptor[2][2] pfdMatrix; // IBinder[2][2] binderMatrix; // IEmptyInterface[2][2] interfaceMatrix; public boolean[] boolNullableArray; public byte[] byteNullableArray; public char[] charNullableArray; public int[] intNullableArray; public long[] longNullableArray; public float[] floatNullableArray; public double[] doubleNullableArray; public java.lang.String[] stringNullableArray = {"hello", "world"}; public byte[] byteEnumNullableArray; public int[] intEnumNullableArray; public long[] longEnumNullableArray; public android.os.IBinder[] binderNullableArray; public android.os.ParcelFileDescriptor[] pfdNullableArray; public android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[] parcelableNullableArray; public android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface[] interfaceNullableArray; public boolean[][] boolNullableMatrix; public byte[][] byteNullableMatrix; public char[][] charNullableMatrix; public int[][] intNullableMatrix; public long[][] longNullableMatrix; public float[][] floatNullableMatrix; public double[][] doubleNullableMatrix; public java.lang.String[][] stringNullableMatrix = {{"hello", "world"}, {"Ciao", "mondo"}}; public byte[][] byteEnumNullableMatrix; public int[][] intEnumNullableMatrix; public long[][] longEnumNullableMatrix; public android.os.IBinder[][] binderNullableMatrix; public android.os.ParcelFileDescriptor[][] pfdNullableMatrix; public android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][] parcelableNullableMatrix; public android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface[][] interfaceNullableMatrix; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public FixedSizeArrayExample createFromParcel(android.os.Parcel _aidl_source) { FixedSizeArrayExample _aidl_out = new FixedSizeArrayExample(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public FixedSizeArrayExample[] newArray(int _aidl_size) { return new FixedSizeArrayExample[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeFixedArray(int2x3, _aidl_flag, 2, 3); _aidl_parcel.writeFixedArray(boolArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(byteArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(charArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(intArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(longArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(floatArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(doubleArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(stringArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(byteEnumArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(intEnumArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(longEnumArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(parcelableArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(boolMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(byteMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(charMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(intMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(longMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(floatMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(doubleMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(stringMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(byteEnumMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(intEnumMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(longEnumMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(parcelableMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(boolNullableArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(byteNullableArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(charNullableArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(intNullableArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(longNullableArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(floatNullableArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(doubleNullableArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(stringNullableArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(byteEnumNullableArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(intEnumNullableArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(longEnumNullableArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(binderNullableArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(pfdNullableArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(parcelableNullableArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(interfaceNullableArray, _aidl_flag, 2); _aidl_parcel.writeFixedArray(boolNullableMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(byteNullableMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(charNullableMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(intNullableMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(longNullableMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(floatNullableMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(doubleNullableMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(stringNullableMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(byteEnumNullableMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(intEnumNullableMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(longEnumNullableMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(binderNullableMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(pfdNullableMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(parcelableNullableMatrix, _aidl_flag, 2, 2); _aidl_parcel.writeFixedArray(interfaceNullableMatrix, _aidl_flag, 2, 2); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; int2x3 = _aidl_parcel.createFixedArray(int[][].class, 2, 3); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; boolArray = _aidl_parcel.createFixedArray(boolean[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; byteArray = _aidl_parcel.createFixedArray(byte[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; charArray = _aidl_parcel.createFixedArray(char[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; intArray = _aidl_parcel.createFixedArray(int[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; longArray = _aidl_parcel.createFixedArray(long[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; floatArray = _aidl_parcel.createFixedArray(float[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; doubleArray = _aidl_parcel.createFixedArray(double[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; stringArray = _aidl_parcel.createFixedArray(java.lang.String[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; byteEnumArray = _aidl_parcel.createFixedArray(byte[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; intEnumArray = _aidl_parcel.createFixedArray(int[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; longEnumArray = _aidl_parcel.createFixedArray(long[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; parcelableArray = _aidl_parcel.createFixedArray(android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[].class, android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable.CREATOR, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; boolMatrix = _aidl_parcel.createFixedArray(boolean[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; byteMatrix = _aidl_parcel.createFixedArray(byte[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; charMatrix = _aidl_parcel.createFixedArray(char[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; intMatrix = _aidl_parcel.createFixedArray(int[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; longMatrix = _aidl_parcel.createFixedArray(long[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; floatMatrix = _aidl_parcel.createFixedArray(float[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; doubleMatrix = _aidl_parcel.createFixedArray(double[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; stringMatrix = _aidl_parcel.createFixedArray(java.lang.String[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; byteEnumMatrix = _aidl_parcel.createFixedArray(byte[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; intEnumMatrix = _aidl_parcel.createFixedArray(int[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; longEnumMatrix = _aidl_parcel.createFixedArray(long[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; parcelableMatrix = _aidl_parcel.createFixedArray(android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][].class, android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable.CREATOR, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; boolNullableArray = _aidl_parcel.createFixedArray(boolean[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; byteNullableArray = _aidl_parcel.createFixedArray(byte[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; charNullableArray = _aidl_parcel.createFixedArray(char[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; intNullableArray = _aidl_parcel.createFixedArray(int[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; longNullableArray = _aidl_parcel.createFixedArray(long[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; floatNullableArray = _aidl_parcel.createFixedArray(float[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; doubleNullableArray = _aidl_parcel.createFixedArray(double[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; stringNullableArray = _aidl_parcel.createFixedArray(java.lang.String[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; byteEnumNullableArray = _aidl_parcel.createFixedArray(byte[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; intEnumNullableArray = _aidl_parcel.createFixedArray(int[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; longEnumNullableArray = _aidl_parcel.createFixedArray(long[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; binderNullableArray = _aidl_parcel.createFixedArray(android.os.IBinder[].class, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; pfdNullableArray = _aidl_parcel.createFixedArray(android.os.ParcelFileDescriptor[].class, android.os.ParcelFileDescriptor.CREATOR, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; parcelableNullableArray = _aidl_parcel.createFixedArray(android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[].class, android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable.CREATOR, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; interfaceNullableArray = _aidl_parcel.createFixedArray(android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface[].class, android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface.Stub::asInterface, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; boolNullableMatrix = _aidl_parcel.createFixedArray(boolean[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; byteNullableMatrix = _aidl_parcel.createFixedArray(byte[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; charNullableMatrix = _aidl_parcel.createFixedArray(char[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; intNullableMatrix = _aidl_parcel.createFixedArray(int[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; longNullableMatrix = _aidl_parcel.createFixedArray(long[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; floatNullableMatrix = _aidl_parcel.createFixedArray(float[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; doubleNullableMatrix = _aidl_parcel.createFixedArray(double[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; stringNullableMatrix = _aidl_parcel.createFixedArray(java.lang.String[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; byteEnumNullableMatrix = _aidl_parcel.createFixedArray(byte[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; intEnumNullableMatrix = _aidl_parcel.createFixedArray(int[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; longEnumNullableMatrix = _aidl_parcel.createFixedArray(long[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; binderNullableMatrix = _aidl_parcel.createFixedArray(android.os.IBinder[][].class, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; pfdNullableMatrix = _aidl_parcel.createFixedArray(android.os.ParcelFileDescriptor[][].class, android.os.ParcelFileDescriptor.CREATOR, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; parcelableNullableMatrix = _aidl_parcel.createFixedArray(android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][].class, android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable.CREATOR, 2, 2); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; interfaceNullableMatrix = _aidl_parcel.createFixedArray(android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface[][].class, android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface.Stub::asInterface, 2, 2); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public String toString() { java.util.StringJoiner _aidl_sj = new java.util.StringJoiner(", ", "{", "}"); _aidl_sj.add("int2x3: " + (java.util.Arrays.deepToString(int2x3))); _aidl_sj.add("boolArray: " + (java.util.Arrays.toString(boolArray))); _aidl_sj.add("byteArray: " + (java.util.Arrays.toString(byteArray))); _aidl_sj.add("charArray: " + (java.util.Arrays.toString(charArray))); _aidl_sj.add("intArray: " + (java.util.Arrays.toString(intArray))); _aidl_sj.add("longArray: " + (java.util.Arrays.toString(longArray))); _aidl_sj.add("floatArray: " + (java.util.Arrays.toString(floatArray))); _aidl_sj.add("doubleArray: " + (java.util.Arrays.toString(doubleArray))); _aidl_sj.add("stringArray: " + (java.util.Arrays.toString(stringArray))); _aidl_sj.add("byteEnumArray: " + (java.util.Arrays.toString(byteEnumArray))); _aidl_sj.add("intEnumArray: " + (java.util.Arrays.toString(intEnumArray))); _aidl_sj.add("longEnumArray: " + (java.util.Arrays.toString(longEnumArray))); _aidl_sj.add("parcelableArray: " + (java.util.Arrays.toString(parcelableArray))); _aidl_sj.add("boolMatrix: " + (java.util.Arrays.deepToString(boolMatrix))); _aidl_sj.add("byteMatrix: " + (java.util.Arrays.deepToString(byteMatrix))); _aidl_sj.add("charMatrix: " + (java.util.Arrays.deepToString(charMatrix))); _aidl_sj.add("intMatrix: " + (java.util.Arrays.deepToString(intMatrix))); _aidl_sj.add("longMatrix: " + (java.util.Arrays.deepToString(longMatrix))); _aidl_sj.add("floatMatrix: " + (java.util.Arrays.deepToString(floatMatrix))); _aidl_sj.add("doubleMatrix: " + (java.util.Arrays.deepToString(doubleMatrix))); _aidl_sj.add("stringMatrix: " + (java.util.Arrays.deepToString(stringMatrix))); _aidl_sj.add("byteEnumMatrix: " + (java.util.Arrays.deepToString(byteEnumMatrix))); _aidl_sj.add("intEnumMatrix: " + (java.util.Arrays.deepToString(intEnumMatrix))); _aidl_sj.add("longEnumMatrix: " + (java.util.Arrays.deepToString(longEnumMatrix))); _aidl_sj.add("parcelableMatrix: " + (java.util.Arrays.deepToString(parcelableMatrix))); _aidl_sj.add("boolNullableArray: " + (java.util.Arrays.toString(boolNullableArray))); _aidl_sj.add("byteNullableArray: " + (java.util.Arrays.toString(byteNullableArray))); _aidl_sj.add("charNullableArray: " + (java.util.Arrays.toString(charNullableArray))); _aidl_sj.add("intNullableArray: " + (java.util.Arrays.toString(intNullableArray))); _aidl_sj.add("longNullableArray: " + (java.util.Arrays.toString(longNullableArray))); _aidl_sj.add("floatNullableArray: " + (java.util.Arrays.toString(floatNullableArray))); _aidl_sj.add("doubleNullableArray: " + (java.util.Arrays.toString(doubleNullableArray))); _aidl_sj.add("stringNullableArray: " + (java.util.Arrays.toString(stringNullableArray))); _aidl_sj.add("byteEnumNullableArray: " + (java.util.Arrays.toString(byteEnumNullableArray))); _aidl_sj.add("intEnumNullableArray: " + (java.util.Arrays.toString(intEnumNullableArray))); _aidl_sj.add("longEnumNullableArray: " + (java.util.Arrays.toString(longEnumNullableArray))); _aidl_sj.add("binderNullableArray: " + (java.util.Arrays.toString(binderNullableArray))); _aidl_sj.add("pfdNullableArray: " + (java.util.Arrays.toString(pfdNullableArray))); _aidl_sj.add("parcelableNullableArray: " + (java.util.Arrays.toString(parcelableNullableArray))); _aidl_sj.add("interfaceNullableArray: " + (java.util.Arrays.toString(interfaceNullableArray))); _aidl_sj.add("boolNullableMatrix: " + (java.util.Arrays.deepToString(boolNullableMatrix))); _aidl_sj.add("byteNullableMatrix: " + (java.util.Arrays.deepToString(byteNullableMatrix))); _aidl_sj.add("charNullableMatrix: " + (java.util.Arrays.deepToString(charNullableMatrix))); _aidl_sj.add("intNullableMatrix: " + (java.util.Arrays.deepToString(intNullableMatrix))); _aidl_sj.add("longNullableMatrix: " + (java.util.Arrays.deepToString(longNullableMatrix))); _aidl_sj.add("floatNullableMatrix: " + (java.util.Arrays.deepToString(floatNullableMatrix))); _aidl_sj.add("doubleNullableMatrix: " + (java.util.Arrays.deepToString(doubleNullableMatrix))); _aidl_sj.add("stringNullableMatrix: " + (java.util.Arrays.deepToString(stringNullableMatrix))); _aidl_sj.add("byteEnumNullableMatrix: " + (java.util.Arrays.deepToString(byteEnumNullableMatrix))); _aidl_sj.add("intEnumNullableMatrix: " + (java.util.Arrays.deepToString(intEnumNullableMatrix))); _aidl_sj.add("longEnumNullableMatrix: " + (java.util.Arrays.deepToString(longEnumNullableMatrix))); _aidl_sj.add("binderNullableMatrix: " + (java.util.Arrays.deepToString(binderNullableMatrix))); _aidl_sj.add("pfdNullableMatrix: " + (java.util.Arrays.deepToString(pfdNullableMatrix))); _aidl_sj.add("parcelableNullableMatrix: " + (java.util.Arrays.deepToString(parcelableNullableMatrix))); _aidl_sj.add("interfaceNullableMatrix: " + (java.util.Arrays.deepToString(interfaceNullableMatrix))); return "FixedSizeArrayExample" + _aidl_sj.toString() ; } @Override public int describeContents() { int _mask = 0; _mask |= describeContents(parcelableArray); _mask |= describeContents(parcelableMatrix); _mask |= describeContents(pfdNullableArray); _mask |= describeContents(parcelableNullableArray); _mask |= describeContents(pfdNullableMatrix); _mask |= describeContents(parcelableNullableMatrix); return _mask; } private int describeContents(Object _v) { if (_v == null) return 0; if (_v instanceof Object[]) { int _mask = 0; for (Object o : (Object[]) _v) { _mask |= describeContents(o); } return _mask; } if (_v instanceof android.os.Parcelable) { return ((android.os.Parcelable) _v).describeContents(); } return 0; } public interface IRepeatFixedSizeArray extends android.os.IInterface { /** Default implementation for IRepeatFixedSizeArray. */ public static class Default implements android.aidl.fixedsizearray.FixedSizeArrayExample.IRepeatFixedSizeArray { @Override public byte[] RepeatBytes(byte[] input, byte[] repeated) throws android.os.RemoteException { return null; } @Override public int[] RepeatInts(int[] input, int[] repeated) throws android.os.RemoteException { return null; } @Override public android.os.IBinder[] RepeatBinders(android.os.IBinder[] input, android.os.IBinder[] repeated) throws android.os.RemoteException { return null; } @Override public android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[] RepeatParcelables(android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[] input, android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[] repeated) throws android.os.RemoteException { return null; } @Override public byte[][] Repeat2dBytes(byte[][] input, byte[][] repeated) throws android.os.RemoteException { return null; } @Override public int[][] Repeat2dInts(int[][] input, int[][] repeated) throws android.os.RemoteException { return null; } @Override public android.os.IBinder[][] Repeat2dBinders(android.os.IBinder[][] input, android.os.IBinder[][] repeated) throws android.os.RemoteException { return null; } @Override public android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][] Repeat2dParcelables(android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][] input, android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][] repeated) throws android.os.RemoteException { return null; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.fixedsizearray.FixedSizeArrayExample.IRepeatFixedSizeArray { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.fixedsizearray.FixedSizeArrayExample.IRepeatFixedSizeArray interface, * generating a proxy if needed. */ public static android.aidl.fixedsizearray.FixedSizeArrayExample.IRepeatFixedSizeArray asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.fixedsizearray.FixedSizeArrayExample.IRepeatFixedSizeArray))) { return ((android.aidl.fixedsizearray.FixedSizeArrayExample.IRepeatFixedSizeArray)iin); } return new android.aidl.fixedsizearray.FixedSizeArrayExample.IRepeatFixedSizeArray.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_RepeatBytes: { byte[] _arg0; _arg0 = data.createFixedArray(byte[].class, 3); byte[] _arg1; _arg1 = new byte[3]; data.enforceNoDataAvail(); byte[] _result = this.RepeatBytes(_arg0, _arg1); reply.writeNoException(); reply.writeFixedArray(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE, 3); reply.writeFixedArray(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE, 3); break; } case TRANSACTION_RepeatInts: { int[] _arg0; _arg0 = data.createFixedArray(int[].class, 3); int[] _arg1; _arg1 = new int[3]; data.enforceNoDataAvail(); int[] _result = this.RepeatInts(_arg0, _arg1); reply.writeNoException(); reply.writeFixedArray(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE, 3); reply.writeFixedArray(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE, 3); break; } case TRANSACTION_RepeatBinders: { android.os.IBinder[] _arg0; _arg0 = data.createFixedArray(android.os.IBinder[].class, 3); android.os.IBinder[] _arg1; _arg1 = new android.os.IBinder[3]; data.enforceNoDataAvail(); android.os.IBinder[] _result = this.RepeatBinders(_arg0, _arg1); reply.writeNoException(); reply.writeFixedArray(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE, 3); reply.writeFixedArray(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE, 3); break; } case TRANSACTION_RepeatParcelables: { android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[] _arg0; _arg0 = data.createFixedArray(android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[].class, android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable.CREATOR, 3); android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[] _arg1; _arg1 = new android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[3]; data.enforceNoDataAvail(); android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[] _result = this.RepeatParcelables(_arg0, _arg1); reply.writeNoException(); reply.writeFixedArray(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE, 3); reply.writeFixedArray(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE, 3); break; } case TRANSACTION_Repeat2dBytes: { byte[][] _arg0; _arg0 = data.createFixedArray(byte[][].class, 2, 3); byte[][] _arg1; _arg1 = new byte[2][3]; data.enforceNoDataAvail(); byte[][] _result = this.Repeat2dBytes(_arg0, _arg1); reply.writeNoException(); reply.writeFixedArray(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE, 2, 3); reply.writeFixedArray(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE, 2, 3); break; } case TRANSACTION_Repeat2dInts: { int[][] _arg0; _arg0 = data.createFixedArray(int[][].class, 2, 3); int[][] _arg1; _arg1 = new int[2][3]; data.enforceNoDataAvail(); int[][] _result = this.Repeat2dInts(_arg0, _arg1); reply.writeNoException(); reply.writeFixedArray(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE, 2, 3); reply.writeFixedArray(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE, 2, 3); break; } case TRANSACTION_Repeat2dBinders: { android.os.IBinder[][] _arg0; _arg0 = data.createFixedArray(android.os.IBinder[][].class, 2, 3); android.os.IBinder[][] _arg1; _arg1 = new android.os.IBinder[2][3]; data.enforceNoDataAvail(); android.os.IBinder[][] _result = this.Repeat2dBinders(_arg0, _arg1); reply.writeNoException(); reply.writeFixedArray(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE, 2, 3); reply.writeFixedArray(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE, 2, 3); break; } case TRANSACTION_Repeat2dParcelables: { android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][] _arg0; _arg0 = data.createFixedArray(android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][].class, android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable.CREATOR, 2, 3); android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][] _arg1; _arg1 = new android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[2][3]; data.enforceNoDataAvail(); android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][] _result = this.Repeat2dParcelables(_arg0, _arg1); reply.writeNoException(); reply.writeFixedArray(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE, 2, 3); reply.writeFixedArray(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE, 2, 3); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.fixedsizearray.FixedSizeArrayExample.IRepeatFixedSizeArray { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public byte[] RepeatBytes(byte[] input, byte[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); byte[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeFixedArray(input, 0, 3); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatBytes, _data, _reply, 0); _reply.readException(); _result = _reply.createFixedArray(byte[].class, 3); _reply.readFixedArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int[] RepeatInts(int[] input, int[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); int[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeFixedArray(input, 0, 3); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatInts, _data, _reply, 0); _reply.readException(); _result = _reply.createFixedArray(int[].class, 3); _reply.readFixedArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.os.IBinder[] RepeatBinders(android.os.IBinder[] input, android.os.IBinder[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.os.IBinder[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeFixedArray(input, 0, 3); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatBinders, _data, _reply, 0); _reply.readException(); _result = _reply.createFixedArray(android.os.IBinder[].class, 3); _reply.readFixedArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[] RepeatParcelables(android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[] input, android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeFixedArray(input, 0, 3); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatParcelables, _data, _reply, 0); _reply.readException(); _result = _reply.createFixedArray(android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[].class, android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable.CREATOR, 3); _reply.readFixedArray(repeated, android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public byte[][] Repeat2dBytes(byte[][] input, byte[][] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); byte[][] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeFixedArray(input, 0, 2, 3); boolean _status = mRemote.transact(Stub.TRANSACTION_Repeat2dBytes, _data, _reply, 0); _reply.readException(); _result = _reply.createFixedArray(byte[][].class, 2, 3); _reply.readFixedArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int[][] Repeat2dInts(int[][] input, int[][] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); int[][] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeFixedArray(input, 0, 2, 3); boolean _status = mRemote.transact(Stub.TRANSACTION_Repeat2dInts, _data, _reply, 0); _reply.readException(); _result = _reply.createFixedArray(int[][].class, 2, 3); _reply.readFixedArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.os.IBinder[][] Repeat2dBinders(android.os.IBinder[][] input, android.os.IBinder[][] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.os.IBinder[][] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeFixedArray(input, 0, 2, 3); boolean _status = mRemote.transact(Stub.TRANSACTION_Repeat2dBinders, _data, _reply, 0); _reply.readException(); _result = _reply.createFixedArray(android.os.IBinder[][].class, 2, 3); _reply.readFixedArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][] Repeat2dParcelables(android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][] input, android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeFixedArray(input, 0, 2, 3); boolean _status = mRemote.transact(Stub.TRANSACTION_Repeat2dParcelables, _data, _reply, 0); _reply.readException(); _result = _reply.createFixedArray(android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][].class, android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable.CREATOR, 2, 3); _reply.readFixedArray(repeated, android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } } static final int TRANSACTION_RepeatBytes = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); static final int TRANSACTION_RepeatInts = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1); static final int TRANSACTION_RepeatBinders = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2); static final int TRANSACTION_RepeatParcelables = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3); static final int TRANSACTION_Repeat2dBytes = (android.os.IBinder.FIRST_CALL_TRANSACTION + 4); static final int TRANSACTION_Repeat2dInts = (android.os.IBinder.FIRST_CALL_TRANSACTION + 5); static final int TRANSACTION_Repeat2dBinders = (android.os.IBinder.FIRST_CALL_TRANSACTION + 6); static final int TRANSACTION_Repeat2dParcelables = (android.os.IBinder.FIRST_CALL_TRANSACTION + 7); } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.fixedsizearray.FixedSizeArrayExample.IRepeatFixedSizeArray"; public byte[] RepeatBytes(byte[] input, byte[] repeated) throws android.os.RemoteException; public int[] RepeatInts(int[] input, int[] repeated) throws android.os.RemoteException; public android.os.IBinder[] RepeatBinders(android.os.IBinder[] input, android.os.IBinder[] repeated) throws android.os.RemoteException; public android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[] RepeatParcelables(android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[] input, android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[] repeated) throws android.os.RemoteException; public byte[][] Repeat2dBytes(byte[][] input, byte[][] repeated) throws android.os.RemoteException; public int[][] Repeat2dInts(int[][] input, int[][] repeated) throws android.os.RemoteException; public android.os.IBinder[][] Repeat2dBinders(android.os.IBinder[][] input, android.os.IBinder[][] repeated) throws android.os.RemoteException; public android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][] Repeat2dParcelables(android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][] input, android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable[][] repeated) throws android.os.RemoteException; } public static @interface ByteEnum { public static final byte A = 0; } public static @interface IntEnum { public static final int A = 0; } public static @interface LongEnum { public static final long A = 0L; } public static class IntParcelable implements android.os.Parcelable { public int value = 0; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public IntParcelable createFromParcel(android.os.Parcel _aidl_source) { IntParcelable _aidl_out = new IntParcelable(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public IntParcelable[] newArray(int _aidl_size) { return new IntParcelable[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(value); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; value = _aidl_parcel.readInt(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public boolean equals(Object other) { if (this == other) return true; if (other == null) return false; if (!(other instanceof IntParcelable)) return false; IntParcelable that = (IntParcelable)other; if (!java.util.Objects.deepEquals(value, that.value)) return false; return true; } @Override public int hashCode() { return java.util.Arrays.deepHashCode(java.util.Arrays.asList(value).toArray()); } @Override public int describeContents() { int _mask = 0; return _mask; } } public interface IEmptyInterface extends android.os.IInterface { /** Default implementation for IEmptyInterface. */ public static class Default implements android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface { @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface interface, * generating a proxy if needed. */ public static android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface))) { return ((android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface)iin); } return new android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { default: { return super.onTransact(code, data, reply, flags); } } } private static class Proxy implements android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface"; } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-java-source_gen_android_aidl_fix0100644 0000000 0000000 00000000242 15172120304 033317 xustar000000000 0000000 134 path=tests/golden_output/frozen/aidl-test-fixedsizearray-java-source/gen/android/aidl/fixedsizearray/FixedSizeArrayExample.java.d 28 mtime=1776853188.5650000 tests/golden_output/frozen/aidl-test-fixedsizearray-java-source/gen/android/aidl/fixedsizearray/Fixe0100644 0000000 0000000 00000000340 15172120304 033235 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-java-source/gen/android/aidl/fixedsizearray/FixedSizeArrayExample.java : \ system/tools/aidl/tests/android/aidl/fixedsizearray/FixedSizeArrayExample.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-java-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 032042 xustar000000000 0000000 28 mtime=1776853188.5650000 tests/golden_output/frozen/aidl-test-fixedsizearray-java-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 026754 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-ndk-source_0100644 0000000 0000000 00000000034 15172120304 027120 xustar000000000 0000000 28 mtime=1776853188.5650000 tests/golden_output/frozen/aidl-test-fixedsizearray-ndk-source/0040755 0000000 0000000 00000000000 15172120304 024125 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-ndk-source_gen_0100644 0000000 0000000 00000000034 15172120304 027751 xustar000000000 0000000 28 mtime=1776853188.5650000 tests/golden_output/frozen/aidl-test-fixedsizearray-ndk-source/gen/0040755 0000000 0000000 00000000000 15172120304 024676 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-ndk-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 031451 xustar000000000 0000000 28 mtime=1776853188.5650000 tests/golden_output/frozen/aidl-test-fixedsizearray-ndk-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 026316 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-ndk-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 032442 xustar000000000 0000000 28 mtime=1776853188.5660000 tests/golden_output/frozen/aidl-test-fixedsizearray-ndk-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 027227 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-ndk-source_gen_android_aidl_fixe0100644 0000000 0000000 00000000034 15172120304 033316 xustar000000000 0000000 28 mtime=1776853188.5660000 tests/golden_output/frozen/aidl-test-fixedsizearray-ndk-source/gen/android/aidl/fixedsizearray/0040755 0000000 0000000 00000000000 15172120304 032260 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-ndk-source_gen_android_aidl_fixe0100644 0000000 0000000 00000000236 15172120304 033322 xustar000000000 0000000 130 path=tests/golden_output/frozen/aidl-test-fixedsizearray-ndk-source/gen/android/aidl/fixedsizearray/FixedSizeArrayExample.cpp 28 mtime=1776853188.5660000 tests/golden_output/frozen/aidl-test-fixedsizearray-ndk-source/gen/android/aidl/fixedsizearray/Fixed0100644 0000000 0000000 00000202147 15172120304 033245 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-ndk-source/gen/staging/android/aidl/fixedsizearray/FixedSizeArrayExample.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/fixedsizearray/FixedSizeArrayExample.aidl */ #include "aidl/android/aidl/fixedsizearray/FixedSizeArrayExample.h" #include namespace aidl { namespace android { namespace aidl { namespace fixedsizearray { const char* FixedSizeArrayExample::descriptor = "android.aidl.fixedsizearray.FixedSizeArrayExample"; binder_status_t FixedSizeArrayExample::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &int2x3); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &boolArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &byteArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &charArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &intArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &longArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &floatArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &doubleArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &stringArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &byteEnumArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &intEnumArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &longEnumArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &parcelableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &boolMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &byteMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &charMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &intMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &longMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &floatMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &doubleMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &stringMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &byteEnumMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &intEnumMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &longEnumMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &parcelableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &boolNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &byteNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &charNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &intNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &longNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &floatNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &doubleNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &stringNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &byteEnumNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &intEnumNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &longEnumNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &binderNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &pfdNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &parcelableNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &interfaceNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &boolNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &byteNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &charNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &intNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &longNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &floatNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &doubleNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &stringNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &byteEnumNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &intEnumNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &longEnumNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &binderNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &pfdNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &parcelableNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &interfaceNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t FixedSizeArrayExample::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, int2x3); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, boolArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, byteArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, charArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, intArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, longArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, floatArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, doubleArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, stringArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, byteEnumArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, intEnumArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, longEnumArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, parcelableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, boolMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, byteMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, charMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, intMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, longMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, floatMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, doubleMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, stringMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, byteEnumMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, intEnumMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, longEnumMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, parcelableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, boolNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, byteNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, charNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, intNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, longNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, floatNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, doubleNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, stringNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, byteEnumNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, intEnumNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, longEnumNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, binderNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, pfdNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, parcelableNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, interfaceNullableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, boolNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, byteNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, charNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, intNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, longNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, floatNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, doubleNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, stringNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, byteEnumNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, intEnumNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, longEnumNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, binderNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, pfdNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, parcelableNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, interfaceNullableMatrix); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace fixedsizearray } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace fixedsizearray { static binder_status_t _aidl_android_aidl_fixedsizearray_FixedSizeArrayExample_IRepeatFixedSizeArray_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*RepeatBytes*/): { std::array in_input; std::array out_repeated; std::array _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatBytes(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 1 /*RepeatInts*/): { std::array in_input; std::array out_repeated; std::array _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatInts(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 2 /*RepeatBinders*/): { std::array<::ndk::SpAIBinder, 3> in_input; std::array<::ndk::SpAIBinder, 3> out_repeated; std::array<::ndk::SpAIBinder, 3> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatBinders(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 3 /*RepeatParcelables*/): { std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3> in_input; std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3> out_repeated; std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatParcelables(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 4 /*Repeat2dBytes*/): { std::array, 2> in_input; std::array, 2> out_repeated; std::array, 2> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->Repeat2dBytes(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 5 /*Repeat2dInts*/): { std::array, 2> in_input; std::array, 2> out_repeated; std::array, 2> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->Repeat2dInts(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 6 /*Repeat2dBinders*/): { std::array, 2> in_input; std::array, 2> out_repeated; std::array, 2> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->Repeat2dBinders(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 7 /*Repeat2dParcelables*/): { std::array, 2> in_input; std::array, 2> out_repeated; std::array, 2> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->Repeat2dParcelables(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_fixedsizearray_FixedSizeArrayExample_IRepeatFixedSizeArray_clazz = ::ndk::ICInterface::defineClass(FixedSizeArrayExample::IRepeatFixedSizeArray::descriptor, _aidl_android_aidl_fixedsizearray_FixedSizeArrayExample_IRepeatFixedSizeArray_onTransact); FixedSizeArrayExample::BpRepeatFixedSizeArray::BpRepeatFixedSizeArray(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} FixedSizeArrayExample::BpRepeatFixedSizeArray::~BpRepeatFixedSizeArray() {} ::ndk::ScopedAStatus FixedSizeArrayExample::BpRepeatFixedSizeArray::RepeatBytes(const std::array& in_input, std::array* out_repeated, std::array* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*RepeatBytes*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl()) { _aidl_status = IRepeatFixedSizeArray::getDefaultImpl()->RepeatBytes(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus FixedSizeArrayExample::BpRepeatFixedSizeArray::RepeatInts(const std::array& in_input, std::array* out_repeated, std::array* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 1 /*RepeatInts*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl()) { _aidl_status = IRepeatFixedSizeArray::getDefaultImpl()->RepeatInts(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus FixedSizeArrayExample::BpRepeatFixedSizeArray::RepeatBinders(const std::array<::ndk::SpAIBinder, 3>& in_input, std::array<::ndk::SpAIBinder, 3>* out_repeated, std::array<::ndk::SpAIBinder, 3>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 2 /*RepeatBinders*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl()) { _aidl_status = IRepeatFixedSizeArray::getDefaultImpl()->RepeatBinders(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus FixedSizeArrayExample::BpRepeatFixedSizeArray::RepeatParcelables(const std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>& in_input, std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* out_repeated, std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 3 /*RepeatParcelables*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl()) { _aidl_status = IRepeatFixedSizeArray::getDefaultImpl()->RepeatParcelables(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus FixedSizeArrayExample::BpRepeatFixedSizeArray::Repeat2dBytes(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 4 /*Repeat2dBytes*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl()) { _aidl_status = IRepeatFixedSizeArray::getDefaultImpl()->Repeat2dBytes(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus FixedSizeArrayExample::BpRepeatFixedSizeArray::Repeat2dInts(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 5 /*Repeat2dInts*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl()) { _aidl_status = IRepeatFixedSizeArray::getDefaultImpl()->Repeat2dInts(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus FixedSizeArrayExample::BpRepeatFixedSizeArray::Repeat2dBinders(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 6 /*Repeat2dBinders*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl()) { _aidl_status = IRepeatFixedSizeArray::getDefaultImpl()->Repeat2dBinders(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus FixedSizeArrayExample::BpRepeatFixedSizeArray::Repeat2dParcelables(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 7 /*Repeat2dParcelables*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IRepeatFixedSizeArray::getDefaultImpl()) { _aidl_status = IRepeatFixedSizeArray::getDefaultImpl()->Repeat2dParcelables(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } // Source for BnRepeatFixedSizeArray FixedSizeArrayExample::BnRepeatFixedSizeArray::BnRepeatFixedSizeArray() {} FixedSizeArrayExample::BnRepeatFixedSizeArray::~BnRepeatFixedSizeArray() {} ::ndk::SpAIBinder FixedSizeArrayExample::BnRepeatFixedSizeArray::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_fixedsizearray_FixedSizeArrayExample_IRepeatFixedSizeArray_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for IRepeatFixedSizeArray const char* FixedSizeArrayExample::IRepeatFixedSizeArray::descriptor = "android.aidl.fixedsizearray.FixedSizeArrayExample.IRepeatFixedSizeArray"; FixedSizeArrayExample::IRepeatFixedSizeArray::IRepeatFixedSizeArray() {} FixedSizeArrayExample::IRepeatFixedSizeArray::~IRepeatFixedSizeArray() {} std::shared_ptr FixedSizeArrayExample::IRepeatFixedSizeArray::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_fixedsizearray_FixedSizeArrayExample_IRepeatFixedSizeArray_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t FixedSizeArrayExample::IRepeatFixedSizeArray::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t FixedSizeArrayExample::IRepeatFixedSizeArray::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = IRepeatFixedSizeArray::fromBinder(binder); return STATUS_OK; } bool FixedSizeArrayExample::IRepeatFixedSizeArray::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!IRepeatFixedSizeArray::default_impl); if (impl) { IRepeatFixedSizeArray::default_impl = impl; return true; } return false; } const std::shared_ptr& FixedSizeArrayExample::IRepeatFixedSizeArray::getDefaultImpl() { return IRepeatFixedSizeArray::default_impl; } std::shared_ptr FixedSizeArrayExample::IRepeatFixedSizeArray::default_impl = nullptr; ::ndk::ScopedAStatus FixedSizeArrayExample::IRepeatFixedSizeArrayDefault::RepeatBytes(const std::array& /*in_input*/, std::array* /*out_repeated*/, std::array* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus FixedSizeArrayExample::IRepeatFixedSizeArrayDefault::RepeatInts(const std::array& /*in_input*/, std::array* /*out_repeated*/, std::array* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus FixedSizeArrayExample::IRepeatFixedSizeArrayDefault::RepeatBinders(const std::array<::ndk::SpAIBinder, 3>& /*in_input*/, std::array<::ndk::SpAIBinder, 3>* /*out_repeated*/, std::array<::ndk::SpAIBinder, 3>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus FixedSizeArrayExample::IRepeatFixedSizeArrayDefault::RepeatParcelables(const std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>& /*in_input*/, std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* /*out_repeated*/, std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus FixedSizeArrayExample::IRepeatFixedSizeArrayDefault::Repeat2dBytes(const std::array, 2>& /*in_input*/, std::array, 2>* /*out_repeated*/, std::array, 2>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus FixedSizeArrayExample::IRepeatFixedSizeArrayDefault::Repeat2dInts(const std::array, 2>& /*in_input*/, std::array, 2>* /*out_repeated*/, std::array, 2>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus FixedSizeArrayExample::IRepeatFixedSizeArrayDefault::Repeat2dBinders(const std::array, 2>& /*in_input*/, std::array, 2>* /*out_repeated*/, std::array, 2>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus FixedSizeArrayExample::IRepeatFixedSizeArrayDefault::Repeat2dParcelables(const std::array, 2>& /*in_input*/, std::array, 2>* /*out_repeated*/, std::array, 2>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::SpAIBinder FixedSizeArrayExample::IRepeatFixedSizeArrayDefault::asBinder() { return ::ndk::SpAIBinder(); } bool FixedSizeArrayExample::IRepeatFixedSizeArrayDefault::isRemote() { return false; } } // namespace fixedsizearray } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace fixedsizearray { const char* FixedSizeArrayExample::IntParcelable::descriptor = "android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable"; binder_status_t FixedSizeArrayExample::IntParcelable::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &value); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t FixedSizeArrayExample::IntParcelable::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, value); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace fixedsizearray } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace fixedsizearray { static binder_status_t _aidl_android_aidl_fixedsizearray_FixedSizeArrayExample_IEmptyInterface_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; (void)_aidl_binder; (void)_aidl_code; return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_fixedsizearray_FixedSizeArrayExample_IEmptyInterface_clazz = ::ndk::ICInterface::defineClass(FixedSizeArrayExample::IEmptyInterface::descriptor, _aidl_android_aidl_fixedsizearray_FixedSizeArrayExample_IEmptyInterface_onTransact); FixedSizeArrayExample::BpEmptyInterface::BpEmptyInterface(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} FixedSizeArrayExample::BpEmptyInterface::~BpEmptyInterface() {} // Source for BnEmptyInterface FixedSizeArrayExample::BnEmptyInterface::BnEmptyInterface() {} FixedSizeArrayExample::BnEmptyInterface::~BnEmptyInterface() {} ::ndk::SpAIBinder FixedSizeArrayExample::BnEmptyInterface::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_fixedsizearray_FixedSizeArrayExample_IEmptyInterface_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for IEmptyInterface const char* FixedSizeArrayExample::IEmptyInterface::descriptor = "android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface"; FixedSizeArrayExample::IEmptyInterface::IEmptyInterface() {} FixedSizeArrayExample::IEmptyInterface::~IEmptyInterface() {} std::shared_ptr FixedSizeArrayExample::IEmptyInterface::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_fixedsizearray_FixedSizeArrayExample_IEmptyInterface_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t FixedSizeArrayExample::IEmptyInterface::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t FixedSizeArrayExample::IEmptyInterface::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = IEmptyInterface::fromBinder(binder); return STATUS_OK; } bool FixedSizeArrayExample::IEmptyInterface::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!IEmptyInterface::default_impl); if (impl) { IEmptyInterface::default_impl = impl; return true; } return false; } const std::shared_ptr& FixedSizeArrayExample::IEmptyInterface::getDefaultImpl() { return IEmptyInterface::default_impl; } std::shared_ptr FixedSizeArrayExample::IEmptyInterface::default_impl = nullptr; ::ndk::SpAIBinder FixedSizeArrayExample::IEmptyInterfaceDefault::asBinder() { return ::ndk::SpAIBinder(); } bool FixedSizeArrayExample::IEmptyInterfaceDefault::isRemote() { return false; } } // namespace fixedsizearray } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-ndk-source_gen_android_aidl_fixe0100644 0000000 0000000 00000000240 15172120304 033315 xustar000000000 0000000 132 path=tests/golden_output/frozen/aidl-test-fixedsizearray-ndk-source/gen/android/aidl/fixedsizearray/FixedSizeArrayExample.cpp.d 28 mtime=1776853188.5670000 tests/golden_output/frozen/aidl-test-fixedsizearray-ndk-source/gen/android/aidl/fixedsizearray/Fixed0100644 0000000 0000000 00000000336 15172120304 033241 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-ndk-source/gen/android/aidl/fixedsizearray/FixedSizeArrayExample.cpp : \ system/tools/aidl/tests/android/aidl/fixedsizearray/FixedSizeArrayExample.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-ndk-source_gen_include_0100644 0000000 0000000 00000000034 15172120304 031454 xustar000000000 0000000 28 mtime=1776853188.5670000 tests/golden_output/frozen/aidl-test-fixedsizearray-ndk-source/gen/include/0040755 0000000 0000000 00000000000 15172120304 026321 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-ndk-source_gen_include_aidl_0100644 0000000 0000000 00000000034 15172120304 032445 xustar000000000 0000000 28 mtime=1776853188.5680000 tests/golden_output/frozen/aidl-test-fixedsizearray-ndk-source/gen/include/aidl/0040755 0000000 0000000 00000000000 15172120304 027232 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-ndk-source_gen_include_aidl_andr0100644 0000000 0000000 00000000034 15172120304 033312 xustar000000000 0000000 28 mtime=1776853188.5680000 tests/golden_output/frozen/aidl-test-fixedsizearray-ndk-source/gen/include/aidl/android/0040755 0000000 0000000 00000000000 15172120304 030652 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-ndk-source_gen_include_aidl_andr0100644 0000000 0000000 00000000034 15172120304 033312 xustar000000000 0000000 28 mtime=1776853188.5680000 tests/golden_output/frozen/aidl-test-fixedsizearray-ndk-source/gen/include/aidl/android/aidl/0040755 0000000 0000000 00000000000 15172120304 031563 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-ndk-source_gen_include_aidl_andr0100644 0000000 0000000 00000000222 15172120304 033311 xustar000000000 0000000 118 path=tests/golden_output/frozen/aidl-test-fixedsizearray-ndk-source/gen/include/aidl/android/aidl/fixedsizearray/ 28 mtime=1776853188.5680000 tests/golden_output/frozen/aidl-test-fixedsizearray-ndk-source/gen/include/aidl/android/aidl/fixedsi0040755 0000000 0000000 00000000000 15172120304 033137 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-ndk-source_gen_include_aidl_andr0100644 0000000 0000000 00000000253 15172120304 033315 xustar000000000 0000000 143 path=tests/golden_output/frozen/aidl-test-fixedsizearray-ndk-source/gen/include/aidl/android/aidl/fixedsizearray/BnFixedSizeArrayExample.h 28 mtime=1776853188.5700000 tests/golden_output/frozen/aidl-test-fixedsizearray-ndk-source/gen/include/aidl/android/aidl/fixedsi0100644 0000000 0000000 00000001273 15172120304 033141 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-ndk-source/gen/staging/android/aidl/fixedsizearray/FixedSizeArrayExample.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/fixedsizearray/FixedSizeArrayExample.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-ndk-source_gen_include_aidl_andr0100644 0000000 0000000 00000000253 15172120304 033315 xustar000000000 0000000 143 path=tests/golden_output/frozen/aidl-test-fixedsizearray-ndk-source/gen/include/aidl/android/aidl/fixedsizearray/BpFixedSizeArrayExample.h 28 mtime=1776853188.5700000 tests/golden_output/frozen/aidl-test-fixedsizearray-ndk-source/gen/include/aidl/android/aidl/fixedsi0100644 0000000 0000000 00000001273 15172120304 033141 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-ndk-source/gen/staging/android/aidl/fixedsizearray/FixedSizeArrayExample.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/fixedsizearray/FixedSizeArrayExample.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-ndk-source_gen_include_aidl_andr0100644 0000000 0000000 00000000251 15172120304 033313 xustar000000000 0000000 141 path=tests/golden_output/frozen/aidl-test-fixedsizearray-ndk-source/gen/include/aidl/android/aidl/fixedsizearray/FixedSizeArrayExample.h 28 mtime=1776853188.5700000 tests/golden_output/frozen/aidl-test-fixedsizearray-ndk-source/gen/include/aidl/android/aidl/fixedsi0100644 0000000 0000000 00000072535 15172120304 033152 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-ndk-source/gen/staging/android/aidl/fixedsizearray/FixedSizeArrayExample.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/fixedsizearray/FixedSizeArrayExample.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace fixedsizearray { class FixedSizeArrayExample { public: typedef std::false_type fixed_size; static const char* descriptor; class IntParcelable { public: typedef std::false_type fixed_size; static const char* descriptor; int32_t value = 0; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const IntParcelable& _rhs) const { return std::tie(value) == std::tie(_rhs.value); } inline bool operator<(const IntParcelable& _rhs) const { return std::tie(value) < std::tie(_rhs.value); } inline bool operator!=(const IntParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const IntParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const IntParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const IntParcelable& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "IntParcelable{"; _aidl_os << "value: " << ::android::internal::ToString(value); _aidl_os << "}"; return _aidl_os.str(); } }; class IRepeatFixedSizeArrayDelegator; class IRepeatFixedSizeArray : public ::ndk::ICInterface { public: typedef IRepeatFixedSizeArrayDelegator DefaultDelegator; static const char* descriptor; IRepeatFixedSizeArray(); virtual ~IRepeatFixedSizeArray(); static constexpr uint32_t TRANSACTION_RepeatBytes = FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_RepeatInts = FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_RepeatBinders = FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_RepeatParcelables = FIRST_CALL_TRANSACTION + 3; static constexpr uint32_t TRANSACTION_Repeat2dBytes = FIRST_CALL_TRANSACTION + 4; static constexpr uint32_t TRANSACTION_Repeat2dInts = FIRST_CALL_TRANSACTION + 5; static constexpr uint32_t TRANSACTION_Repeat2dBinders = FIRST_CALL_TRANSACTION + 6; static constexpr uint32_t TRANSACTION_Repeat2dParcelables = FIRST_CALL_TRANSACTION + 7; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus RepeatBytes(const std::array& in_input, std::array* out_repeated, std::array* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatInts(const std::array& in_input, std::array* out_repeated, std::array* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatBinders(const std::array<::ndk::SpAIBinder, 3>& in_input, std::array<::ndk::SpAIBinder, 3>* out_repeated, std::array<::ndk::SpAIBinder, 3>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatParcelables(const std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>& in_input, std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* out_repeated, std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus Repeat2dBytes(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus Repeat2dInts(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus Repeat2dBinders(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus Repeat2dParcelables(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) = 0; private: static std::shared_ptr default_impl; }; class IRepeatFixedSizeArrayDefault : public IRepeatFixedSizeArray { public: ::ndk::ScopedAStatus RepeatBytes(const std::array& in_input, std::array* out_repeated, std::array* _aidl_return) override; ::ndk::ScopedAStatus RepeatInts(const std::array& in_input, std::array* out_repeated, std::array* _aidl_return) override; ::ndk::ScopedAStatus RepeatBinders(const std::array<::ndk::SpAIBinder, 3>& in_input, std::array<::ndk::SpAIBinder, 3>* out_repeated, std::array<::ndk::SpAIBinder, 3>* _aidl_return) override; ::ndk::ScopedAStatus RepeatParcelables(const std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>& in_input, std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* out_repeated, std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* _aidl_return) override; ::ndk::ScopedAStatus Repeat2dBytes(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) override; ::ndk::ScopedAStatus Repeat2dInts(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) override; ::ndk::ScopedAStatus Repeat2dBinders(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) override; ::ndk::ScopedAStatus Repeat2dParcelables(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; class BpRepeatFixedSizeArray : public ::ndk::BpCInterface { public: explicit BpRepeatFixedSizeArray(const ::ndk::SpAIBinder& binder); virtual ~BpRepeatFixedSizeArray(); ::ndk::ScopedAStatus RepeatBytes(const std::array& in_input, std::array* out_repeated, std::array* _aidl_return) override; ::ndk::ScopedAStatus RepeatInts(const std::array& in_input, std::array* out_repeated, std::array* _aidl_return) override; ::ndk::ScopedAStatus RepeatBinders(const std::array<::ndk::SpAIBinder, 3>& in_input, std::array<::ndk::SpAIBinder, 3>* out_repeated, std::array<::ndk::SpAIBinder, 3>* _aidl_return) override; ::ndk::ScopedAStatus RepeatParcelables(const std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>& in_input, std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* out_repeated, std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 3>* _aidl_return) override; ::ndk::ScopedAStatus Repeat2dBytes(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) override; ::ndk::ScopedAStatus Repeat2dInts(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) override; ::ndk::ScopedAStatus Repeat2dBinders(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) override; ::ndk::ScopedAStatus Repeat2dParcelables(const std::array, 2>& in_input, std::array, 2>* out_repeated, std::array, 2>* _aidl_return) override; }; class BnRepeatFixedSizeArray : public ::ndk::BnCInterface { public: BnRepeatFixedSizeArray(); virtual ~BnRepeatFixedSizeArray(); protected: ::ndk::SpAIBinder createBinder() override; private: }; enum class ByteEnum : int8_t { A = 0, }; enum class IntEnum : int32_t { A = 0, }; enum class LongEnum : int64_t { A = 0L, }; class IEmptyInterfaceDelegator; class IEmptyInterface : public ::ndk::ICInterface { public: typedef IEmptyInterfaceDelegator DefaultDelegator; static const char* descriptor; IEmptyInterface(); virtual ~IEmptyInterface(); static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); private: static std::shared_ptr default_impl; }; class IEmptyInterfaceDefault : public IEmptyInterface { public: ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; class BpEmptyInterface : public ::ndk::BpCInterface { public: explicit BpEmptyInterface(const ::ndk::SpAIBinder& binder); virtual ~BpEmptyInterface(); }; class BnEmptyInterface : public ::ndk::BnCInterface { public: BnEmptyInterface(); virtual ~BnEmptyInterface(); protected: ::ndk::SpAIBinder createBinder() override; private: }; std::array, 2> int2x3 = {{{{1, 2, 3}}, {{4, 5, 6}}}}; std::array boolArray = {{}}; std::array byteArray = {{}}; std::array charArray = {{}}; std::array intArray = {{}}; std::array longArray = {{}}; std::array floatArray = {{}}; std::array doubleArray = {{}}; std::array stringArray = {{"hello", "world"}}; std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::ByteEnum, 2> byteEnumArray = {{}}; std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntEnum, 2> intEnumArray = {{}}; std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::LongEnum, 2> longEnumArray = {{}}; std::array<::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntParcelable, 2> parcelableArray = {{}}; std::array, 2> boolMatrix = {{}}; std::array, 2> byteMatrix = {{}}; std::array, 2> charMatrix = {{}}; std::array, 2> intMatrix = {{}}; std::array, 2> longMatrix = {{}}; std::array, 2> floatMatrix = {{}}; std::array, 2> doubleMatrix = {{}}; std::array, 2> stringMatrix = {{{{"hello", "world"}}, {{"Ciao", "mondo"}}}}; std::array, 2> byteEnumMatrix = {{}}; std::array, 2> intEnumMatrix = {{}}; std::array, 2> longEnumMatrix = {{}}; std::array, 2> parcelableMatrix = {{}}; std::optional> boolNullableArray; std::optional> byteNullableArray; std::optional> charNullableArray; std::optional> intNullableArray; std::optional> longNullableArray; std::optional> floatNullableArray; std::optional> doubleNullableArray; std::optional, 2>> stringNullableArray = {{{"hello", "world"}}}; std::optional> byteEnumNullableArray; std::optional> intEnumNullableArray; std::optional> longEnumNullableArray; std::optional> binderNullableArray; std::optional> pfdNullableArray; std::optional, 2>> parcelableNullableArray; std::optional, 2>> interfaceNullableArray; std::optional, 2>> boolNullableMatrix; std::optional, 2>> byteNullableMatrix; std::optional, 2>> charNullableMatrix; std::optional, 2>> intNullableMatrix; std::optional, 2>> longNullableMatrix; std::optional, 2>> floatNullableMatrix; std::optional, 2>> doubleNullableMatrix; std::optional, 2>, 2>> stringNullableMatrix = {{{{{"hello", "world"}}, {{"Ciao", "mondo"}}}}}; std::optional, 2>> byteEnumNullableMatrix; std::optional, 2>> intEnumNullableMatrix; std::optional, 2>> longEnumNullableMatrix; std::optional, 2>> binderNullableMatrix; std::optional, 2>> pfdNullableMatrix; std::optional, 2>, 2>> parcelableNullableMatrix; std::optional, 2>, 2>> interfaceNullableMatrix; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const FixedSizeArrayExample& _rhs) const { return std::tie(int2x3, boolArray, byteArray, charArray, intArray, longArray, floatArray, doubleArray, stringArray, byteEnumArray, intEnumArray, longEnumArray, parcelableArray, boolMatrix, byteMatrix, charMatrix, intMatrix, longMatrix, floatMatrix, doubleMatrix, stringMatrix, byteEnumMatrix, intEnumMatrix, longEnumMatrix, parcelableMatrix, boolNullableArray, byteNullableArray, charNullableArray, intNullableArray, longNullableArray, floatNullableArray, doubleNullableArray, stringNullableArray, byteEnumNullableArray, intEnumNullableArray, longEnumNullableArray, binderNullableArray, pfdNullableArray, parcelableNullableArray, interfaceNullableArray, boolNullableMatrix, byteNullableMatrix, charNullableMatrix, intNullableMatrix, longNullableMatrix, floatNullableMatrix, doubleNullableMatrix, stringNullableMatrix, byteEnumNullableMatrix, intEnumNullableMatrix, longEnumNullableMatrix, binderNullableMatrix, pfdNullableMatrix, parcelableNullableMatrix, interfaceNullableMatrix) == std::tie(_rhs.int2x3, _rhs.boolArray, _rhs.byteArray, _rhs.charArray, _rhs.intArray, _rhs.longArray, _rhs.floatArray, _rhs.doubleArray, _rhs.stringArray, _rhs.byteEnumArray, _rhs.intEnumArray, _rhs.longEnumArray, _rhs.parcelableArray, _rhs.boolMatrix, _rhs.byteMatrix, _rhs.charMatrix, _rhs.intMatrix, _rhs.longMatrix, _rhs.floatMatrix, _rhs.doubleMatrix, _rhs.stringMatrix, _rhs.byteEnumMatrix, _rhs.intEnumMatrix, _rhs.longEnumMatrix, _rhs.parcelableMatrix, _rhs.boolNullableArray, _rhs.byteNullableArray, _rhs.charNullableArray, _rhs.intNullableArray, _rhs.longNullableArray, _rhs.floatNullableArray, _rhs.doubleNullableArray, _rhs.stringNullableArray, _rhs.byteEnumNullableArray, _rhs.intEnumNullableArray, _rhs.longEnumNullableArray, _rhs.binderNullableArray, _rhs.pfdNullableArray, _rhs.parcelableNullableArray, _rhs.interfaceNullableArray, _rhs.boolNullableMatrix, _rhs.byteNullableMatrix, _rhs.charNullableMatrix, _rhs.intNullableMatrix, _rhs.longNullableMatrix, _rhs.floatNullableMatrix, _rhs.doubleNullableMatrix, _rhs.stringNullableMatrix, _rhs.byteEnumNullableMatrix, _rhs.intEnumNullableMatrix, _rhs.longEnumNullableMatrix, _rhs.binderNullableMatrix, _rhs.pfdNullableMatrix, _rhs.parcelableNullableMatrix, _rhs.interfaceNullableMatrix); } inline bool operator<(const FixedSizeArrayExample& _rhs) const { return std::tie(int2x3, boolArray, byteArray, charArray, intArray, longArray, floatArray, doubleArray, stringArray, byteEnumArray, intEnumArray, longEnumArray, parcelableArray, boolMatrix, byteMatrix, charMatrix, intMatrix, longMatrix, floatMatrix, doubleMatrix, stringMatrix, byteEnumMatrix, intEnumMatrix, longEnumMatrix, parcelableMatrix, boolNullableArray, byteNullableArray, charNullableArray, intNullableArray, longNullableArray, floatNullableArray, doubleNullableArray, stringNullableArray, byteEnumNullableArray, intEnumNullableArray, longEnumNullableArray, binderNullableArray, pfdNullableArray, parcelableNullableArray, interfaceNullableArray, boolNullableMatrix, byteNullableMatrix, charNullableMatrix, intNullableMatrix, longNullableMatrix, floatNullableMatrix, doubleNullableMatrix, stringNullableMatrix, byteEnumNullableMatrix, intEnumNullableMatrix, longEnumNullableMatrix, binderNullableMatrix, pfdNullableMatrix, parcelableNullableMatrix, interfaceNullableMatrix) < std::tie(_rhs.int2x3, _rhs.boolArray, _rhs.byteArray, _rhs.charArray, _rhs.intArray, _rhs.longArray, _rhs.floatArray, _rhs.doubleArray, _rhs.stringArray, _rhs.byteEnumArray, _rhs.intEnumArray, _rhs.longEnumArray, _rhs.parcelableArray, _rhs.boolMatrix, _rhs.byteMatrix, _rhs.charMatrix, _rhs.intMatrix, _rhs.longMatrix, _rhs.floatMatrix, _rhs.doubleMatrix, _rhs.stringMatrix, _rhs.byteEnumMatrix, _rhs.intEnumMatrix, _rhs.longEnumMatrix, _rhs.parcelableMatrix, _rhs.boolNullableArray, _rhs.byteNullableArray, _rhs.charNullableArray, _rhs.intNullableArray, _rhs.longNullableArray, _rhs.floatNullableArray, _rhs.doubleNullableArray, _rhs.stringNullableArray, _rhs.byteEnumNullableArray, _rhs.intEnumNullableArray, _rhs.longEnumNullableArray, _rhs.binderNullableArray, _rhs.pfdNullableArray, _rhs.parcelableNullableArray, _rhs.interfaceNullableArray, _rhs.boolNullableMatrix, _rhs.byteNullableMatrix, _rhs.charNullableMatrix, _rhs.intNullableMatrix, _rhs.longNullableMatrix, _rhs.floatNullableMatrix, _rhs.doubleNullableMatrix, _rhs.stringNullableMatrix, _rhs.byteEnumNullableMatrix, _rhs.intEnumNullableMatrix, _rhs.longEnumNullableMatrix, _rhs.binderNullableMatrix, _rhs.pfdNullableMatrix, _rhs.parcelableNullableMatrix, _rhs.interfaceNullableMatrix); } inline bool operator!=(const FixedSizeArrayExample& _rhs) const { return !(*this == _rhs); } inline bool operator>(const FixedSizeArrayExample& _rhs) const { return _rhs < *this; } inline bool operator>=(const FixedSizeArrayExample& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const FixedSizeArrayExample& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "FixedSizeArrayExample{"; _aidl_os << "int2x3: " << ::android::internal::ToString(int2x3); _aidl_os << ", boolArray: " << ::android::internal::ToString(boolArray); _aidl_os << ", byteArray: " << ::android::internal::ToString(byteArray); _aidl_os << ", charArray: " << ::android::internal::ToString(charArray); _aidl_os << ", intArray: " << ::android::internal::ToString(intArray); _aidl_os << ", longArray: " << ::android::internal::ToString(longArray); _aidl_os << ", floatArray: " << ::android::internal::ToString(floatArray); _aidl_os << ", doubleArray: " << ::android::internal::ToString(doubleArray); _aidl_os << ", stringArray: " << ::android::internal::ToString(stringArray); _aidl_os << ", byteEnumArray: " << ::android::internal::ToString(byteEnumArray); _aidl_os << ", intEnumArray: " << ::android::internal::ToString(intEnumArray); _aidl_os << ", longEnumArray: " << ::android::internal::ToString(longEnumArray); _aidl_os << ", parcelableArray: " << ::android::internal::ToString(parcelableArray); _aidl_os << ", boolMatrix: " << ::android::internal::ToString(boolMatrix); _aidl_os << ", byteMatrix: " << ::android::internal::ToString(byteMatrix); _aidl_os << ", charMatrix: " << ::android::internal::ToString(charMatrix); _aidl_os << ", intMatrix: " << ::android::internal::ToString(intMatrix); _aidl_os << ", longMatrix: " << ::android::internal::ToString(longMatrix); _aidl_os << ", floatMatrix: " << ::android::internal::ToString(floatMatrix); _aidl_os << ", doubleMatrix: " << ::android::internal::ToString(doubleMatrix); _aidl_os << ", stringMatrix: " << ::android::internal::ToString(stringMatrix); _aidl_os << ", byteEnumMatrix: " << ::android::internal::ToString(byteEnumMatrix); _aidl_os << ", intEnumMatrix: " << ::android::internal::ToString(intEnumMatrix); _aidl_os << ", longEnumMatrix: " << ::android::internal::ToString(longEnumMatrix); _aidl_os << ", parcelableMatrix: " << ::android::internal::ToString(parcelableMatrix); _aidl_os << ", boolNullableArray: " << ::android::internal::ToString(boolNullableArray); _aidl_os << ", byteNullableArray: " << ::android::internal::ToString(byteNullableArray); _aidl_os << ", charNullableArray: " << ::android::internal::ToString(charNullableArray); _aidl_os << ", intNullableArray: " << ::android::internal::ToString(intNullableArray); _aidl_os << ", longNullableArray: " << ::android::internal::ToString(longNullableArray); _aidl_os << ", floatNullableArray: " << ::android::internal::ToString(floatNullableArray); _aidl_os << ", doubleNullableArray: " << ::android::internal::ToString(doubleNullableArray); _aidl_os << ", stringNullableArray: " << ::android::internal::ToString(stringNullableArray); _aidl_os << ", byteEnumNullableArray: " << ::android::internal::ToString(byteEnumNullableArray); _aidl_os << ", intEnumNullableArray: " << ::android::internal::ToString(intEnumNullableArray); _aidl_os << ", longEnumNullableArray: " << ::android::internal::ToString(longEnumNullableArray); _aidl_os << ", binderNullableArray: " << ::android::internal::ToString(binderNullableArray); _aidl_os << ", pfdNullableArray: " << ::android::internal::ToString(pfdNullableArray); _aidl_os << ", parcelableNullableArray: " << ::android::internal::ToString(parcelableNullableArray); _aidl_os << ", interfaceNullableArray: " << ::android::internal::ToString(interfaceNullableArray); _aidl_os << ", boolNullableMatrix: " << ::android::internal::ToString(boolNullableMatrix); _aidl_os << ", byteNullableMatrix: " << ::android::internal::ToString(byteNullableMatrix); _aidl_os << ", charNullableMatrix: " << ::android::internal::ToString(charNullableMatrix); _aidl_os << ", intNullableMatrix: " << ::android::internal::ToString(intNullableMatrix); _aidl_os << ", longNullableMatrix: " << ::android::internal::ToString(longNullableMatrix); _aidl_os << ", floatNullableMatrix: " << ::android::internal::ToString(floatNullableMatrix); _aidl_os << ", doubleNullableMatrix: " << ::android::internal::ToString(doubleNullableMatrix); _aidl_os << ", stringNullableMatrix: " << ::android::internal::ToString(stringNullableMatrix); _aidl_os << ", byteEnumNullableMatrix: " << ::android::internal::ToString(byteEnumNullableMatrix); _aidl_os << ", intEnumNullableMatrix: " << ::android::internal::ToString(intEnumNullableMatrix); _aidl_os << ", longEnumNullableMatrix: " << ::android::internal::ToString(longEnumNullableMatrix); _aidl_os << ", binderNullableMatrix: " << ::android::internal::ToString(binderNullableMatrix); _aidl_os << ", pfdNullableMatrix: " << ::android::internal::ToString(pfdNullableMatrix); _aidl_os << ", parcelableNullableMatrix: " << ::android::internal::ToString(parcelableNullableMatrix); _aidl_os << ", interfaceNullableMatrix: " << ::android::internal::ToString(interfaceNullableMatrix); _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace fixedsizearray } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace fixedsizearray { [[nodiscard]] static inline std::string toString(FixedSizeArrayExample::ByteEnum val) { switch(val) { case FixedSizeArrayExample::ByteEnum::A: return "A"; default: return std::to_string(static_cast(val)); } } } // namespace fixedsizearray } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::ByteEnum::A, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk namespace aidl { namespace android { namespace aidl { namespace fixedsizearray { [[nodiscard]] static inline std::string toString(FixedSizeArrayExample::IntEnum val) { switch(val) { case FixedSizeArrayExample::IntEnum::A: return "A"; default: return std::to_string(static_cast(val)); } } } // namespace fixedsizearray } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::IntEnum::A, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk namespace aidl { namespace android { namespace aidl { namespace fixedsizearray { [[nodiscard]] static inline std::string toString(FixedSizeArrayExample::LongEnum val) { switch(val) { case FixedSizeArrayExample::LongEnum::A: return "A"; default: return std::to_string(static_cast(val)); } } } // namespace fixedsizearray } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::LongEnum::A, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-ndk-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 031675 xustar000000000 0000000 28 mtime=1776853188.5710000 tests/golden_output/frozen/aidl-test-fixedsizearray-ndk-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 026607 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-rust-source_0100644 0000000 0000000 00000000034 15172120304 027341 xustar000000000 0000000 28 mtime=1776853188.5710000 tests/golden_output/frozen/aidl-test-fixedsizearray-rust-source/0040755 0000000 0000000 00000000000 15172120304 024346 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-rust-source_gen_0100644 0000000 0000000 00000000034 15172120304 030172 xustar000000000 0000000 28 mtime=1776853188.5710000 tests/golden_output/frozen/aidl-test-fixedsizearray-rust-source/gen/0040755 0000000 0000000 00000000000 15172120304 025117 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-rust-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 031672 xustar000000000 0000000 28 mtime=1776853188.5710000 tests/golden_output/frozen/aidl-test-fixedsizearray-rust-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 026537 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-rust-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 032663 xustar000000000 0000000 28 mtime=1776853188.5710000 tests/golden_output/frozen/aidl-test-fixedsizearray-rust-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 027450 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-rust-source_gen_android_aidl_fix0100644 0000000 0000000 00000000034 15172120304 033372 xustar000000000 0000000 28 mtime=1776853188.5710000 tests/golden_output/frozen/aidl-test-fixedsizearray-rust-source/gen/android/aidl/fixedsizearray/0040755 0000000 0000000 00000000000 15172120304 032501 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-rust-source_gen_android_aidl_fix0100644 0000000 0000000 00000000236 15172120304 033376 xustar000000000 0000000 130 path=tests/golden_output/frozen/aidl-test-fixedsizearray-rust-source/gen/android/aidl/fixedsizearray/FixedSizeArrayExample.rs 28 mtime=1776853188.5710000 tests/golden_output/frozen/aidl-test-fixedsizearray-rust-source/gen/android/aidl/fixedsizearray/Fixe0100644 0000000 0000000 00000175730 15172120304 033331 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-rust-source/gen/android/aidl/fixedsizearray/FixedSizeArrayExample.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/fixedsizearray/FixedSizeArrayExample.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug, PartialEq)] pub struct r#FixedSizeArrayExample { pub r#int2x3: [[i32; 3]; 2], pub r#boolArray: [bool; 2], pub r#byteArray: [u8; 2], pub r#charArray: [u16; 2], pub r#intArray: [i32; 2], pub r#longArray: [i64; 2], pub r#floatArray: [f32; 2], pub r#doubleArray: [f64; 2], pub r#stringArray: [String; 2], pub r#byteEnumArray: [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_8_ByteEnum; 2], pub r#intEnumArray: [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_7_IntEnum; 2], pub r#longEnumArray: [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_8_LongEnum; 2], pub r#parcelableArray: [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 2], pub r#boolMatrix: [[bool; 2]; 2], pub r#byteMatrix: [[u8; 2]; 2], pub r#charMatrix: [[u16; 2]; 2], pub r#intMatrix: [[i32; 2]; 2], pub r#longMatrix: [[i64; 2]; 2], pub r#floatMatrix: [[f32; 2]; 2], pub r#doubleMatrix: [[f64; 2]; 2], pub r#stringMatrix: [[String; 2]; 2], pub r#byteEnumMatrix: [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_8_ByteEnum; 2]; 2], pub r#intEnumMatrix: [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_7_IntEnum; 2]; 2], pub r#longEnumMatrix: [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_8_LongEnum; 2]; 2], pub r#parcelableMatrix: [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 2]; 2], pub r#boolNullableArray: Option<[bool; 2]>, pub r#byteNullableArray: Option<[u8; 2]>, pub r#charNullableArray: Option<[u16; 2]>, pub r#intNullableArray: Option<[i32; 2]>, pub r#longNullableArray: Option<[i64; 2]>, pub r#floatNullableArray: Option<[f32; 2]>, pub r#doubleNullableArray: Option<[f64; 2]>, pub r#stringNullableArray: Option<[Option; 2]>, pub r#byteEnumNullableArray: Option<[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_8_ByteEnum; 2]>, pub r#intEnumNullableArray: Option<[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_7_IntEnum; 2]>, pub r#longEnumNullableArray: Option<[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_8_LongEnum; 2]>, pub r#binderNullableArray: Option<[Option; 2]>, pub r#pfdNullableArray: Option<[Option; 2]>, pub r#parcelableNullableArray: Option<[Option; 2]>, pub r#interfaceNullableArray: Option<[Option>; 2]>, pub r#boolNullableMatrix: Option<[[bool; 2]; 2]>, pub r#byteNullableMatrix: Option<[[u8; 2]; 2]>, pub r#charNullableMatrix: Option<[[u16; 2]; 2]>, pub r#intNullableMatrix: Option<[[i32; 2]; 2]>, pub r#longNullableMatrix: Option<[[i64; 2]; 2]>, pub r#floatNullableMatrix: Option<[[f32; 2]; 2]>, pub r#doubleNullableMatrix: Option<[[f64; 2]; 2]>, pub r#stringNullableMatrix: Option<[[Option; 2]; 2]>, pub r#byteEnumNullableMatrix: Option<[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_8_ByteEnum; 2]; 2]>, pub r#intEnumNullableMatrix: Option<[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_7_IntEnum; 2]; 2]>, pub r#longEnumNullableMatrix: Option<[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_8_LongEnum; 2]; 2]>, pub r#binderNullableMatrix: Option<[[Option; 2]; 2]>, pub r#pfdNullableMatrix: Option<[[Option; 2]; 2]>, pub r#parcelableNullableMatrix: Option<[[Option; 2]; 2]>, pub r#interfaceNullableMatrix: Option<[[Option>; 2]; 2]>, } impl Default for r#FixedSizeArrayExample { fn default() -> Self { Self { r#int2x3: [[1, 2, 3], [4, 5, 6]], r#boolArray: [Default::default(), Default::default()], r#byteArray: [Default::default(), Default::default()], r#charArray: [Default::default(), Default::default()], r#intArray: [Default::default(), Default::default()], r#longArray: [Default::default(), Default::default()], r#floatArray: [Default::default(), Default::default()], r#doubleArray: [Default::default(), Default::default()], r#stringArray: ["hello".into(), "world".into()], r#byteEnumArray: [Default::default(), Default::default()], r#intEnumArray: [Default::default(), Default::default()], r#longEnumArray: [Default::default(), Default::default()], r#parcelableArray: [Default::default(), Default::default()], r#boolMatrix: [[Default::default(), Default::default()], [Default::default(), Default::default()]], r#byteMatrix: [[Default::default(), Default::default()], [Default::default(), Default::default()]], r#charMatrix: [[Default::default(), Default::default()], [Default::default(), Default::default()]], r#intMatrix: [[Default::default(), Default::default()], [Default::default(), Default::default()]], r#longMatrix: [[Default::default(), Default::default()], [Default::default(), Default::default()]], r#floatMatrix: [[Default::default(), Default::default()], [Default::default(), Default::default()]], r#doubleMatrix: [[Default::default(), Default::default()], [Default::default(), Default::default()]], r#stringMatrix: [["hello".into(), "world".into()], ["Ciao".into(), "mondo".into()]], r#byteEnumMatrix: [[Default::default(), Default::default()], [Default::default(), Default::default()]], r#intEnumMatrix: [[Default::default(), Default::default()], [Default::default(), Default::default()]], r#longEnumMatrix: [[Default::default(), Default::default()], [Default::default(), Default::default()]], r#parcelableMatrix: [[Default::default(), Default::default()], [Default::default(), Default::default()]], r#boolNullableArray: Default::default(), r#byteNullableArray: Default::default(), r#charNullableArray: Default::default(), r#intNullableArray: Default::default(), r#longNullableArray: Default::default(), r#floatNullableArray: Default::default(), r#doubleNullableArray: Default::default(), r#stringNullableArray: Some([Some("hello".into()), Some("world".into())]), r#byteEnumNullableArray: Default::default(), r#intEnumNullableArray: Default::default(), r#longEnumNullableArray: Default::default(), r#binderNullableArray: Default::default(), r#pfdNullableArray: Default::default(), r#parcelableNullableArray: Default::default(), r#interfaceNullableArray: Default::default(), r#boolNullableMatrix: Default::default(), r#byteNullableMatrix: Default::default(), r#charNullableMatrix: Default::default(), r#intNullableMatrix: Default::default(), r#longNullableMatrix: Default::default(), r#floatNullableMatrix: Default::default(), r#doubleNullableMatrix: Default::default(), r#stringNullableMatrix: Some([[Some("hello".into()), Some("world".into())], [Some("Ciao".into()), Some("mondo".into())]]), r#byteEnumNullableMatrix: Default::default(), r#intEnumNullableMatrix: Default::default(), r#longEnumNullableMatrix: Default::default(), r#binderNullableMatrix: Default::default(), r#pfdNullableMatrix: Default::default(), r#parcelableNullableMatrix: Default::default(), r#interfaceNullableMatrix: Default::default(), } } } impl binder::Parcelable for r#FixedSizeArrayExample { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#int2x3)?; subparcel.write(&self.r#boolArray)?; subparcel.write(&self.r#byteArray)?; subparcel.write(&self.r#charArray)?; subparcel.write(&self.r#intArray)?; subparcel.write(&self.r#longArray)?; subparcel.write(&self.r#floatArray)?; subparcel.write(&self.r#doubleArray)?; subparcel.write(&self.r#stringArray)?; subparcel.write(&self.r#byteEnumArray)?; subparcel.write(&self.r#intEnumArray)?; subparcel.write(&self.r#longEnumArray)?; subparcel.write(&self.r#parcelableArray)?; subparcel.write(&self.r#boolMatrix)?; subparcel.write(&self.r#byteMatrix)?; subparcel.write(&self.r#charMatrix)?; subparcel.write(&self.r#intMatrix)?; subparcel.write(&self.r#longMatrix)?; subparcel.write(&self.r#floatMatrix)?; subparcel.write(&self.r#doubleMatrix)?; subparcel.write(&self.r#stringMatrix)?; subparcel.write(&self.r#byteEnumMatrix)?; subparcel.write(&self.r#intEnumMatrix)?; subparcel.write(&self.r#longEnumMatrix)?; subparcel.write(&self.r#parcelableMatrix)?; subparcel.write(&self.r#boolNullableArray)?; subparcel.write(&self.r#byteNullableArray)?; subparcel.write(&self.r#charNullableArray)?; subparcel.write(&self.r#intNullableArray)?; subparcel.write(&self.r#longNullableArray)?; subparcel.write(&self.r#floatNullableArray)?; subparcel.write(&self.r#doubleNullableArray)?; subparcel.write(&self.r#stringNullableArray)?; subparcel.write(&self.r#byteEnumNullableArray)?; subparcel.write(&self.r#intEnumNullableArray)?; subparcel.write(&self.r#longEnumNullableArray)?; subparcel.write(&self.r#binderNullableArray)?; subparcel.write(&self.r#pfdNullableArray)?; subparcel.write(&self.r#parcelableNullableArray)?; subparcel.write(&self.r#interfaceNullableArray)?; subparcel.write(&self.r#boolNullableMatrix)?; subparcel.write(&self.r#byteNullableMatrix)?; subparcel.write(&self.r#charNullableMatrix)?; subparcel.write(&self.r#intNullableMatrix)?; subparcel.write(&self.r#longNullableMatrix)?; subparcel.write(&self.r#floatNullableMatrix)?; subparcel.write(&self.r#doubleNullableMatrix)?; subparcel.write(&self.r#stringNullableMatrix)?; subparcel.write(&self.r#byteEnumNullableMatrix)?; subparcel.write(&self.r#intEnumNullableMatrix)?; subparcel.write(&self.r#longEnumNullableMatrix)?; subparcel.write(&self.r#binderNullableMatrix)?; subparcel.write(&self.r#pfdNullableMatrix)?; subparcel.write(&self.r#parcelableNullableMatrix)?; subparcel.write(&self.r#interfaceNullableMatrix)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#int2x3 = subparcel.read()?; } if subparcel.has_more_data() { self.r#boolArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#byteArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#charArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#intArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#longArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#floatArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#doubleArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#stringArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#byteEnumArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#intEnumArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#longEnumArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#parcelableArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#boolMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#byteMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#charMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#intMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#longMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#floatMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#doubleMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#stringMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#byteEnumMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#intEnumMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#longEnumMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#parcelableMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#boolNullableArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#byteNullableArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#charNullableArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#intNullableArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#longNullableArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#floatNullableArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#doubleNullableArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#stringNullableArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#byteEnumNullableArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#intEnumNullableArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#longEnumNullableArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#binderNullableArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#pfdNullableArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#parcelableNullableArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#interfaceNullableArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#boolNullableMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#byteNullableMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#charNullableMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#intNullableMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#longNullableMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#floatNullableMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#doubleNullableMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#stringNullableMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#byteEnumNullableMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#intEnumNullableMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#longEnumNullableMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#binderNullableMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#pfdNullableMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#parcelableNullableMatrix = subparcel.read()?; } if subparcel.has_more_data() { self.r#interfaceNullableMatrix = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#FixedSizeArrayExample); binder::impl_deserialize_for_parcelable!(r#FixedSizeArrayExample); impl binder::binder_impl::ParcelableMetadata for r#FixedSizeArrayExample { fn get_descriptor() -> &'static str { "android.aidl.fixedsizearray.FixedSizeArrayExample" } } pub mod r#IRepeatFixedSizeArray { #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { IRepeatFixedSizeArray["android.aidl.fixedsizearray.FixedSizeArrayExample.IRepeatFixedSizeArray"] { native: BnRepeatFixedSizeArray(on_transact), proxy: BpRepeatFixedSizeArray { }, async: IRepeatFixedSizeArrayAsync, } } pub trait IRepeatFixedSizeArray: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.fixedsizearray.FixedSizeArrayExample.IRepeatFixedSizeArray" } fn r#RepeatBytes(&self, _arg_input: &[u8; 3], _arg_repeated: &mut [u8; 3]) -> binder::Result<[u8; 3]>; fn r#RepeatInts(&self, _arg_input: &[i32; 3], _arg_repeated: &mut [i32; 3]) -> binder::Result<[i32; 3]>; fn r#RepeatBinders(&self, _arg_input: &[binder::SpIBinder; 3], _arg_repeated: &mut [Option; 3]) -> binder::Result<[binder::SpIBinder; 3]>; fn r#RepeatParcelables(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3], _arg_repeated: &mut [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]) -> binder::Result<[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]>; fn r#Repeat2dBytes(&self, _arg_input: &[[u8; 3]; 2], _arg_repeated: &mut [[u8; 3]; 2]) -> binder::Result<[[u8; 3]; 2]>; fn r#Repeat2dInts(&self, _arg_input: &[[i32; 3]; 2], _arg_repeated: &mut [[i32; 3]; 2]) -> binder::Result<[[i32; 3]; 2]>; fn r#Repeat2dBinders(&self, _arg_input: &[[binder::SpIBinder; 3]; 2], _arg_repeated: &mut [[Option; 3]; 2]) -> binder::Result<[[binder::SpIBinder; 3]; 2]>; fn r#Repeat2dParcelables(&self, _arg_input: &[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2], _arg_repeated: &mut [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]) -> binder::Result<[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]>; fn getDefaultImpl() -> IRepeatFixedSizeArrayDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: IRepeatFixedSizeArrayDefaultRef) -> IRepeatFixedSizeArrayDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait IRepeatFixedSizeArrayAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.fixedsizearray.FixedSizeArrayExample.IRepeatFixedSizeArray" } fn r#RepeatBytes<'a>(&'a self, _arg_input: &'a [u8; 3], _arg_repeated: &'a mut [u8; 3]) -> binder::BoxFuture<'a, binder::Result<[u8; 3]>>; fn r#RepeatInts<'a>(&'a self, _arg_input: &'a [i32; 3], _arg_repeated: &'a mut [i32; 3]) -> binder::BoxFuture<'a, binder::Result<[i32; 3]>>; fn r#RepeatBinders<'a>(&'a self, _arg_input: &'a [binder::SpIBinder; 3], _arg_repeated: &'a mut [Option; 3]) -> binder::BoxFuture<'a, binder::Result<[binder::SpIBinder; 3]>>; fn r#RepeatParcelables<'a>(&'a self, _arg_input: &'a [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3], _arg_repeated: &'a mut [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]) -> binder::BoxFuture<'a, binder::Result<[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]>>; fn r#Repeat2dBytes<'a>(&'a self, _arg_input: &'a [[u8; 3]; 2], _arg_repeated: &'a mut [[u8; 3]; 2]) -> binder::BoxFuture<'a, binder::Result<[[u8; 3]; 2]>>; fn r#Repeat2dInts<'a>(&'a self, _arg_input: &'a [[i32; 3]; 2], _arg_repeated: &'a mut [[i32; 3]; 2]) -> binder::BoxFuture<'a, binder::Result<[[i32; 3]; 2]>>; fn r#Repeat2dBinders<'a>(&'a self, _arg_input: &'a [[binder::SpIBinder; 3]; 2], _arg_repeated: &'a mut [[Option; 3]; 2]) -> binder::BoxFuture<'a, binder::Result<[[binder::SpIBinder; 3]; 2]>>; fn r#Repeat2dParcelables<'a>(&'a self, _arg_input: &'a [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2], _arg_repeated: &'a mut [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]) -> binder::BoxFuture<'a, binder::Result<[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]>>; } #[::async_trait::async_trait] pub trait IRepeatFixedSizeArrayAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.fixedsizearray.FixedSizeArrayExample.IRepeatFixedSizeArray" } async fn r#RepeatBytes(&self, _arg_input: &[u8; 3], _arg_repeated: &mut [u8; 3]) -> binder::Result<[u8; 3]>; async fn r#RepeatInts(&self, _arg_input: &[i32; 3], _arg_repeated: &mut [i32; 3]) -> binder::Result<[i32; 3]>; async fn r#RepeatBinders(&self, _arg_input: &[binder::SpIBinder; 3], _arg_repeated: &mut [Option; 3]) -> binder::Result<[binder::SpIBinder; 3]>; async fn r#RepeatParcelables(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3], _arg_repeated: &mut [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]) -> binder::Result<[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]>; async fn r#Repeat2dBytes(&self, _arg_input: &[[u8; 3]; 2], _arg_repeated: &mut [[u8; 3]; 2]) -> binder::Result<[[u8; 3]; 2]>; async fn r#Repeat2dInts(&self, _arg_input: &[[i32; 3]; 2], _arg_repeated: &mut [[i32; 3]; 2]) -> binder::Result<[[i32; 3]; 2]>; async fn r#Repeat2dBinders(&self, _arg_input: &[[binder::SpIBinder; 3]; 2], _arg_repeated: &mut [[Option; 3]; 2]) -> binder::Result<[[binder::SpIBinder; 3]; 2]>; async fn r#Repeat2dParcelables(&self, _arg_input: &[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2], _arg_repeated: &mut [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]) -> binder::Result<[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]>; } impl BnRepeatFixedSizeArray { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: IRepeatFixedSizeArrayAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl IRepeatFixedSizeArray for Wrapper where T: IRepeatFixedSizeArrayAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#RepeatBytes(&self, _arg_input: &[u8; 3], _arg_repeated: &mut [u8; 3]) -> binder::Result<[u8; 3]> { self._rt.block_on(self._inner.r#RepeatBytes(_arg_input, _arg_repeated)) } fn r#RepeatInts(&self, _arg_input: &[i32; 3], _arg_repeated: &mut [i32; 3]) -> binder::Result<[i32; 3]> { self._rt.block_on(self._inner.r#RepeatInts(_arg_input, _arg_repeated)) } fn r#RepeatBinders(&self, _arg_input: &[binder::SpIBinder; 3], _arg_repeated: &mut [Option; 3]) -> binder::Result<[binder::SpIBinder; 3]> { self._rt.block_on(self._inner.r#RepeatBinders(_arg_input, _arg_repeated)) } fn r#RepeatParcelables(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3], _arg_repeated: &mut [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]) -> binder::Result<[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]> { self._rt.block_on(self._inner.r#RepeatParcelables(_arg_input, _arg_repeated)) } fn r#Repeat2dBytes(&self, _arg_input: &[[u8; 3]; 2], _arg_repeated: &mut [[u8; 3]; 2]) -> binder::Result<[[u8; 3]; 2]> { self._rt.block_on(self._inner.r#Repeat2dBytes(_arg_input, _arg_repeated)) } fn r#Repeat2dInts(&self, _arg_input: &[[i32; 3]; 2], _arg_repeated: &mut [[i32; 3]; 2]) -> binder::Result<[[i32; 3]; 2]> { self._rt.block_on(self._inner.r#Repeat2dInts(_arg_input, _arg_repeated)) } fn r#Repeat2dBinders(&self, _arg_input: &[[binder::SpIBinder; 3]; 2], _arg_repeated: &mut [[Option; 3]; 2]) -> binder::Result<[[binder::SpIBinder; 3]; 2]> { self._rt.block_on(self._inner.r#Repeat2dBinders(_arg_input, _arg_repeated)) } fn r#Repeat2dParcelables(&self, _arg_input: &[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2], _arg_repeated: &mut [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]) -> binder::Result<[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]> { self._rt.block_on(self._inner.r#Repeat2dParcelables(_arg_input, _arg_repeated)) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait IRepeatFixedSizeArrayDefault: Send + Sync { fn r#RepeatBytes(&self, _arg_input: &[u8; 3], _arg_repeated: &mut [u8; 3]) -> binder::Result<[u8; 3]> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatInts(&self, _arg_input: &[i32; 3], _arg_repeated: &mut [i32; 3]) -> binder::Result<[i32; 3]> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatBinders(&self, _arg_input: &[binder::SpIBinder; 3], _arg_repeated: &mut [Option; 3]) -> binder::Result<[binder::SpIBinder; 3]> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatParcelables(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3], _arg_repeated: &mut [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]) -> binder::Result<[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#Repeat2dBytes(&self, _arg_input: &[[u8; 3]; 2], _arg_repeated: &mut [[u8; 3]; 2]) -> binder::Result<[[u8; 3]; 2]> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#Repeat2dInts(&self, _arg_input: &[[i32; 3]; 2], _arg_repeated: &mut [[i32; 3]; 2]) -> binder::Result<[[i32; 3]; 2]> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#Repeat2dBinders(&self, _arg_input: &[[binder::SpIBinder; 3]; 2], _arg_repeated: &mut [[Option; 3]; 2]) -> binder::Result<[[binder::SpIBinder; 3]; 2]> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#Repeat2dParcelables(&self, _arg_input: &[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2], _arg_repeated: &mut [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]) -> binder::Result<[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#RepeatBytes: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; pub const r#RepeatInts: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 1; pub const r#RepeatBinders: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 2; pub const r#RepeatParcelables: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 3; pub const r#Repeat2dBytes: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 4; pub const r#Repeat2dInts: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 5; pub const r#Repeat2dBinders: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 6; pub const r#Repeat2dParcelables: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 7; } pub type IRepeatFixedSizeArrayDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); impl BpRepeatFixedSizeArray { fn build_parcel_RepeatBytes(&self, _arg_input: &[u8; 3], _arg_repeated: &mut [u8; 3]) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_RepeatBytes(&self, _arg_input: &[u8; 3], _arg_repeated: &mut [u8; 3], _aidl_reply: std::result::Result) -> binder::Result<[u8; 3]> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatBytes(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: [u8; 3] = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_RepeatInts(&self, _arg_input: &[i32; 3], _arg_repeated: &mut [i32; 3]) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_RepeatInts(&self, _arg_input: &[i32; 3], _arg_repeated: &mut [i32; 3], _aidl_reply: std::result::Result) -> binder::Result<[i32; 3]> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatInts(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: [i32; 3] = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_RepeatBinders(&self, _arg_input: &[binder::SpIBinder; 3], _arg_repeated: &mut [Option; 3]) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_RepeatBinders(&self, _arg_input: &[binder::SpIBinder; 3], _arg_repeated: &mut [Option; 3], _aidl_reply: std::result::Result) -> binder::Result<[binder::SpIBinder; 3]> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatBinders(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: [binder::SpIBinder; 3] = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_RepeatParcelables(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3], _arg_repeated: &mut [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_RepeatParcelables(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3], _arg_repeated: &mut [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3], _aidl_reply: std::result::Result) -> binder::Result<[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatParcelables(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3] = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_Repeat2dBytes(&self, _arg_input: &[[u8; 3]; 2], _arg_repeated: &mut [[u8; 3]; 2]) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_Repeat2dBytes(&self, _arg_input: &[[u8; 3]; 2], _arg_repeated: &mut [[u8; 3]; 2], _aidl_reply: std::result::Result) -> binder::Result<[[u8; 3]; 2]> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#Repeat2dBytes(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: [[u8; 3]; 2] = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_Repeat2dInts(&self, _arg_input: &[[i32; 3]; 2], _arg_repeated: &mut [[i32; 3]; 2]) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_Repeat2dInts(&self, _arg_input: &[[i32; 3]; 2], _arg_repeated: &mut [[i32; 3]; 2], _aidl_reply: std::result::Result) -> binder::Result<[[i32; 3]; 2]> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#Repeat2dInts(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: [[i32; 3]; 2] = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_Repeat2dBinders(&self, _arg_input: &[[binder::SpIBinder; 3]; 2], _arg_repeated: &mut [[Option; 3]; 2]) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_Repeat2dBinders(&self, _arg_input: &[[binder::SpIBinder; 3]; 2], _arg_repeated: &mut [[Option; 3]; 2], _aidl_reply: std::result::Result) -> binder::Result<[[binder::SpIBinder; 3]; 2]> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#Repeat2dBinders(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: [[binder::SpIBinder; 3]; 2] = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_Repeat2dParcelables(&self, _arg_input: &[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2], _arg_repeated: &mut [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_Repeat2dParcelables(&self, _arg_input: &[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2], _arg_repeated: &mut [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2], _aidl_reply: std::result::Result) -> binder::Result<[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#Repeat2dParcelables(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2] = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } } impl IRepeatFixedSizeArray for BpRepeatFixedSizeArray { fn r#RepeatBytes(&self, _arg_input: &[u8; 3], _arg_repeated: &mut [u8; 3]) -> binder::Result<[u8; 3]> { let _aidl_data = self.build_parcel_RepeatBytes(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatBytes, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatBytes(_arg_input, _arg_repeated, _aidl_reply) } fn r#RepeatInts(&self, _arg_input: &[i32; 3], _arg_repeated: &mut [i32; 3]) -> binder::Result<[i32; 3]> { let _aidl_data = self.build_parcel_RepeatInts(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatInts, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatInts(_arg_input, _arg_repeated, _aidl_reply) } fn r#RepeatBinders(&self, _arg_input: &[binder::SpIBinder; 3], _arg_repeated: &mut [Option; 3]) -> binder::Result<[binder::SpIBinder; 3]> { let _aidl_data = self.build_parcel_RepeatBinders(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatBinders, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatBinders(_arg_input, _arg_repeated, _aidl_reply) } fn r#RepeatParcelables(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3], _arg_repeated: &mut [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]) -> binder::Result<[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]> { let _aidl_data = self.build_parcel_RepeatParcelables(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatParcelables, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatParcelables(_arg_input, _arg_repeated, _aidl_reply) } fn r#Repeat2dBytes(&self, _arg_input: &[[u8; 3]; 2], _arg_repeated: &mut [[u8; 3]; 2]) -> binder::Result<[[u8; 3]; 2]> { let _aidl_data = self.build_parcel_Repeat2dBytes(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#Repeat2dBytes, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_Repeat2dBytes(_arg_input, _arg_repeated, _aidl_reply) } fn r#Repeat2dInts(&self, _arg_input: &[[i32; 3]; 2], _arg_repeated: &mut [[i32; 3]; 2]) -> binder::Result<[[i32; 3]; 2]> { let _aidl_data = self.build_parcel_Repeat2dInts(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#Repeat2dInts, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_Repeat2dInts(_arg_input, _arg_repeated, _aidl_reply) } fn r#Repeat2dBinders(&self, _arg_input: &[[binder::SpIBinder; 3]; 2], _arg_repeated: &mut [[Option; 3]; 2]) -> binder::Result<[[binder::SpIBinder; 3]; 2]> { let _aidl_data = self.build_parcel_Repeat2dBinders(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#Repeat2dBinders, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_Repeat2dBinders(_arg_input, _arg_repeated, _aidl_reply) } fn r#Repeat2dParcelables(&self, _arg_input: &[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2], _arg_repeated: &mut [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]) -> binder::Result<[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]> { let _aidl_data = self.build_parcel_Repeat2dParcelables(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#Repeat2dParcelables, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_Repeat2dParcelables(_arg_input, _arg_repeated, _aidl_reply) } } impl IRepeatFixedSizeArrayAsync

for BpRepeatFixedSizeArray { fn r#RepeatBytes<'a>(&'a self, _arg_input: &'a [u8; 3], _arg_repeated: &'a mut [u8; 3]) -> binder::BoxFuture<'a, binder::Result<[u8; 3]>> { let _aidl_data = match self.build_parcel_RepeatBytes(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatBytes, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatBytes(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#RepeatInts<'a>(&'a self, _arg_input: &'a [i32; 3], _arg_repeated: &'a mut [i32; 3]) -> binder::BoxFuture<'a, binder::Result<[i32; 3]>> { let _aidl_data = match self.build_parcel_RepeatInts(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatInts, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatInts(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#RepeatBinders<'a>(&'a self, _arg_input: &'a [binder::SpIBinder; 3], _arg_repeated: &'a mut [Option; 3]) -> binder::BoxFuture<'a, binder::Result<[binder::SpIBinder; 3]>> { let _aidl_data = match self.build_parcel_RepeatBinders(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatBinders, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatBinders(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#RepeatParcelables<'a>(&'a self, _arg_input: &'a [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3], _arg_repeated: &'a mut [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]) -> binder::BoxFuture<'a, binder::Result<[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]>> { let _aidl_data = match self.build_parcel_RepeatParcelables(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatParcelables, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatParcelables(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#Repeat2dBytes<'a>(&'a self, _arg_input: &'a [[u8; 3]; 2], _arg_repeated: &'a mut [[u8; 3]; 2]) -> binder::BoxFuture<'a, binder::Result<[[u8; 3]; 2]>> { let _aidl_data = match self.build_parcel_Repeat2dBytes(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#Repeat2dBytes, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_Repeat2dBytes(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#Repeat2dInts<'a>(&'a self, _arg_input: &'a [[i32; 3]; 2], _arg_repeated: &'a mut [[i32; 3]; 2]) -> binder::BoxFuture<'a, binder::Result<[[i32; 3]; 2]>> { let _aidl_data = match self.build_parcel_Repeat2dInts(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#Repeat2dInts, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_Repeat2dInts(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#Repeat2dBinders<'a>(&'a self, _arg_input: &'a [[binder::SpIBinder; 3]; 2], _arg_repeated: &'a mut [[Option; 3]; 2]) -> binder::BoxFuture<'a, binder::Result<[[binder::SpIBinder; 3]; 2]>> { let _aidl_data = match self.build_parcel_Repeat2dBinders(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#Repeat2dBinders, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_Repeat2dBinders(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#Repeat2dParcelables<'a>(&'a self, _arg_input: &'a [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2], _arg_repeated: &'a mut [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]) -> binder::BoxFuture<'a, binder::Result<[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]>> { let _aidl_data = match self.build_parcel_Repeat2dParcelables(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#Repeat2dParcelables, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_Repeat2dParcelables(_arg_input, _arg_repeated, _aidl_reply) } ) } } impl IRepeatFixedSizeArray for binder::binder_impl::Binder { fn r#RepeatBytes(&self, _arg_input: &[u8; 3], _arg_repeated: &mut [u8; 3]) -> binder::Result<[u8; 3]> { self.0.r#RepeatBytes(_arg_input, _arg_repeated) } fn r#RepeatInts(&self, _arg_input: &[i32; 3], _arg_repeated: &mut [i32; 3]) -> binder::Result<[i32; 3]> { self.0.r#RepeatInts(_arg_input, _arg_repeated) } fn r#RepeatBinders(&self, _arg_input: &[binder::SpIBinder; 3], _arg_repeated: &mut [Option; 3]) -> binder::Result<[binder::SpIBinder; 3]> { self.0.r#RepeatBinders(_arg_input, _arg_repeated) } fn r#RepeatParcelables(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3], _arg_repeated: &mut [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]) -> binder::Result<[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]> { self.0.r#RepeatParcelables(_arg_input, _arg_repeated) } fn r#Repeat2dBytes(&self, _arg_input: &[[u8; 3]; 2], _arg_repeated: &mut [[u8; 3]; 2]) -> binder::Result<[[u8; 3]; 2]> { self.0.r#Repeat2dBytes(_arg_input, _arg_repeated) } fn r#Repeat2dInts(&self, _arg_input: &[[i32; 3]; 2], _arg_repeated: &mut [[i32; 3]; 2]) -> binder::Result<[[i32; 3]; 2]> { self.0.r#Repeat2dInts(_arg_input, _arg_repeated) } fn r#Repeat2dBinders(&self, _arg_input: &[[binder::SpIBinder; 3]; 2], _arg_repeated: &mut [[Option; 3]; 2]) -> binder::Result<[[binder::SpIBinder; 3]; 2]> { self.0.r#Repeat2dBinders(_arg_input, _arg_repeated) } fn r#Repeat2dParcelables(&self, _arg_input: &[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2], _arg_repeated: &mut [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]) -> binder::Result<[[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2]> { self.0.r#Repeat2dParcelables(_arg_input, _arg_repeated) } } fn on_transact(_aidl_service: &dyn IRepeatFixedSizeArray, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#RepeatBytes => { let _arg_input: [u8; 3] = _aidl_data.read()?; let mut _arg_repeated: [u8; 3] = Default::default(); let _aidl_return = _aidl_service.r#RepeatBytes(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatInts => { let _arg_input: [i32; 3] = _aidl_data.read()?; let mut _arg_repeated: [i32; 3] = Default::default(); let _aidl_return = _aidl_service.r#RepeatInts(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatBinders => { let _arg_input: [binder::SpIBinder; 3] = _aidl_data.read()?; let mut _arg_repeated: [Option; 3] = Default::default(); let _aidl_return = _aidl_service.r#RepeatBinders(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatParcelables => { let _arg_input: [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3] = _aidl_data.read()?; let mut _arg_repeated: [crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3] = Default::default(); let _aidl_return = _aidl_service.r#RepeatParcelables(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#Repeat2dBytes => { let _arg_input: [[u8; 3]; 2] = _aidl_data.read()?; let mut _arg_repeated: [[u8; 3]; 2] = Default::default(); let _aidl_return = _aidl_service.r#Repeat2dBytes(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#Repeat2dInts => { let _arg_input: [[i32; 3]; 2] = _aidl_data.read()?; let mut _arg_repeated: [[i32; 3]; 2] = Default::default(); let _aidl_return = _aidl_service.r#Repeat2dInts(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#Repeat2dBinders => { let _arg_input: [[binder::SpIBinder; 3]; 2] = _aidl_data.read()?; let mut _arg_repeated: [[Option; 3]; 2] = Default::default(); let _aidl_return = _aidl_service.r#Repeat2dBinders(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#Repeat2dParcelables => { let _arg_input: [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2] = _aidl_data.read()?; let mut _arg_repeated: [[crate::mangled::_7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; 3]; 2] = Default::default(); let _aidl_return = _aidl_service.r#Repeat2dParcelables(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } } pub mod r#ByteEnum { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#ByteEnum : [i8; 1] { r#A = 0, } } } pub mod r#IntEnum { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#IntEnum : [i32; 1] { r#A = 0, } } } pub mod r#LongEnum { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#LongEnum : [i64; 1] { r#A = 0, } } } pub mod r#IntParcelable { #[derive(Debug, Clone, Copy, PartialEq)] pub struct r#IntParcelable { pub r#value: i32, } impl Default for r#IntParcelable { fn default() -> Self { Self { r#value: 0, } } } impl binder::Parcelable for r#IntParcelable { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#value)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#value = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#IntParcelable); binder::impl_deserialize_for_parcelable!(r#IntParcelable); impl binder::binder_impl::ParcelableMetadata for r#IntParcelable { fn get_descriptor() -> &'static str { "android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable" } } } pub mod r#IEmptyInterface { #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { IEmptyInterface["android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface"] { native: BnEmptyInterface(on_transact), proxy: BpEmptyInterface { }, async: IEmptyInterfaceAsync, } } pub trait IEmptyInterface: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface" } fn getDefaultImpl() -> IEmptyInterfaceDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: IEmptyInterfaceDefaultRef) -> IEmptyInterfaceDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait IEmptyInterfaceAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface" } } #[::async_trait::async_trait] pub trait IEmptyInterfaceAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.fixedsizearray.FixedSizeArrayExample.IEmptyInterface" } } impl BnEmptyInterface { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: IEmptyInterfaceAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl IEmptyInterface for Wrapper where T: IEmptyInterfaceAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait IEmptyInterfaceDefault: Send + Sync { } pub mod transactions { } pub type IEmptyInterfaceDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); impl BpEmptyInterface { } impl IEmptyInterface for BpEmptyInterface { } impl IEmptyInterfaceAsync

for BpEmptyInterface { } impl IEmptyInterface for binder::binder_impl::Binder { } fn on_transact(_aidl_service: &dyn IEmptyInterface, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } } pub(crate) mod mangled { pub use super::r#FixedSizeArrayExample as _7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample; pub use super::r#IRepeatFixedSizeArray::r#IRepeatFixedSizeArray as _7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_21_IRepeatFixedSizeArray; pub use super::r#ByteEnum::r#ByteEnum as _7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_8_ByteEnum; pub use super::r#IntEnum::r#IntEnum as _7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_7_IntEnum; pub use super::r#LongEnum::r#LongEnum as _7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_8_LongEnum; pub use super::r#IntParcelable::r#IntParcelable as _7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_13_IntParcelable; pub use super::r#IEmptyInterface::r#IEmptyInterface as _7_android_4_aidl_14_fixedsizearray_21_FixedSizeArrayExample_15_IEmptyInterface; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-rust-source_gen_android_aidl_fix0100644 0000000 0000000 00000000240 15172120304 033371 xustar000000000 0000000 132 path=tests/golden_output/frozen/aidl-test-fixedsizearray-rust-source/gen/android/aidl/fixedsizearray/FixedSizeArrayExample.rs.d 28 mtime=1776853188.5730000 tests/golden_output/frozen/aidl-test-fixedsizearray-rust-source/gen/android/aidl/fixedsizearray/Fixe0100644 0000000 0000000 00000000336 15172120304 033316 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-fixedsizearray-rust-source/gen/android/aidl/fixedsizearray/FixedSizeArrayExample.rs : \ system/tools/aidl/tests/android/aidl/fixedsizearray/FixedSizeArrayExample.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-fixedsizearray-rust-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 032116 xustar000000000 0000000 28 mtime=1776853188.5730000 tests/golden_output/frozen/aidl-test-fixedsizearray-rust-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 027030 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_0100644 0000000 0000000 00000000034 15172120304 027660 xustar000000000 0000000 28 mtime=1776853188.5750000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/0040755 0000000 0000000 00000000000 15172120304 024665 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_0100644 0000000 0000000 00000000034 15172120304 030511 xustar000000000 0000000 28 mtime=1776853188.5750000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/0040755 0000000 0000000 00000000000 15172120304 025436 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 032211 xustar000000000 0000000 28 mtime=1776853188.5750000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 027056 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 033202 xustar000000000 0000000 28 mtime=1776853188.5750000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 027767 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 033202 xustar000000000 0000000 28 mtime=1776853188.5750000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/0040755 0000000 0000000 00000000000 15172120304 031131 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000225 15172120304 033204 xustar000000000 0000000 121 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ArrayOfInterfaces.cpp 28 mtime=1776853188.5750000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ArrayOfInt0100644 0000000 0000000 00000001322 15172120304 033065 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/ArrayOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ArrayOfInterfaces.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000227 15172120304 033206 xustar000000000 0000000 123 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ArrayOfInterfaces.cpp.d 28 mtime=1776853188.5750000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ArrayOfInt0100644 0000000 0000000 00000000310 15172120304 033061 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ArrayOfInterfaces.cpp : \ system/tools/aidl/tests/android/aidl/tests/ArrayOfInterfaces.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000217 15172120304 033205 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/BackendType.cpp 28 mtime=1776853188.5750000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/BackendTyp0100644 0000000 0000000 00000001306 15172120304 033075 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/BackendType.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/BackendType.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000221 15172120304 033200 xustar000000000 0000000 117 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/BackendType.cpp.d 28 mtime=1776853188.5750000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/BackendTyp0100644 0000000 0000000 00000000274 15172120304 033100 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/BackendType.cpp : \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000214 15172120304 033202 xustar000000000 0000000 112 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ByteEnum.cpp 28 mtime=1776853188.5750000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ByteEnum.c0100644 0000000 0000000 00000001300 15172120304 033014 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/ByteEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000216 15172120304 033204 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ByteEnum.cpp.d 28 mtime=1776853188.5750000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ByteEnum.c0100644 0000000 0000000 00000000266 15172120304 033026 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ByteEnum.cpp : \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000226 15172120304 033205 xustar000000000 0000000 122 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/CircularParcelable.cpp 28 mtime=1776853188.5760000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/CircularPa0100644 0000000 0000000 00000001324 15172120304 033076 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/CircularParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000230 15172120304 033200 xustar000000000 0000000 124 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/CircularParcelable.cpp.d 28 mtime=1776853188.5760000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/CircularPa0100644 0000000 0000000 00000002244 15172120304 033100 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/CircularParcelable.cpp : \ system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ITestService.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl \ system/tools/aidl/tests/android/aidl/tests/SimpleParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl \ system/tools/aidl/tests/android/aidl/tests/ICircular.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000232 15172120304 033202 xustar000000000 0000000 126 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ConstantExpressionEnum.cpp 28 mtime=1776853188.5760000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ConstantEx0100644 0000000 0000000 00000001334 15172120304 033140 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/ConstantExpressionEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000234 15172120304 033204 xustar000000000 0000000 128 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ConstantExpressionEnum.cpp.d 28 mtime=1776853188.5760000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ConstantEx0100644 0000000 0000000 00000000322 15172120304 033134 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ConstantExpressionEnum.cpp : \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000222 15172120304 033201 xustar000000000 0000000 118 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/DeprecatedEnum.cpp 28 mtime=1776853188.5760000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/Deprecated0100644 0000000 0000000 00000001314 15172120304 033110 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/DeprecatedEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedEnum.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000224 15172120304 033203 xustar000000000 0000000 120 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/DeprecatedEnum.cpp.d 28 mtime=1776853188.5760000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/Deprecated0100644 0000000 0000000 00000000302 15172120304 033104 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/DeprecatedEnum.cpp : \ system/tools/aidl/tests/android/aidl/tests/DeprecatedEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000230 15172120304 033200 xustar000000000 0000000 124 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/DeprecatedParcelable.cpp 28 mtime=1776853188.5760000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/Deprecated0100644 0000000 0000000 00000001330 15172120304 033106 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/DeprecatedParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedParcelable.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000232 15172120304 033202 xustar000000000 0000000 126 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/DeprecatedParcelable.cpp.d 28 mtime=1776853188.5760000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/Deprecated0100644 0000000 0000000 00000000316 15172120304 033111 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/DeprecatedParcelable.cpp : \ system/tools/aidl/tests/android/aidl/tests/DeprecatedParcelable.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000215 15172120304 033203 xustar000000000 0000000 113 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/FixedSize.cpp 28 mtime=1776853188.5760000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/FixedSize.0100644 0000000 0000000 00000001302 15172120304 033015 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/FixedSize.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/FixedSize.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000217 15172120304 033205 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/FixedSize.cpp.d 28 mtime=1776853188.5760000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/FixedSize.0100644 0000000 0000000 00000000365 15172120304 033025 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/FixedSize.cpp : \ system/tools/aidl/tests/android/aidl/tests/FixedSize.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000237 15172120304 033207 xustar000000000 0000000 131 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/GenericStructuredParcelable.cpp 28 mtime=1776853188.5760000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/GenericStr0100644 0000000 0000000 00000001346 15172120304 033122 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/GenericStructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000241 15172120304 033202 xustar000000000 0000000 133 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/GenericStructuredParcelable.cpp.d 28 mtime=1776853188.5760000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/GenericStr0100644 0000000 0000000 00000000334 15172120304 033116 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/GenericStructuredParcelable.cpp : \ system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000215 15172120304 033203 xustar000000000 0000000 113 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ICircular.cpp 28 mtime=1776853188.5760000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ICircular.0100644 0000000 0000000 00000005235 15172120304 033011 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/ICircular.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ICircular.aidl */ #include #include #include #include namespace { android::status_t analyzeICircular(uint32_t _aidl_code, const android::Parcel& _aidl_data, const android::Parcel& _aidl_reply) { android::status_t _aidl_ret_status; switch(_aidl_code) { case ::android::IBinder::FIRST_CALL_TRANSACTION + 0: { std::cout << "ICircular.GetTestService()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ICircular")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::sp<::android::aidl::tests::ITestService> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readNullableStrongBinder(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails } while(false); std::cout << " arguments: " << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; default: { std::cout << " Transaction code " << _aidl_code << " not known." << std::endl; _aidl_ret_status = android::UNKNOWN_TRANSACTION; } } return _aidl_ret_status; // To prevent unused variable warnings (void)_aidl_ret_status; (void)_aidl_data; (void)_aidl_reply; } } // namespace #include using android::aidl::Analyzer; __attribute__((constructor)) static void addAnalyzer() { Analyzer::installAnalyzer(std::make_unique("android.aidl.tests.ICircular", "ICircular", &analyzeICircular)); } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000217 15172120304 033205 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ICircular.cpp.d 28 mtime=1776853188.5770000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ICircular.0100644 0000000 0000000 00000002233 15172120304 033004 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ICircular.cpp : \ system/tools/aidl/tests/android/aidl/tests/ICircular.aidl \ system/tools/aidl/tests/android/aidl/tests/ITestService.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl \ system/tools/aidl/tests/android/aidl/tests/SimpleParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl \ system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000217 15172120304 033205 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/IDeprecated.cpp 28 mtime=1776853188.5770000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/IDeprecate0100644 0000000 0000000 00000002756 15172120304 033070 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/IDeprecated.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IDeprecated.aidl */ #include #include #include #include namespace { android::status_t analyzeIDeprecated(uint32_t _aidl_code, const android::Parcel& _aidl_data, const android::Parcel& _aidl_reply) { android::status_t _aidl_ret_status; switch(_aidl_code) { default: { std::cout << " Transaction code " << _aidl_code << " not known." << std::endl; _aidl_ret_status = android::UNKNOWN_TRANSACTION; } } return _aidl_ret_status; // To prevent unused variable warnings (void)_aidl_ret_status; (void)_aidl_data; (void)_aidl_reply; } } // namespace #include using android::aidl::Analyzer; __attribute__((constructor)) static void addAnalyzer() { Analyzer::installAnalyzer(std::make_unique("android.aidl.tests.IDeprecated", "IDeprecated", &analyzeIDeprecated)); } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000221 15172120304 033200 xustar000000000 0000000 117 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/IDeprecated.cpp.d 28 mtime=1776853188.5770000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/IDeprecate0100644 0000000 0000000 00000000274 15172120304 033061 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/IDeprecated.cpp : \ system/tools/aidl/tests/android/aidl/tests/IDeprecated.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000222 15172120304 033201 xustar000000000 0000000 118 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/INamedCallback.cpp 28 mtime=1776853188.5770000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/INamedCall0100644 0000000 0000000 00000005227 15172120304 033010 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/INamedCallback.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl */ #include #include #include #include namespace { android::status_t analyzeINamedCallback(uint32_t _aidl_code, const android::Parcel& _aidl_data, const android::Parcel& _aidl_reply) { android::status_t _aidl_ret_status; switch(_aidl_code) { case ::android::IBinder::FIRST_CALL_TRANSACTION + 0: { std::cout << "INamedCallback.GetName()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.INamedCallback")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::String16 _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readString16(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails } while(false); std::cout << " arguments: " << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; default: { std::cout << " Transaction code " << _aidl_code << " not known." << std::endl; _aidl_ret_status = android::UNKNOWN_TRANSACTION; } } return _aidl_ret_status; // To prevent unused variable warnings (void)_aidl_ret_status; (void)_aidl_data; (void)_aidl_reply; } } // namespace #include using android::aidl::Analyzer; __attribute__((constructor)) static void addAnalyzer() { Analyzer::installAnalyzer(std::make_unique("android.aidl.tests.INamedCallback", "INamedCallback", &analyzeINamedCallback)); } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000224 15172120304 033203 xustar000000000 0000000 120 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/INamedCallback.cpp.d 28 mtime=1776853188.5770000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/INamedCall0100644 0000000 0000000 00000000302 15172120304 032775 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/INamedCallback.cpp : \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000214 15172120304 033202 xustar000000000 0000000 112 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/INewName.cpp 28 mtime=1776853188.5770000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/INewName.c0100644 0000000 0000000 00000005142 15172120304 032737 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/INewName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INewName.aidl */ #include #include #include #include namespace { android::status_t analyzeINewName(uint32_t _aidl_code, const android::Parcel& _aidl_data, const android::Parcel& _aidl_reply) { android::status_t _aidl_ret_status; switch(_aidl_code) { case ::android::IBinder::FIRST_CALL_TRANSACTION + 0: { std::cout << "INewName.RealName()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.IOldName")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::String16 _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readString16(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails } while(false); std::cout << " arguments: " << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; default: { std::cout << " Transaction code " << _aidl_code << " not known." << std::endl; _aidl_ret_status = android::UNKNOWN_TRANSACTION; } } return _aidl_ret_status; // To prevent unused variable warnings (void)_aidl_ret_status; (void)_aidl_data; (void)_aidl_reply; } } // namespace #include using android::aidl::Analyzer; __attribute__((constructor)) static void addAnalyzer() { Analyzer::installAnalyzer(std::make_unique("android.aidl.tests.INewName", "INewName", &analyzeINewName)); } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000216 15172120304 033204 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/INewName.cpp.d 28 mtime=1776853188.5770000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/INewName.c0100644 0000000 0000000 00000000266 15172120304 032741 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/INewName.cpp : \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000214 15172120304 033202 xustar000000000 0000000 112 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/IOldName.cpp 28 mtime=1776853188.5770000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/IOldName.c0100644 0000000 0000000 00000005142 15172120304 032724 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/IOldName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IOldName.aidl */ #include #include #include #include namespace { android::status_t analyzeIOldName(uint32_t _aidl_code, const android::Parcel& _aidl_data, const android::Parcel& _aidl_reply) { android::status_t _aidl_ret_status; switch(_aidl_code) { case ::android::IBinder::FIRST_CALL_TRANSACTION + 0: { std::cout << "IOldName.RealName()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.IOldName")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::String16 _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readString16(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails } while(false); std::cout << " arguments: " << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; default: { std::cout << " Transaction code " << _aidl_code << " not known." << std::endl; _aidl_ret_status = android::UNKNOWN_TRANSACTION; } } return _aidl_ret_status; // To prevent unused variable warnings (void)_aidl_ret_status; (void)_aidl_data; (void)_aidl_reply; } } // namespace #include using android::aidl::Analyzer; __attribute__((constructor)) static void addAnalyzer() { Analyzer::installAnalyzer(std::make_unique("android.aidl.tests.IOldName", "IOldName", &analyzeIOldName)); } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000216 15172120304 033204 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/IOldName.cpp.d 28 mtime=1776853188.5770000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/IOldName.c0100644 0000000 0000000 00000000266 15172120304 032726 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/IOldName.cpp : \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000220 15172120304 033177 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ITestService.cpp 28 mtime=1776853188.5770000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ITestServi0100644 0000000 0000000 00000375431 15172120304 033127 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/ITestService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ITestService.aidl */ #include #include #include #include namespace { android::status_t analyzeITestService(uint32_t _aidl_code, const android::Parcel& _aidl_data, const android::Parcel& _aidl_reply) { android::status_t _aidl_ret_status; switch(_aidl_code) { case ::android::IBinder::FIRST_CALL_TRANSACTION + 0: { std::cout << "ITestService.UnimplementedMethod()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } int32_t in_arg; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); int32_t _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readInt32(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readInt32(&in_arg); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument arg from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " arg: " << ::android::internal::ToString(in_arg) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 1: { std::cout << "ITestService.Deprecated()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); do { // Single-pass loop to break if argument reading fails } while(false); std::cout << " arguments: " << std::endl; std::cout << " return: void" << std::endl; } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 2: { std::cout << "ITestService.TestOneway()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); do { // Single-pass loop to break if argument reading fails } while(false); std::cout << " arguments: " << std::endl; std::cout << " return: void" << std::endl; } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 3: { std::cout << "ITestService.RepeatBoolean()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } bool in_token; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); bool _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readBool(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readBool(&in_token); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument token from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " token: " << ::android::internal::ToString(in_token) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 4: { std::cout << "ITestService.RepeatByte()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } int8_t in_token; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); int8_t _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readByte(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readByte(&in_token); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument token from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " token: " << ::android::internal::ToString(in_token) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 5: { std::cout << "ITestService.RepeatChar()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } char16_t in_token; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); char16_t _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readChar(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readChar(&in_token); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument token from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " token: " << ::android::internal::ToString(in_token) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 6: { std::cout << "ITestService.RepeatInt()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } int32_t in_token; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); int32_t _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readInt32(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readInt32(&in_token); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument token from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " token: " << ::android::internal::ToString(in_token) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 7: { std::cout << "ITestService.RepeatLong()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } int64_t in_token; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); int64_t _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readInt64(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readInt64(&in_token); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument token from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " token: " << ::android::internal::ToString(in_token) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 8: { std::cout << "ITestService.RepeatFloat()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } float in_token; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); float _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readFloat(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readFloat(&in_token); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument token from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " token: " << ::android::internal::ToString(in_token) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 9: { std::cout << "ITestService.RepeatDouble()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } double in_token; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); double _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readDouble(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readDouble(&in_token); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument token from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " token: " << ::android::internal::ToString(in_token) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 10: { std::cout << "ITestService.RepeatString()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::String16 in_token; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::String16 _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readString16(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readString16(&in_token); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument token from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " token: " << ::android::internal::ToString(in_token) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 11: { std::cout << "ITestService.RepeatByteEnum()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::aidl::tests::ByteEnum in_token; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::aidl::tests::ByteEnum _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readByte(reinterpret_cast(&_aidl_return)); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readByte(reinterpret_cast(&in_token)); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument token from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " token: " << ::android::internal::ToString(in_token) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 12: { std::cout << "ITestService.RepeatIntEnum()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::aidl::tests::IntEnum in_token; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::aidl::tests::IntEnum _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readInt32(reinterpret_cast(&_aidl_return)); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readInt32(reinterpret_cast(&in_token)); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument token from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " token: " << ::android::internal::ToString(in_token) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 13: { std::cout << "ITestService.RepeatLongEnum()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::aidl::tests::LongEnum in_token; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::aidl::tests::LongEnum _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readInt64(reinterpret_cast(&_aidl_return)); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readInt64(reinterpret_cast(&in_token)); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument token from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " token: " << ::android::internal::ToString(in_token) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 14: { std::cout << "ITestService.ReverseBoolean()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector in_input; ::std::vector out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readBoolVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readBoolVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readBoolVector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 15: { std::cout << "ITestService.ReverseByte()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector in_input; ::std::vector out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readByteVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readByteVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readByteVector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 16: { std::cout << "ITestService.ReverseChar()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector in_input; ::std::vector out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readCharVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readCharVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readCharVector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 17: { std::cout << "ITestService.ReverseInt()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector in_input; ::std::vector out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readInt32Vector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readInt32Vector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readInt32Vector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 18: { std::cout << "ITestService.ReverseLong()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector in_input; ::std::vector out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readInt64Vector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readInt64Vector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readInt64Vector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 19: { std::cout << "ITestService.ReverseFloat()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector in_input; ::std::vector out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readFloatVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readFloatVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readFloatVector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 20: { std::cout << "ITestService.ReverseDouble()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector in_input; ::std::vector out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readDoubleVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readDoubleVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readDoubleVector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 21: { std::cout << "ITestService.ReverseString()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector<::android::String16> in_input; ::std::vector<::android::String16> out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector<::android::String16> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readString16Vector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readString16Vector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readString16Vector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 22: { std::cout << "ITestService.ReverseByteEnum()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector<::android::aidl::tests::ByteEnum> in_input; ::std::vector<::android::aidl::tests::ByteEnum> out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector<::android::aidl::tests::ByteEnum> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readEnumVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readEnumVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readEnumVector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 23: { std::cout << "ITestService.ReverseIntEnum()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector<::android::aidl::tests::IntEnum> in_input; ::std::vector<::android::aidl::tests::IntEnum> out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector<::android::aidl::tests::IntEnum> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readEnumVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readEnumVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readEnumVector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 24: { std::cout << "ITestService.ReverseLongEnum()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector<::android::aidl::tests::LongEnum> in_input; ::std::vector<::android::aidl::tests::LongEnum> out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector<::android::aidl::tests::LongEnum> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readEnumVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readEnumVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readEnumVector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 25: { std::cout << "ITestService.GetOtherTestService()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::String16 in_name; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::sp<::android::aidl::tests::INamedCallback> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readStrongBinder(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readString16(&in_name); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument name from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " name: " << ::android::internal::ToString(in_name) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 26: { std::cout << "ITestService.SetOtherTestService()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::String16 in_name; ::android::sp<::android::aidl::tests::INamedCallback> in_service; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); bool _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readBool(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readString16(&in_name); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument name from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readStrongBinder(&in_service); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument service from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " name: " << ::android::internal::ToString(in_name) << std::endl; std::cout << " service: " << ::android::internal::ToString(in_service) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 27: { std::cout << "ITestService.VerifyName()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::sp<::android::aidl::tests::INamedCallback> in_service; ::android::String16 in_name; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); bool _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readBool(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readStrongBinder(&in_service); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument service from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readString16(&in_name); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument name from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " service: " << ::android::internal::ToString(in_service) << std::endl; std::cout << " name: " << ::android::internal::ToString(in_name) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 28: { std::cout << "ITestService.GetInterfaceArray()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector<::android::String16> in_names; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector<::android::sp<::android::aidl::tests::INamedCallback>> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readStrongBinderVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readString16Vector(&in_names); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument names from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " names: " << ::android::internal::ToString(in_names) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 29: { std::cout << "ITestService.VerifyNamesWithInterfaceArray()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector<::android::sp<::android::aidl::tests::INamedCallback>> in_services; ::std::vector<::android::String16> in_names; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); bool _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readBool(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_services); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument services from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readString16Vector(&in_names); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument names from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " services: " << ::android::internal::ToString(in_services) << std::endl; std::cout << " names: " << ::android::internal::ToString(in_names) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 30: { std::cout << "ITestService.GetNullableInterfaceArray()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::std::vector<::std::optional<::android::String16>>> in_names; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readStrongBinderVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readString16Vector(&in_names); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument names from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " names: " << ::android::internal::ToString(in_names) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 31: { std::cout << "ITestService.VerifyNamesWithNullableInterfaceArray()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>> in_services; ::std::optional<::std::vector<::std::optional<::android::String16>>> in_names; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); bool _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readBool(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_services); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument services from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readString16Vector(&in_names); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument names from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " services: " << ::android::internal::ToString(in_services) << std::endl; std::cout << " names: " << ::android::internal::ToString(in_names) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 32: { std::cout << "ITestService.GetInterfaceList()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::std::vector<::std::optional<::android::String16>>> in_names; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readStrongBinderVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readString16Vector(&in_names); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument names from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " names: " << ::android::internal::ToString(in_names) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 33: { std::cout << "ITestService.VerifyNamesWithInterfaceList()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>> in_services; ::std::optional<::std::vector<::std::optional<::android::String16>>> in_names; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); bool _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readBool(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_services); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument services from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readString16Vector(&in_names); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument names from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " services: " << ::android::internal::ToString(in_services) << std::endl; std::cout << " names: " << ::android::internal::ToString(in_names) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 34: { std::cout << "ITestService.ReverseStringList()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector<::android::String16> in_input; ::std::vector<::android::String16> out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector<::android::String16> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readString16Vector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readString16Vector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readString16Vector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 35: { std::cout << "ITestService.RepeatParcelFileDescriptor()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::os::ParcelFileDescriptor in_read; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::os::ParcelFileDescriptor _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readParcelable(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readParcelable(&in_read); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument read from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " read: " << ::android::internal::ToString(in_read) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 36: { std::cout << "ITestService.ReverseParcelFileDescriptorArray()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector<::android::os::ParcelFileDescriptor> in_input; ::std::vector<::android::os::ParcelFileDescriptor> out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector<::android::os::ParcelFileDescriptor> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readParcelableVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readParcelableVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readParcelableVector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 37: { std::cout << "ITestService.ThrowServiceException()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } int32_t in_code; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readInt32(&in_code); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument code from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " code: " << ::android::internal::ToString(in_code) << std::endl; std::cout << " return: void" << std::endl; } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 38: { std::cout << "ITestService.RepeatNullableIntArray()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::std::vector> in_input; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::optional<::std::vector> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readInt32Vector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readInt32Vector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 39: { std::cout << "ITestService.RepeatNullableByteEnumArray()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::std::vector<::android::aidl::tests::ByteEnum>> in_input; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::optional<::std::vector<::android::aidl::tests::ByteEnum>> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readEnumVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readEnumVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 40: { std::cout << "ITestService.RepeatNullableIntEnumArray()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::std::vector<::android::aidl::tests::IntEnum>> in_input; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::optional<::std::vector<::android::aidl::tests::IntEnum>> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readEnumVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readEnumVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 41: { std::cout << "ITestService.RepeatNullableLongEnumArray()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::std::vector<::android::aidl::tests::LongEnum>> in_input; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::optional<::std::vector<::android::aidl::tests::LongEnum>> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readEnumVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readEnumVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 42: { std::cout << "ITestService.RepeatNullableString()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::android::String16> in_input; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::optional<::android::String16> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readString16(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readString16(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 43: { std::cout << "ITestService.RepeatNullableStringList()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::std::vector<::std::optional<::android::String16>>> in_input; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::optional<::std::vector<::std::optional<::android::String16>>> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readString16Vector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readString16Vector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 44: { std::cout << "ITestService.RepeatNullableParcelable()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::android::aidl::tests::ITestService::Empty> in_input; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::optional<::android::aidl::tests::ITestService::Empty> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readParcelable(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 45: { std::cout << "ITestService.RepeatNullableParcelableArray()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>> in_input; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readParcelableVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readParcelableVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 46: { std::cout << "ITestService.RepeatNullableParcelableList()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>> in_input; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readParcelableVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readParcelableVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 47: { std::cout << "ITestService.TakesAnIBinder()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::sp<::android::IBinder> in_input; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readStrongBinder(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " return: void" << std::endl; } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 48: { std::cout << "ITestService.TakesANullableIBinder()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::sp<::android::IBinder> in_input; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readNullableStrongBinder(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " return: void" << std::endl; } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 49: { std::cout << "ITestService.TakesAnIBinderList()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector<::android::sp<::android::IBinder>> in_input; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " return: void" << std::endl; } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 50: { std::cout << "ITestService.TakesANullableIBinderList()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::std::vector<::android::sp<::android::IBinder>>> in_input; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " return: void" << std::endl; } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 51: { std::cout << "ITestService.RepeatUtf8CppString()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::string in_token; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::string _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readUtf8FromUtf16(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readUtf8FromUtf16(&in_token); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument token from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " token: " << ::android::internal::ToString(in_token) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 52: { std::cout << "ITestService.RepeatNullableUtf8CppString()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::std::string> in_token; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::optional<::std::string> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readUtf8FromUtf16(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readUtf8FromUtf16(&in_token); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument token from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " token: " << ::android::internal::ToString(in_token) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 53: { std::cout << "ITestService.ReverseUtf8CppString()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector<::std::string> in_input; ::std::vector<::std::string> out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector<::std::string> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readUtf8VectorFromUtf16Vector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readUtf8VectorFromUtf16Vector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readUtf8VectorFromUtf16Vector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 54: { std::cout << "ITestService.ReverseNullableUtf8CppString()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::std::vector<::std::optional<::std::string>>> in_input; ::std::optional<::std::vector<::std::optional<::std::string>>> out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::optional<::std::vector<::std::optional<::std::string>>> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readUtf8VectorFromUtf16Vector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readUtf8VectorFromUtf16Vector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readUtf8VectorFromUtf16Vector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 55: { std::cout << "ITestService.ReverseUtf8CppStringList()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::std::vector<::std::optional<::std::string>>> in_input; ::std::optional<::std::vector<::std::optional<::std::string>>> out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::optional<::std::vector<::std::optional<::std::string>>> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readUtf8VectorFromUtf16Vector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readUtf8VectorFromUtf16Vector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readUtf8VectorFromUtf16Vector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 56: { std::cout << "ITestService.GetCallback()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } bool in_return_null; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::sp<::android::aidl::tests::INamedCallback> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readNullableStrongBinder(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readBool(&in_return_null); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument return_null from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " return_null: " << ::android::internal::ToString(in_return_null) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 57: { std::cout << "ITestService.FillOutStructuredParcelable()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::aidl::tests::StructuredParcelable in_parcel; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readParcelable(&in_parcel); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument parcel from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " parcel: " << ::android::internal::ToString(in_parcel) << std::endl; std::cout << " return: void" << std::endl; } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 58: { std::cout << "ITestService.RepeatExtendableParcelable()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::aidl::tests::extension::ExtendableParcelable in_ep; ::android::aidl::tests::extension::ExtendableParcelable out_ep2; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readParcelable(&in_ep); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument ep from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readParcelable(&out_ep2); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument ep2 from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " ep: " << ::android::internal::ToString(in_ep) << std::endl; std::cout << " ep2: " << ::android::internal::ToString(out_ep2) << std::endl; std::cout << " return: void" << std::endl; } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 59: { std::cout << "ITestService.ReverseList()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::aidl::tests::RecursiveList in_list; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::aidl::tests::RecursiveList _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readParcelable(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readParcelable(&in_list); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument list from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " list: " << ::android::internal::ToString(in_list) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 60: { std::cout << "ITestService.ReverseIBinderArray()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector<::android::sp<::android::IBinder>> in_input; ::std::vector<::android::sp<::android::IBinder>> out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector<::android::sp<::android::IBinder>> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readStrongBinderVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readStrongBinderVector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 61: { std::cout << "ITestService.ReverseNullableIBinderArray()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::optional<::std::vector<::android::sp<::android::IBinder>>> in_input; ::std::optional<::std::vector<::android::sp<::android::IBinder>>> out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::optional<::std::vector<::android::sp<::android::IBinder>>> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readStrongBinderVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readStrongBinderVector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 62: { std::cout << "ITestService.RepeatSimpleParcelable()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::aidl::tests::SimpleParcelable in_input; ::android::aidl::tests::SimpleParcelable out_repeat; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::aidl::tests::SimpleParcelable _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readParcelable(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readParcelable(&out_repeat); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeat from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeat: " << ::android::internal::ToString(out_repeat) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 63: { std::cout << "ITestService.ReverseSimpleParcelables()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector<::android::aidl::tests::SimpleParcelable> in_input; ::std::vector<::android::aidl::tests::SimpleParcelable> out_repeated; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector<::android::aidl::tests::SimpleParcelable> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readParcelableVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readParcelableVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readParcelableVector(&out_repeated); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument repeated from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; std::cout << " repeated: " << ::android::internal::ToString(out_repeated) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 64: { std::cout << "ITestService.GetOldNameInterface()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::sp<::android::aidl::tests::IOldName> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readStrongBinder(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails } while(false); std::cout << " arguments: " << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 65: { std::cout << "ITestService.GetNewNameInterface()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::sp<::android::aidl::tests::INewName> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readStrongBinder(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails } while(false); std::cout << " arguments: " << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 66: { std::cout << "ITestService.GetUnionTags()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::std::vector<::android::aidl::tests::Union> in_input; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::std::vector<::android::aidl::tests::Union::Tag> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readEnumVector(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readParcelableVector(&in_input); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument input from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " input: " << ::android::internal::ToString(in_input) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 67: { std::cout << "ITestService.GetCppJavaTests()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::sp<::android::IBinder> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readNullableStrongBinder(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails } while(false); std::cout << " arguments: " << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 68: { std::cout << "ITestService.getBackendType()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::aidl::tests::BackendType _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readByte(reinterpret_cast(&_aidl_return)); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails } while(false); std::cout << " arguments: " << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 69: { std::cout << "ITestService.GetCircular()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.ITestService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::aidl::tests::CircularParcelable out_cp; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::sp<::android::aidl::tests::ICircular> _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readStrongBinder(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readParcelable(&out_cp); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument cp from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " cp: " << ::android::internal::ToString(out_cp) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; default: { std::cout << " Transaction code " << _aidl_code << " not known." << std::endl; _aidl_ret_status = android::UNKNOWN_TRANSACTION; } } return _aidl_ret_status; // To prevent unused variable warnings (void)_aidl_ret_status; (void)_aidl_data; (void)_aidl_reply; } } // namespace #include using android::aidl::Analyzer; __attribute__((constructor)) static void addAnalyzer() { Analyzer::installAnalyzer(std::make_unique("android.aidl.tests.ITestService", "ITestService", &analyzeITestService)); } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000222 15172120304 033201 xustar000000000 0000000 118 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ITestService.cpp.d 28 mtime=1776853188.5790000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ITestServi0100644 0000000 0000000 00000002236 15172120304 033115 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ITestService.cpp : \ system/tools/aidl/tests/android/aidl/tests/ITestService.aidl \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ICircular.aidl \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl \ system/tools/aidl/tests/android/aidl/tests/SimpleParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000213 15172120304 033201 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/IntEnum.cpp 28 mtime=1776853188.5790000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/IntEnum.cp0100644 0000000 0000000 00000001276 15172120304 033037 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/IntEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000215 15172120304 033203 xustar000000000 0000000 113 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/IntEnum.cpp.d 28 mtime=1776853188.5790000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/IntEnum.cp0100644 0000000 0000000 00000000264 15172120304 033033 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/IntEnum.cpp : \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000224 15172120304 033203 xustar000000000 0000000 120 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ListOfInterfaces.cpp 28 mtime=1776853188.5790000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ListOfInte0100644 0000000 0000000 00000001320 15172120304 033065 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/ListOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ListOfInterfaces.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000226 15172120304 033205 xustar000000000 0000000 122 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ListOfInterfaces.cpp.d 28 mtime=1776853188.5790000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ListOfInte0100644 0000000 0000000 00000000306 15172120304 033070 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ListOfInterfaces.cpp : \ system/tools/aidl/tests/android/aidl/tests/ListOfInterfaces.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000214 15172120304 033202 xustar000000000 0000000 112 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/LongEnum.cpp 28 mtime=1776853188.5790000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/LongEnum.c0100644 0000000 0000000 00000001300 15172120304 033010 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/LongEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000216 15172120304 033204 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/LongEnum.cpp.d 28 mtime=1776853188.5790000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/LongEnum.c0100644 0000000 0000000 00000000266 15172120304 033022 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/LongEnum.cpp : \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000236 15172120304 033206 xustar000000000 0000000 130 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/OtherParcelableForToString.cpp 28 mtime=1776853188.5790000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/OtherParce0100644 0000000 0000000 00000001344 15172120304 033107 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/OtherParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000240 15172120304 033201 xustar000000000 0000000 132 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/OtherParcelableForToString.cpp.d 28 mtime=1776853188.5790000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/OtherParce0100644 0000000 0000000 00000000332 15172120304 033103 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/OtherParcelableForToString.cpp : \ system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000231 15172120304 033201 xustar000000000 0000000 125 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ParcelableForToString.cpp 28 mtime=1776853188.5790000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/Parcelable0100644 0000000 0000000 00000001332 15172120304 033102 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/ParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ParcelableForToString.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000233 15172120304 033203 xustar000000000 0000000 127 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ParcelableForToString.cpp.d 28 mtime=1776853188.5790000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/Parcelable0100644 0000000 0000000 00000001363 15172120304 033106 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/ParcelableForToString.cpp : \ system/tools/aidl/tests/android/aidl/tests/ParcelableForToString.aidl \ system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000221 15172120304 033200 xustar000000000 0000000 117 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/RecursiveList.cpp 28 mtime=1776853188.5790000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/RecursiveL0100644 0000000 0000000 00000001312 15172120304 033131 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/RecursiveList.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000223 15172120304 033202 xustar000000000 0000000 119 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/RecursiveList.cpp.d 28 mtime=1776853188.5790000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/RecursiveL0100644 0000000 0000000 00000000300 15172120304 033125 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/RecursiveList.cpp : \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000230 15172120304 033200 xustar000000000 0000000 124 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/StructuredParcelable.cpp 28 mtime=1776853188.5790000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/Structured0100644 0000000 0000000 00000001330 15172120304 033212 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/StructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000232 15172120304 033202 xustar000000000 0000000 126 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/StructuredParcelable.cpp.d 28 mtime=1776853188.5800000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/Structured0100644 0000000 0000000 00000001011 15172120304 033206 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/StructuredParcelable.cpp : \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 033202 xustar000000000 0000000 28 mtime=1776853188.5800000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/Union.cpp0100644 0000000 0000000 00000001272 15172120304 032724 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/Union.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/Union.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000213 15172120304 033201 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/Union.cpp.d 28 mtime=1776853188.5800000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/Union.cpp.0100644 0000000 0000000 00000000355 15172120304 033003 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/Union.cpp : \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000217 15172120304 033205 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/UnionWithFd.cpp 28 mtime=1776853188.5800000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/UnionWithF0100644 0000000 0000000 00000001306 15172120304 033103 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/UnionWithFd.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/UnionWithFd.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000221 15172120304 033200 xustar000000000 0000000 117 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/UnionWithFd.cpp.d 28 mtime=1776853188.5800000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/UnionWithF0100644 0000000 0000000 00000000274 15172120304 033106 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/UnionWithFd.cpp : \ system/tools/aidl/tests/android/aidl/tests/UnionWithFd.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000212 15172120304 033200 xustar000000000 0000000 110 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/ 28 mtime=1776853188.5800000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/0040755 0000000 0000000 00000000000 15172120304 033145 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000242 15172120304 033203 xustar000000000 0000000 134 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/ExtendableParcelable.cpp 28 mtime=1776853188.5800000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/0100644 0000000 0000000 00000001354 15172120304 033147 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/extension/ExtendableParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000244 15172120304 033205 xustar000000000 0000000 136 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/ExtendableParcelable.cpp.d 28 mtime=1776853188.5800000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/0100644 0000000 0000000 00000000342 15172120304 033143 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/ExtendableParcelable.cpp : \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000223 15172120304 033202 xustar000000000 0000000 119 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/MyExt.cpp 28 mtime=1776853188.5800000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/0100644 0000000 0000000 00000001316 15172120304 033145 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/extension/MyExt.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000225 15172120304 033204 xustar000000000 0000000 121 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/MyExt.cpp.d 28 mtime=1776853188.5800000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/0100644 0000000 0000000 00000000304 15172120304 033141 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/MyExt.cpp : \ system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000224 15172120304 033203 xustar000000000 0000000 120 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/MyExt2.cpp 28 mtime=1776853188.5800000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/0100644 0000000 0000000 00000001320 15172120304 033140 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/extension/MyExt2.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt2.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000226 15172120304 033205 xustar000000000 0000000 122 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/MyExt2.cpp.d 28 mtime=1776853188.5800000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/0100644 0000000 0000000 00000000412 15172120304 033141 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/MyExt2.cpp : \ system/tools/aidl/tests/android/aidl/tests/extension/MyExt2.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000227 15172120304 033206 xustar000000000 0000000 123 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/MyExtLike.cpp 28 mtime=1776853188.5810000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/0100644 0000000 0000000 00000001326 15172120304 033146 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/extension/MyExtLike.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExtLike.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000231 15172120304 033201 xustar000000000 0000000 125 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/MyExtLike.cpp.d 28 mtime=1776853188.5810000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/0100644 0000000 0000000 00000000314 15172120304 033142 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/extension/MyExtLike.cpp : \ system/tools/aidl/tests/android/aidl/tests/extension/MyExtLike.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 033202 xustar000000000 0000000 28 mtime=1776853188.5820000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/nested/0040755 0000000 0000000 00000000000 15172120304 032413 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000227 15172120304 033206 xustar000000000 0000000 123 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/nested/DeeplyNested.cpp 28 mtime=1776853188.5820000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/nested/Dee0100644 0000000 0000000 00000001326 15172120304 033032 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/nested/DeeplyNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/DeeplyNested.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000231 15172120304 033201 xustar000000000 0000000 125 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/nested/DeeplyNested.cpp.d 28 mtime=1776853188.5820000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/nested/Dee0100644 0000000 0000000 00000000314 15172120304 033026 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/nested/DeeplyNested.cpp : \ system/tools/aidl/tests/android/aidl/tests/nested/DeeplyNested.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000231 15172120304 033201 xustar000000000 0000000 125 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/nested/INestedService.cpp 28 mtime=1776853188.5820000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/nested/INe0100644 0000000 0000000 00000012032 15172120304 033004 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/nested/INestedService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/INestedService.aidl */ #include #include #include #include namespace { android::status_t analyzeINestedService(uint32_t _aidl_code, const android::Parcel& _aidl_data, const android::Parcel& _aidl_reply) { android::status_t _aidl_ret_status; switch(_aidl_code) { case ::android::IBinder::FIRST_CALL_TRANSACTION + 0: { std::cout << "INestedService.flipStatus()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.nested.INestedService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::aidl::tests::nested::ParcelableWithNested in_p; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); ::android::aidl::tests::nested::INestedService::Result _aidl_return; bool returnError = false; _aidl_ret_status = _aidl_reply.readParcelable(&_aidl_return); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading return value from Parcel." << std::endl; returnError = true; } do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readParcelable(&in_p); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument p from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " p: " << ::android::internal::ToString(in_p) << std::endl; if (returnError) { std::cout << " return: " << std::endl; } else {std::cout << " return: " << ::android::internal::ToString(_aidl_return) << std::endl; } } break; case ::android::IBinder::FIRST_CALL_TRANSACTION + 1: { std::cout << "INestedService.flipStatusWithCallback()" << std::endl; _aidl_ret_status = ::android::OK; if (!(_aidl_data.enforceInterface(android::String16("android.aidl.tests.nested.INestedService")))) { _aidl_ret_status = ::android::BAD_TYPE; std::cout << " Failure: Parcel interface does not match." << std::endl; break; } ::android::aidl::tests::nested::ParcelableWithNested::Status in_status; ::android::sp<::android::aidl::tests::nested::INestedService::ICallback> in_cb; ::android::binder::Status binderStatus; binderStatus.readFromParcel(_aidl_reply); do { // Single-pass loop to break if argument reading fails _aidl_ret_status = _aidl_data.readByte(reinterpret_cast(&in_status)); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument status from Parcel." << std::endl; break; } _aidl_ret_status = _aidl_data.readStrongBinder(&in_cb); if (((_aidl_ret_status) != (android::NO_ERROR))) { std::cerr << "Failure: error in reading argument cb from Parcel." << std::endl; break; } } while(false); if (!_aidl_data.enforceNoDataAvail().isOk()) { _aidl_ret_status = android::BAD_VALUE; std::cout << " Failure: Parcel has too much data." << std::endl; break; } std::cout << " arguments: " << std::endl; std::cout << " status: " << ::android::internal::ToString(in_status) << std::endl; std::cout << " cb: " << ::android::internal::ToString(in_cb) << std::endl; std::cout << " return: void" << std::endl; } break; default: { std::cout << " Transaction code " << _aidl_code << " not known." << std::endl; _aidl_ret_status = android::UNKNOWN_TRANSACTION; } } return _aidl_ret_status; // To prevent unused variable warnings (void)_aidl_ret_status; (void)_aidl_data; (void)_aidl_reply; } } // namespace #include using android::aidl::Analyzer; __attribute__((constructor)) static void addAnalyzer() { Analyzer::installAnalyzer(std::make_unique("android.aidl.tests.nested.INestedService", "INestedService", &analyzeINestedService)); } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000233 15172120304 033203 xustar000000000 0000000 127 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/nested/INestedService.cpp.d 28 mtime=1776853188.5820000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/nested/INe0100644 0000000 0000000 00000000440 15172120304 033004 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/nested/INestedService.cpp : \ system/tools/aidl/tests/android/aidl/tests/nested/INestedService.aidl \ system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000237 15172120304 033207 xustar000000000 0000000 131 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/nested/ParcelableWithNested.cpp 28 mtime=1776853188.5820000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/nested/Par0100644 0000000 0000000 00000001346 15172120304 033061 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/nested/ParcelableWithNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000241 15172120304 033202 xustar000000000 0000000 133 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/nested/ParcelableWithNested.cpp.d 28 mtime=1776853188.5820000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/nested/Par0100644 0000000 0000000 00000000334 15172120304 033055 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/nested/ParcelableWithNested.cpp : \ system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 033202 xustar000000000 0000000 28 mtime=1776853188.5820000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/unions/0040755 0000000 0000000 00000000000 15172120304 032444 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000224 15172120304 033203 xustar000000000 0000000 120 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/unions/EnumUnion.cpp 28 mtime=1776853188.5820000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/unions/Enu0100644 0000000 0000000 00000001320 15172120304 033107 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/unions/EnumUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000226 15172120304 033205 xustar000000000 0000000 122 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/unions/EnumUnion.cpp.d 28 mtime=1776853188.5820000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/unions/Enu0100644 0000000 0000000 00000000477 15172120304 033123 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/unions/EnumUnion.cpp : \ system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000227 15172120304 033206 xustar000000000 0000000 123 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/unions/UnionInUnion.cpp 28 mtime=1776853188.5820000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/unions/Uni0100644 0000000 0000000 00000001326 15172120304 033121 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp-analyzer -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging/android/aidl/tests/unions/UnionInUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/UnionInUnion.aidl */ // This file is intentionally left blank as placeholder for building an analyzer. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_android_aidl_0100644 0000000 0000000 00000000231 15172120304 033201 xustar000000000 0000000 125 path=tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/unions/UnionInUnion.cpp.d 28 mtime=1776853188.5820000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/unions/Uni0100644 0000000 0000000 00000000612 15172120304 033116 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-analyzer-source/gen/android/aidl/tests/unions/UnionInUnion.cpp : \ system/tools/aidl/tests/android/aidl/tests/unions/UnionInUnion.aidl \ system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-analyzer-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 032435 xustar000000000 0000000 28 mtime=1776853188.5820000 tests/golden_output/frozen/aidl-test-interface-cpp-analyzer-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 027347 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_0100644 0000000 0000000 00000000034 15172120304 026035 xustar000000000 0000000 28 mtime=1776853188.5820000 tests/golden_output/frozen/aidl-test-interface-cpp-source/0040755 0000000 0000000 00000000000 15172120304 023042 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_0100644 0000000 0000000 00000000034 15172120304 026666 xustar000000000 0000000 28 mtime=1776853188.5820000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/0040755 0000000 0000000 00000000000 15172120304 023613 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 030366 xustar000000000 0000000 28 mtime=1776853188.5820000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 025233 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 031357 xustar000000000 0000000 28 mtime=1776853188.5820000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 026144 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_0100644 0000000 0000000 00000000034 15172120304 032601 xustar000000000 0000000 28 mtime=1776853188.5820000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/0040755 0000000 0000000 00000000000 15172120304 027306 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Arr0100644 0000000 0000000 00000000214 15172120304 033246 xustar000000000 0000000 112 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/ArrayOfInterfaces.cpp 28 mtime=1776853188.5830000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/ArrayOfInterfaces.c0100644 0000000 0000000 00000050534 15172120304 033025 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ArrayOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ArrayOfInterfaces.aidl */ #include namespace android { namespace aidl { namespace tests { ::android::status_t ArrayOfInterfaces::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t ArrayOfInterfaces::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android #include #include namespace android { namespace aidl { namespace tests { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_NESTED_INTERFACE(ArrayOfInterfaces, EmptyInterface, "android.aidl.tests.ArrayOfInterfaces.IEmptyInterface") } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { ArrayOfInterfaces::BpEmptyInterface::BpEmptyInterface(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { ArrayOfInterfaces::BnEmptyInterface::BnEmptyInterface() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t ArrayOfInterfaces::BnEmptyInterface::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android #include #include namespace android { namespace aidl { namespace tests { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_NESTED_INTERFACE(ArrayOfInterfaces, MyInterface, "android.aidl.tests.ArrayOfInterfaces.IMyInterface") } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { ArrayOfInterfaces::BpMyInterface::BpMyInterface(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } ::android::binder::Status ArrayOfInterfaces::BpMyInterface::methodWithInterfaces(const ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& iface, const ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& nullable_iface, const ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>& iface_array_in, ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>* iface_array_out, ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>* iface_array_inout, const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>& nullable_iface_array_in, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>* nullable_iface_array_out, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>* nullable_iface_array_inout, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyInterface::methodWithInterfaces::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinder(iface); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinder(nullable_iface); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinderVector(iface_array_in); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*iface_array_out); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinderVector(*iface_array_inout); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinderVector(nullable_iface_array_in); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*nullable_iface_array_out); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinderVector(*nullable_iface_array_inout); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(ArrayOfInterfaces::BnMyInterface::TRANSACTION_methodWithInterfaces, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IMyInterface::getDefaultImpl()) [[unlikely]] { return IMyInterface::getDefaultImpl()->methodWithInterfaces(iface, nullable_iface, iface_array_in, iface_array_out, iface_array_inout, nullable_iface_array_in, nullable_iface_array_out, nullable_iface_array_inout, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(iface_array_out); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(iface_array_inout); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(nullable_iface_array_out); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(nullable_iface_array_inout); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { ArrayOfInterfaces::BnMyInterface::BnMyInterface() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t ArrayOfInterfaces::BnMyInterface::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnMyInterface::TRANSACTION_methodWithInterfaces: { ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface> in_iface; ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface> in_nullable_iface; ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>> in_iface_array_in; ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>> out_iface_array_out; ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>> in_iface_array_inout; ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>> in_nullable_iface_array_in; ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>> out_nullable_iface_array_out; ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>> in_nullable_iface_array_inout; ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyInterface::methodWithInterfaces::cppServer"); _aidl_ret_status = _aidl_data.readStrongBinder(&in_iface); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readNullableStrongBinder(&in_nullable_iface); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_iface_array_in); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_iface_array_out); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_iface_array_inout); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_nullable_iface_array_in); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_nullable_iface_array_out); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_nullable_iface_array_inout); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(methodWithInterfaces(in_iface, in_nullable_iface, in_iface_array_in, &out_iface_array_out, &in_iface_array_inout, in_nullable_iface_array_in, &out_nullable_iface_array_out, &in_nullable_iface_array_inout, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(out_iface_array_out); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(in_iface_array_inout); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(out_nullable_iface_array_out); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(in_nullable_iface_array_inout); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { ::android::status_t ArrayOfInterfaces::MyParcelable::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readStrongBinder(&iface); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readNullableStrongBinder(&nullable_iface); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readStrongBinderVector(&iface_array); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readStrongBinderVector(&nullable_iface_array); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t ArrayOfInterfaces::MyParcelable::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeStrongBinder(iface); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeStrongBinder(nullable_iface); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeStrongBinderVector(iface_array); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeStrongBinderVector(nullable_iface_array); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { ::android::status_t ArrayOfInterfaces::MyUnion::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_tag)) != ::android::OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case iface: { ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface> _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readStrongBinder(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case nullable_iface: { ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface> _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readNullableStrongBinder(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case iface_array: { ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>> _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readStrongBinderVector(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case nullable_iface_array: { ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>> _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readStrongBinderVector(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } } return ::android::BAD_VALUE; } ::android::status_t ArrayOfInterfaces::MyUnion::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(getTag())); if (_aidl_ret_status != ::android::OK) return _aidl_ret_status; switch (getTag()) { case iface: return _aidl_parcel->writeStrongBinder(get()); case nullable_iface: return _aidl_parcel->writeStrongBinder(get()); case iface_array: return _aidl_parcel->writeStrongBinderVector(get()); case nullable_iface_array: return _aidl_parcel->writeStrongBinderVector(get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Arr0100644 0000000 0000000 00000000216 15172120304 033250 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/ArrayOfInterfaces.cpp.d 28 mtime=1776853188.5830000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/ArrayOfInterfaces.c0100644 0000000 0000000 00000000277 15172120304 033024 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/ArrayOfInterfaces.cpp : \ system/tools/aidl/tests/android/aidl/tests/ArrayOfInterfaces.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Bac0100644 0000000 0000000 00000000034 15172120304 033207 xustar000000000 0000000 28 mtime=1776853188.5830000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/BackendType.cpp0100644 0000000 0000000 00000001241 15172120304 032176 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/BackendType.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/BackendType.aidl */ // This file is intentionally left blank as placeholder for enum declaration. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Bac0100644 0000000 0000000 00000000034 15172120304 033207 xustar000000000 0000000 28 mtime=1776853188.5830000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/BackendType.cpp.d0100644 0000000 0000000 00000000263 15172120304 032423 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/BackendType.cpp : \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Byt0100644 0000000 0000000 00000000034 15172120304 033260 xustar000000000 0000000 28 mtime=1776853188.5830000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/ByteEnum.cpp0100644 0000000 0000000 00000001233 15172120304 031536 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ByteEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl */ // This file is intentionally left blank as placeholder for enum declaration. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Byt0100644 0000000 0000000 00000000034 15172120304 033260 xustar000000000 0000000 28 mtime=1776853188.5830000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/ByteEnum.cpp.d0100644 0000000 0000000 00000000255 15172120304 031763 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/ByteEnum.cpp : \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Cir0100644 0000000 0000000 00000000215 15172120304 033240 xustar000000000 0000000 113 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/CircularParcelable.cpp 28 mtime=1776853188.5830000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/CircularParcelable.0100644 0000000 0000000 00000004737 15172120304 033036 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/CircularParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl */ #include namespace android { namespace aidl { namespace tests { ::android::status_t CircularParcelable::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readNullableStrongBinder(&testService); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t CircularParcelable::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeStrongBinder(testService); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Cir0100644 0000000 0000000 00000000217 15172120304 033242 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/CircularParcelable.cpp.d 28 mtime=1776853188.5830000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/CircularParcelable.0100644 0000000 0000000 00000002233 15172120304 033023 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/CircularParcelable.cpp : \ system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ITestService.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl \ system/tools/aidl/tests/android/aidl/tests/SimpleParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl \ system/tools/aidl/tests/android/aidl/tests/ICircular.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Con0100644 0000000 0000000 00000000221 15172120304 033237 xustar000000000 0000000 117 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/ConstantExpressionEnum.cpp 28 mtime=1776853188.5830000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/ConstantExpressionE0100644 0000000 0000000 00000001267 15172120304 033212 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ConstantExpressionEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl */ // This file is intentionally left blank as placeholder for enum declaration. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Con0100644 0000000 0000000 00000000223 15172120304 033241 xustar000000000 0000000 119 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/ConstantExpressionEnum.cpp.d 28 mtime=1776853188.5830000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/ConstantExpressionE0100644 0000000 0000000 00000000311 15172120304 033177 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/ConstantExpressionEnum.cpp : \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Dep0100644 0000000 0000000 00000000034 15172120304 033232 xustar000000000 0000000 28 mtime=1776853188.5840000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/DeprecatedEnum.cpp0100644 0000000 0000000 00000001247 15172120304 032700 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/DeprecatedEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedEnum.aidl */ // This file is intentionally left blank as placeholder for enum declaration. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Dep0100644 0000000 0000000 00000000213 15172120304 033231 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/DeprecatedEnum.cpp.d 28 mtime=1776853188.5840000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/DeprecatedEnum.cpp.0100644 0000000 0000000 00000000271 15172120304 032752 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/DeprecatedEnum.cpp : \ system/tools/aidl/tests/android/aidl/tests/DeprecatedEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Dep0100644 0000000 0000000 00000000217 15172120304 033235 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/DeprecatedParcelable.cpp 28 mtime=1776853188.5840000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/DeprecatedParcelabl0100644 0000000 0000000 00000003771 15172120304 033104 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/DeprecatedParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedParcelable.aidl */ #include namespace android { namespace aidl { namespace tests { ::android::status_t DeprecatedParcelable::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t DeprecatedParcelable::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Dep0100644 0000000 0000000 00000000221 15172120304 033230 xustar000000000 0000000 117 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/DeprecatedParcelable.cpp.d 28 mtime=1776853188.5840000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/DeprecatedParcelabl0100644 0000000 0000000 00000000305 15172120304 033072 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/DeprecatedParcelable.cpp : \ system/tools/aidl/tests/android/aidl/tests/DeprecatedParcelable.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Fix0100644 0000000 0000000 00000000034 15172120304 033250 xustar000000000 0000000 28 mtime=1776853188.5840000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/FixedSize.cpp0100644 0000000 0000000 00000030174 15172120304 031706 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/FixedSize.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/FixedSize.aidl */ #include namespace android { namespace aidl { namespace tests { ::android::status_t FixedSize::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t FixedSize::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { ::android::status_t FixedSize::FixedParcelable::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readBool(&booleanValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readByte(&byteValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readChar(&charValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&intValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt64(&longValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFloat(&floatValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readDouble(&doubleValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt64(reinterpret_cast(&enumValue)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelable(&parcelableValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t FixedSize::FixedParcelable::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeBool(booleanValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeByte(byteValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeChar(charValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(intValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt64(longValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFloat(floatValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeDouble(doubleValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt64(static_cast(enumValue)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelable(parcelableValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { ::android::status_t FixedSize::FixedUnion::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_tag)) != ::android::OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case booleanValue: { bool _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readBool(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case byteValue: { int8_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readByte(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case charValue: { char16_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readChar(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case intValue: { int32_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case longValue: { int64_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt64(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case floatValue: { float _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readFloat(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case doubleValue: { double _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readDouble(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case enumValue: { ::android::aidl::tests::LongEnum _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt64(reinterpret_cast(&_aidl_value))) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::android::aidl::tests::LongEnum>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } } return ::android::BAD_VALUE; } ::android::status_t FixedSize::FixedUnion::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(getTag())); if (_aidl_ret_status != ::android::OK) return _aidl_ret_status; switch (getTag()) { case booleanValue: return _aidl_parcel->writeBool(get()); case byteValue: return _aidl_parcel->writeByte(get()); case charValue: return _aidl_parcel->writeChar(get()); case intValue: return _aidl_parcel->writeInt32(get()); case longValue: return _aidl_parcel->writeInt64(get()); case floatValue: return _aidl_parcel->writeFloat(get()); case doubleValue: return _aidl_parcel->writeDouble(get()); case enumValue: return _aidl_parcel->writeInt64(static_cast(get())); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Fix0100644 0000000 0000000 00000000034 15172120304 033250 xustar000000000 0000000 28 mtime=1776853188.5860000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/FixedSize.cpp.d0100644 0000000 0000000 00000000354 15172120304 032125 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/FixedSize.cpp : \ system/tools/aidl/tests/android/aidl/tests/FixedSize.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Gen0100644 0000000 0000000 00000000226 15172120304 033236 xustar000000000 0000000 122 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/GenericStructuredParcelable.cpp 28 mtime=1776853188.5860000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/GenericStructuredPa0100644 0000000 0000000 00000001164 15172120304 033152 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/GenericStructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl */ ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Gen0100644 0000000 0000000 00000000230 15172120304 033231 xustar000000000 0000000 124 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/GenericStructuredParcelable.cpp.d 28 mtime=1776853188.5860000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/GenericStructuredPa0100644 0000000 0000000 00000000323 15172120304 033146 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/GenericStructuredParcelable.cpp : \ system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_ICi0100644 0000000 0000000 00000000034 15172120304 033166 xustar000000000 0000000 28 mtime=1776853188.5860000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/ICircular.cpp0100644 0000000 0000000 00000010343 15172120304 031665 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ICircular.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ICircular.aidl */ #include #include namespace android { namespace aidl { namespace tests { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE(Circular, "android.aidl.tests.ICircular") } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { BpCircular::BpCircular(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } ::android::binder::Status BpCircular::GetTestService(::android::sp<::android::aidl::tests::ITestService>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICircular::GetTestService::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnCircular::TRANSACTION_GetTestService, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ICircular::getDefaultImpl()) [[unlikely]] { return ICircular::getDefaultImpl()->GetTestService(_aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readNullableStrongBinder(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { BnCircular::BnCircular() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t BnCircular::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnCircular::TRANSACTION_GetTestService: { ::android::sp<::android::aidl::tests::ITestService> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICircular::GetTestService::cppServer"); ::android::binder::Status _aidl_status(GetTestService(&_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinder(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_ICi0100644 0000000 0000000 00000000034 15172120304 033166 xustar000000000 0000000 28 mtime=1776853188.5870000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/ICircular.cpp.d0100644 0000000 0000000 00000002222 15172120304 032104 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/ICircular.cpp : \ system/tools/aidl/tests/android/aidl/tests/ICircular.aidl \ system/tools/aidl/tests/android/aidl/tests/ITestService.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl \ system/tools/aidl/tests/android/aidl/tests/SimpleParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl \ system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_IDe0100644 0000000 0000000 00000000034 15172120304 033163 xustar000000000 0000000 28 mtime=1776853188.5870000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/IDeprecated.cpp0100644 0000000 0000000 00000004402 15172120304 032160 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/IDeprecated.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IDeprecated.aidl */ #include #include namespace android { namespace aidl { namespace tests { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE(Deprecated, "android.aidl.tests.IDeprecated") } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { BpDeprecated::BpDeprecated(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { BnDeprecated::BnDeprecated() { ::android::internal::Stability::markCompilationUnit(this); } #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated" ::android::status_t BnDeprecated::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } #pragma clang diagnostic pop } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_IDe0100644 0000000 0000000 00000000034 15172120304 033163 xustar000000000 0000000 28 mtime=1776853188.5870000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/IDeprecated.cpp.d0100644 0000000 0000000 00000000263 15172120304 032403 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/IDeprecated.cpp : \ system/tools/aidl/tests/android/aidl/tests/IDeprecated.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_INa0100644 0000000 0000000 00000000034 15172120304 033171 xustar000000000 0000000 28 mtime=1776853188.5870000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/INamedCallback.cpp0100644 0000000 0000000 00000010320 15172120304 032555 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/INamedCallback.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl */ #include #include namespace android { namespace aidl { namespace tests { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE(NamedCallback, "android.aidl.tests.INamedCallback") } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { BpNamedCallback::BpNamedCallback(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } ::android::binder::Status BpNamedCallback::GetName(::android::String16* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::INamedCallback::GetName::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnNamedCallback::TRANSACTION_GetName, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && INamedCallback::getDefaultImpl()) [[unlikely]] { return INamedCallback::getDefaultImpl()->GetName(_aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readString16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { BnNamedCallback::BnNamedCallback() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t BnNamedCallback::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnNamedCallback::TRANSACTION_GetName: { ::android::String16 _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::INamedCallback::GetName::cppServer"); ::android::binder::Status _aidl_status(GetName(&_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeString16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_INa0100644 0000000 0000000 00000000213 15172120304 033170 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/INamedCallback.cpp.d 28 mtime=1776853188.5870000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/INamedCallback.cpp.0100644 0000000 0000000 00000000271 15172120304 032637 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/INamedCallback.cpp : \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_INe0100644 0000000 0000000 00000000034 15172120304 033175 xustar000000000 0000000 28 mtime=1776853188.5870000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/INewName.cpp0100644 0000000 0000000 00000010123 15172120304 031447 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/INewName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INewName.aidl */ #include #include namespace android { namespace aidl { namespace tests { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE(NewName, "android.aidl.tests.IOldName") } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { BpNewName::BpNewName(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } ::android::binder::Status BpNewName::RealName(::android::String16* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::INewName::RealName::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnNewName::TRANSACTION_RealName, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && INewName::getDefaultImpl()) [[unlikely]] { return INewName::getDefaultImpl()->RealName(_aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readString16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { BnNewName::BnNewName() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t BnNewName::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnNewName::TRANSACTION_RealName: { ::android::String16 _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::INewName::RealName::cppServer"); ::android::binder::Status _aidl_status(RealName(&_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeString16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_INe0100644 0000000 0000000 00000000034 15172120304 033175 xustar000000000 0000000 28 mtime=1776853188.5870000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/INewName.cpp.d0100644 0000000 0000000 00000000255 15172120304 031676 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/INewName.cpp : \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_IOl0100644 0000000 0000000 00000000034 15172120304 033205 xustar000000000 0000000 28 mtime=1776853188.5870000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/IOldName.cpp0100644 0000000 0000000 00000010123 15172120304 031434 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/IOldName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IOldName.aidl */ #include #include namespace android { namespace aidl { namespace tests { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE(OldName, "android.aidl.tests.IOldName") } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { BpOldName::BpOldName(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } ::android::binder::Status BpOldName::RealName(::android::String16* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IOldName::RealName::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnOldName::TRANSACTION_RealName, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IOldName::getDefaultImpl()) [[unlikely]] { return IOldName::getDefaultImpl()->RealName(_aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readString16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { BnOldName::BnOldName() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t BnOldName::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnOldName::TRANSACTION_RealName: { ::android::String16 _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IOldName::RealName::cppServer"); ::android::binder::Status _aidl_status(RealName(&_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeString16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_IOl0100644 0000000 0000000 00000000034 15172120304 033205 xustar000000000 0000000 28 mtime=1776853188.5870000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/IOldName.cpp.d0100644 0000000 0000000 00000000255 15172120304 031663 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/IOldName.cpp : \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_ITe0100644 0000000 0000000 00000000034 15172120304 033203 xustar000000000 0000000 28 mtime=1776853188.5880000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/ITestService.cpp0100644 0000000 0000000 00000703163 15172120304 032372 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ITestService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ITestService.aidl */ #include #include namespace android { namespace aidl { namespace tests { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE(TestService, "android.aidl.tests.ITestService") const ::android::String16& ITestService::STRING_CONSTANT() { static const ::android::String16 value(::android::String16("foo")); return value; } const ::android::String16& ITestService::STRING_CONSTANT2() { static const ::android::String16 value(::android::String16("bar")); return value; } const ::std::string& ITestService::STRING_CONSTANT_UTF8() { static const ::std::string value("baz"); return value; } } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { BpTestService::BpTestService(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } ::android::binder::Status BpTestService::UnimplementedMethod(int32_t arg, int32_t* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::UnimplementedMethod::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeInt32(arg); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_UnimplementedMethod, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->UnimplementedMethod(arg, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readInt32(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::Deprecated() { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::Deprecated::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_Deprecated, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->Deprecated(); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::TestOneway() { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::TestOneway::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_TestOneway, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_ONEWAY | ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->TestOneway(); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatBoolean(bool token, bool* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatBoolean::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeBool(token); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatBoolean, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatBoolean(token, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readBool(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatByte(int8_t token, int8_t* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatByte::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeByte(token); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatByte, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatByte(token, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readByte(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatChar(char16_t token, char16_t* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatChar::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeChar(token); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatChar, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatChar(token, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readChar(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatInt(int32_t token, int32_t* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatInt::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeInt32(token); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatInt, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatInt(token, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readInt32(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatLong(int64_t token, int64_t* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatLong::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeInt64(token); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatLong, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatLong(token, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readInt64(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatFloat(float token, float* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatFloat::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeFloat(token); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatFloat, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatFloat(token, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readFloat(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatDouble(double token, double* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatDouble::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeDouble(token); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatDouble, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatDouble(token, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readDouble(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatString(const ::android::String16& token, ::android::String16* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatString::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeString16(token); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatString, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatString(token, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readString16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatByteEnum(::android::aidl::tests::ByteEnum token, ::android::aidl::tests::ByteEnum* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatByteEnum::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeByte(static_cast(token)); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatByteEnum, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatByteEnum(token, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readByte(reinterpret_cast(_aidl_return)); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatIntEnum(::android::aidl::tests::IntEnum token, ::android::aidl::tests::IntEnum* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatIntEnum::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeInt32(static_cast(token)); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatIntEnum, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatIntEnum(token, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readInt32(reinterpret_cast(_aidl_return)); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatLongEnum(::android::aidl::tests::LongEnum token, ::android::aidl::tests::LongEnum* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatLongEnum::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeInt64(static_cast(token)); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatLongEnum, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatLongEnum(token, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readInt64(reinterpret_cast(_aidl_return)); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseBoolean(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseBoolean::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeBoolVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseBoolean, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseBoolean(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readBoolVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readBoolVector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseByte(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseByte::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeByteVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseByte, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseByte(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readByteVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readByteVector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseChar(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseChar::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeCharVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseChar, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseChar(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readCharVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readCharVector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseInt(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseInt::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeInt32Vector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseInt, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseInt(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readInt32Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readInt32Vector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseLong(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseLong::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeInt64Vector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseLong, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseLong(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readInt64Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readInt64Vector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseFloat(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseFloat::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeFloatVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseFloat, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseFloat(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readFloatVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readFloatVector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseDouble(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseDouble::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeDoubleVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseDouble, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseDouble(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readDoubleVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readDoubleVector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseString(const ::std::vector<::android::String16>& input, ::std::vector<::android::String16>* repeated, ::std::vector<::android::String16>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseString::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeString16Vector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseString, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseString(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readString16Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readString16Vector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseByteEnum(const ::std::vector<::android::aidl::tests::ByteEnum>& input, ::std::vector<::android::aidl::tests::ByteEnum>* repeated, ::std::vector<::android::aidl::tests::ByteEnum>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseByteEnum::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeEnumVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseByteEnum, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseByteEnum(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readEnumVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readEnumVector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseIntEnum(const ::std::vector<::android::aidl::tests::IntEnum>& input, ::std::vector<::android::aidl::tests::IntEnum>* repeated, ::std::vector<::android::aidl::tests::IntEnum>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseIntEnum::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeEnumVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseIntEnum, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseIntEnum(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readEnumVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readEnumVector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseLongEnum(const ::std::vector<::android::aidl::tests::LongEnum>& input, ::std::vector<::android::aidl::tests::LongEnum>* repeated, ::std::vector<::android::aidl::tests::LongEnum>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseLongEnum::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeEnumVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseLongEnum, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseLongEnum(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readEnumVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readEnumVector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::GetOtherTestService(const ::android::String16& name, ::android::sp<::android::aidl::tests::INamedCallback>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetOtherTestService::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeString16(name); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_GetOtherTestService, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->GetOtherTestService(name, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readStrongBinder(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::SetOtherTestService(const ::android::String16& name, const ::android::sp<::android::aidl::tests::INamedCallback>& service, bool* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::SetOtherTestService::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeString16(name); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinder(service); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_SetOtherTestService, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->SetOtherTestService(name, service, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readBool(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::VerifyName(const ::android::sp<::android::aidl::tests::INamedCallback>& service, const ::android::String16& name, bool* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::VerifyName::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinder(service); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeString16(name); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_VerifyName, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->VerifyName(service, name, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readBool(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::GetInterfaceArray(const ::std::vector<::android::String16>& names, ::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetInterfaceArray::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeString16Vector(names); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_GetInterfaceArray, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->GetInterfaceArray(names, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::VerifyNamesWithInterfaceArray(const ::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>& services, const ::std::vector<::android::String16>& names, bool* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::VerifyNamesWithInterfaceArray::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinderVector(services); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeString16Vector(names); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_VerifyNamesWithInterfaceArray, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->VerifyNamesWithInterfaceArray(services, names, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readBool(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::GetNullableInterfaceArray(const ::std::optional<::std::vector<::std::optional<::android::String16>>>& names, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetNullableInterfaceArray::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeString16Vector(names); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_GetNullableInterfaceArray, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->GetNullableInterfaceArray(names, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::VerifyNamesWithNullableInterfaceArray(const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>& services, const ::std::optional<::std::vector<::std::optional<::android::String16>>>& names, bool* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::VerifyNamesWithNullableInterfaceArray::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinderVector(services); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeString16Vector(names); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_VerifyNamesWithNullableInterfaceArray, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->VerifyNamesWithNullableInterfaceArray(services, names, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readBool(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::GetInterfaceList(const ::std::optional<::std::vector<::std::optional<::android::String16>>>& names, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetInterfaceList::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeString16Vector(names); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_GetInterfaceList, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->GetInterfaceList(names, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::VerifyNamesWithInterfaceList(const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>& services, const ::std::optional<::std::vector<::std::optional<::android::String16>>>& names, bool* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::VerifyNamesWithInterfaceList::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinderVector(services); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeString16Vector(names); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_VerifyNamesWithInterfaceList, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->VerifyNamesWithInterfaceList(services, names, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readBool(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseStringList(const ::std::vector<::android::String16>& input, ::std::vector<::android::String16>* repeated, ::std::vector<::android::String16>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseStringList::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeString16Vector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseStringList, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseStringList(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readString16Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readString16Vector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatParcelFileDescriptor(const ::android::os::ParcelFileDescriptor& read, ::android::os::ParcelFileDescriptor* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatParcelFileDescriptor::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(read); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatParcelFileDescriptor, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatParcelFileDescriptor(read, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseParcelFileDescriptorArray(const ::std::vector<::android::os::ParcelFileDescriptor>& input, ::std::vector<::android::os::ParcelFileDescriptor>* repeated, ::std::vector<::android::os::ParcelFileDescriptor>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseParcelFileDescriptorArray::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelableVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseParcelFileDescriptorArray, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseParcelFileDescriptorArray(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelableVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readParcelableVector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ThrowServiceException(int32_t code) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ThrowServiceException::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeInt32(code); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ThrowServiceException, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ThrowServiceException(code); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatNullableIntArray(const ::std::optional<::std::vector>& input, ::std::optional<::std::vector>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableIntArray::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeInt32Vector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatNullableIntArray, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatNullableIntArray(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readInt32Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatNullableByteEnumArray(const ::std::optional<::std::vector<::android::aidl::tests::ByteEnum>>& input, ::std::optional<::std::vector<::android::aidl::tests::ByteEnum>>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableByteEnumArray::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeEnumVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatNullableByteEnumArray, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatNullableByteEnumArray(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readEnumVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatNullableIntEnumArray(const ::std::optional<::std::vector<::android::aidl::tests::IntEnum>>& input, ::std::optional<::std::vector<::android::aidl::tests::IntEnum>>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableIntEnumArray::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeEnumVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatNullableIntEnumArray, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatNullableIntEnumArray(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readEnumVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatNullableLongEnumArray(const ::std::optional<::std::vector<::android::aidl::tests::LongEnum>>& input, ::std::optional<::std::vector<::android::aidl::tests::LongEnum>>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableLongEnumArray::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeEnumVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatNullableLongEnumArray, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatNullableLongEnumArray(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readEnumVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatNullableString(const ::std::optional<::android::String16>& input, ::std::optional<::android::String16>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableString::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeString16(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatNullableString, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatNullableString(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readString16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatNullableStringList(const ::std::optional<::std::vector<::std::optional<::android::String16>>>& input, ::std::optional<::std::vector<::std::optional<::android::String16>>>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableStringList::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeString16Vector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatNullableStringList, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatNullableStringList(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readString16Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatNullableParcelable(const ::std::optional<::android::aidl::tests::ITestService::Empty>& input, ::std::optional<::android::aidl::tests::ITestService::Empty>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableParcelable::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeNullableParcelable(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatNullableParcelable, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatNullableParcelable(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatNullableParcelableArray(const ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>& input, ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableParcelableArray::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelableVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatNullableParcelableArray, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatNullableParcelableArray(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelableVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatNullableParcelableList(const ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>& input, ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableParcelableList::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelableVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatNullableParcelableList, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatNullableParcelableList(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelableVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::TakesAnIBinder(const ::android::sp<::android::IBinder>& input) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::TakesAnIBinder::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinder(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_TakesAnIBinder, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->TakesAnIBinder(input); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::TakesANullableIBinder(const ::android::sp<::android::IBinder>& input) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::TakesANullableIBinder::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinder(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_TakesANullableIBinder, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->TakesANullableIBinder(input); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::TakesAnIBinderList(const ::std::vector<::android::sp<::android::IBinder>>& input) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::TakesAnIBinderList::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinderVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_TakesAnIBinderList, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->TakesAnIBinderList(input); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::TakesANullableIBinderList(const ::std::optional<::std::vector<::android::sp<::android::IBinder>>>& input) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::TakesANullableIBinderList::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinderVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_TakesANullableIBinderList, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->TakesANullableIBinderList(input); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatUtf8CppString(const ::std::string& token, ::std::string* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatUtf8CppString::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeUtf8AsUtf16(token); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatUtf8CppString, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatUtf8CppString(token, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readUtf8FromUtf16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatNullableUtf8CppString(const ::std::optional<::std::string>& token, ::std::optional<::std::string>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableUtf8CppString::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeUtf8AsUtf16(token); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatNullableUtf8CppString, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatNullableUtf8CppString(token, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readUtf8FromUtf16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseUtf8CppString(const ::std::vector<::std::string>& input, ::std::vector<::std::string>* repeated, ::std::vector<::std::string>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseUtf8CppString::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeUtf8VectorAsUtf16Vector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseUtf8CppString, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseUtf8CppString(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readUtf8VectorFromUtf16Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readUtf8VectorFromUtf16Vector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseNullableUtf8CppString(const ::std::optional<::std::vector<::std::optional<::std::string>>>& input, ::std::optional<::std::vector<::std::optional<::std::string>>>* repeated, ::std::optional<::std::vector<::std::optional<::std::string>>>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseNullableUtf8CppString::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeUtf8VectorAsUtf16Vector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseNullableUtf8CppString, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseNullableUtf8CppString(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readUtf8VectorFromUtf16Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readUtf8VectorFromUtf16Vector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseUtf8CppStringList(const ::std::optional<::std::vector<::std::optional<::std::string>>>& input, ::std::optional<::std::vector<::std::optional<::std::string>>>* repeated, ::std::optional<::std::vector<::std::optional<::std::string>>>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseUtf8CppStringList::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeUtf8VectorAsUtf16Vector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseUtf8CppStringList, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseUtf8CppStringList(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readUtf8VectorFromUtf16Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readUtf8VectorFromUtf16Vector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::GetCallback(bool return_null, ::android::sp<::android::aidl::tests::INamedCallback>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetCallback::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeBool(return_null); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_GetCallback, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->GetCallback(return_null, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readNullableStrongBinder(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::FillOutStructuredParcelable(::android::aidl::tests::StructuredParcelable* parcel) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::FillOutStructuredParcelable::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(*parcel); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_FillOutStructuredParcelable, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->FillOutStructuredParcelable(parcel); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(parcel); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatExtendableParcelable(const ::android::aidl::tests::extension::ExtendableParcelable& ep, ::android::aidl::tests::extension::ExtendableParcelable* ep2) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatExtendableParcelable::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(ep); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatExtendableParcelable, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatExtendableParcelable(ep, ep2); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(ep2); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseList(const ::android::aidl::tests::RecursiveList& list, ::android::aidl::tests::RecursiveList* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseList::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(list); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseList, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseList(list, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseIBinderArray(const ::std::vector<::android::sp<::android::IBinder>>& input, ::std::vector<::android::sp<::android::IBinder>>* repeated, ::std::vector<::android::sp<::android::IBinder>>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseIBinderArray::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinderVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseIBinderArray, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseIBinderArray(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseNullableIBinderArray(const ::std::optional<::std::vector<::android::sp<::android::IBinder>>>& input, ::std::optional<::std::vector<::android::sp<::android::IBinder>>>* repeated, ::std::optional<::std::vector<::android::sp<::android::IBinder>>>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseNullableIBinderArray::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinderVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseNullableIBinderArray, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseNullableIBinderArray(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::RepeatSimpleParcelable(const ::android::aidl::tests::SimpleParcelable& input, ::android::aidl::tests::SimpleParcelable* repeat, ::android::aidl::tests::SimpleParcelable* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatSimpleParcelable::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_RepeatSimpleParcelable, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->RepeatSimpleParcelable(input, repeat, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readParcelable(repeat); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::ReverseSimpleParcelables(const ::std::vector<::android::aidl::tests::SimpleParcelable>& input, ::std::vector<::android::aidl::tests::SimpleParcelable>* repeated, ::std::vector<::android::aidl::tests::SimpleParcelable>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseSimpleParcelables::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelableVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeVectorSize(*repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_ReverseSimpleParcelables, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->ReverseSimpleParcelables(input, repeated, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelableVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readParcelableVector(repeated); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::GetOldNameInterface(::android::sp<::android::aidl::tests::IOldName>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetOldNameInterface::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_GetOldNameInterface, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->GetOldNameInterface(_aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readStrongBinder(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::GetNewNameInterface(::android::sp<::android::aidl::tests::INewName>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetNewNameInterface::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_GetNewNameInterface, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->GetNewNameInterface(_aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readStrongBinder(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::GetUnionTags(const ::std::vector<::android::aidl::tests::Union>& input, ::std::vector<::android::aidl::tests::Union::Tag>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetUnionTags::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelableVector(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_GetUnionTags, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->GetUnionTags(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readEnumVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::GetCppJavaTests(::android::sp<::android::IBinder>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetCppJavaTests::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_GetCppJavaTests, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->GetCppJavaTests(_aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readNullableStrongBinder(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::getBackendType(::android::aidl::tests::BackendType* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::getBackendType::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_getBackendType, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->getBackendType(_aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readByte(reinterpret_cast(_aidl_return)); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpTestService::GetCircular(::android::aidl::tests::CircularParcelable* cp, ::android::sp<::android::aidl::tests::ICircular>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markSensitive(); _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetCircular::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTestService::TRANSACTION_GetCircular, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_CLEAR_BUF); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) [[unlikely]] { return ITestService::getDefaultImpl()->GetCircular(cp, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readStrongBinder(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readParcelable(cp); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { BnTestService::BnTestService() { ::android::internal::Stability::markCompilationUnit(this); } #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated" ::android::status_t BnTestService::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnTestService::TRANSACTION_UnimplementedMethod: { int32_t in_arg; int32_t _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::UnimplementedMethod::cppServer"); _aidl_ret_status = _aidl_data.readInt32(&in_arg); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(UnimplementedMethod(in_arg, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeInt32(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_Deprecated: { if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::Deprecated::cppServer"); ::android::binder::Status _aidl_status(Deprecated()); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; case BnTestService::TRANSACTION_TestOneway: { if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::TestOneway::cppServer"); ::android::binder::Status _aidl_status(TestOneway()); } break; case BnTestService::TRANSACTION_RepeatBoolean: { bool in_token; bool _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatBoolean::cppServer"); _aidl_ret_status = _aidl_data.readBool(&in_token); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatBoolean(in_token, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeBool(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatByte: { int8_t in_token; int8_t _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatByte::cppServer"); _aidl_ret_status = _aidl_data.readByte(&in_token); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatByte(in_token, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeByte(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatChar: { char16_t in_token; char16_t _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatChar::cppServer"); _aidl_ret_status = _aidl_data.readChar(&in_token); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatChar(in_token, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeChar(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatInt: { int32_t in_token; int32_t _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatInt::cppServer"); _aidl_ret_status = _aidl_data.readInt32(&in_token); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatInt(in_token, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeInt32(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatLong: { int64_t in_token; int64_t _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatLong::cppServer"); _aidl_ret_status = _aidl_data.readInt64(&in_token); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatLong(in_token, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeInt64(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatFloat: { float in_token; float _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatFloat::cppServer"); _aidl_ret_status = _aidl_data.readFloat(&in_token); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatFloat(in_token, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeFloat(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatDouble: { double in_token; double _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatDouble::cppServer"); _aidl_ret_status = _aidl_data.readDouble(&in_token); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatDouble(in_token, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeDouble(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatString: { ::android::String16 in_token; ::android::String16 _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatString::cppServer"); _aidl_ret_status = _aidl_data.readString16(&in_token); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatString(in_token, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeString16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatByteEnum: { ::android::aidl::tests::ByteEnum in_token; ::android::aidl::tests::ByteEnum _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatByteEnum::cppServer"); _aidl_ret_status = _aidl_data.readByte(reinterpret_cast(&in_token)); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatByteEnum(in_token, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeByte(static_cast(_aidl_return)); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatIntEnum: { ::android::aidl::tests::IntEnum in_token; ::android::aidl::tests::IntEnum _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatIntEnum::cppServer"); _aidl_ret_status = _aidl_data.readInt32(reinterpret_cast(&in_token)); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatIntEnum(in_token, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeInt32(static_cast(_aidl_return)); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatLongEnum: { ::android::aidl::tests::LongEnum in_token; ::android::aidl::tests::LongEnum _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatLongEnum::cppServer"); _aidl_ret_status = _aidl_data.readInt64(reinterpret_cast(&in_token)); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatLongEnum(in_token, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeInt64(static_cast(_aidl_return)); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseBoolean: { ::std::vector in_input; ::std::vector out_repeated; ::std::vector _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseBoolean::cppServer"); _aidl_ret_status = _aidl_data.readBoolVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseBoolean(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeBoolVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeBoolVector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseByte: { ::std::vector in_input; ::std::vector out_repeated; ::std::vector _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseByte::cppServer"); _aidl_ret_status = _aidl_data.readByteVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseByte(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeByteVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeByteVector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseChar: { ::std::vector in_input; ::std::vector out_repeated; ::std::vector _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseChar::cppServer"); _aidl_ret_status = _aidl_data.readCharVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseChar(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeCharVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeCharVector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseInt: { ::std::vector in_input; ::std::vector out_repeated; ::std::vector _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseInt::cppServer"); _aidl_ret_status = _aidl_data.readInt32Vector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseInt(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeInt32Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeInt32Vector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseLong: { ::std::vector in_input; ::std::vector out_repeated; ::std::vector _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseLong::cppServer"); _aidl_ret_status = _aidl_data.readInt64Vector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseLong(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeInt64Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeInt64Vector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseFloat: { ::std::vector in_input; ::std::vector out_repeated; ::std::vector _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseFloat::cppServer"); _aidl_ret_status = _aidl_data.readFloatVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseFloat(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeFloatVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeFloatVector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseDouble: { ::std::vector in_input; ::std::vector out_repeated; ::std::vector _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseDouble::cppServer"); _aidl_ret_status = _aidl_data.readDoubleVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseDouble(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeDoubleVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeDoubleVector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseString: { ::std::vector<::android::String16> in_input; ::std::vector<::android::String16> out_repeated; ::std::vector<::android::String16> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseString::cppServer"); _aidl_ret_status = _aidl_data.readString16Vector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseString(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeString16Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeString16Vector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseByteEnum: { ::std::vector<::android::aidl::tests::ByteEnum> in_input; ::std::vector<::android::aidl::tests::ByteEnum> out_repeated; ::std::vector<::android::aidl::tests::ByteEnum> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseByteEnum::cppServer"); _aidl_ret_status = _aidl_data.readEnumVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseByteEnum(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeEnumVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeEnumVector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseIntEnum: { ::std::vector<::android::aidl::tests::IntEnum> in_input; ::std::vector<::android::aidl::tests::IntEnum> out_repeated; ::std::vector<::android::aidl::tests::IntEnum> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseIntEnum::cppServer"); _aidl_ret_status = _aidl_data.readEnumVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseIntEnum(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeEnumVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeEnumVector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseLongEnum: { ::std::vector<::android::aidl::tests::LongEnum> in_input; ::std::vector<::android::aidl::tests::LongEnum> out_repeated; ::std::vector<::android::aidl::tests::LongEnum> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseLongEnum::cppServer"); _aidl_ret_status = _aidl_data.readEnumVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseLongEnum(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeEnumVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeEnumVector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_GetOtherTestService: { ::android::String16 in_name; ::android::sp<::android::aidl::tests::INamedCallback> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetOtherTestService::cppServer"); _aidl_ret_status = _aidl_data.readString16(&in_name); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(GetOtherTestService(in_name, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinder(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_SetOtherTestService: { ::android::String16 in_name; ::android::sp<::android::aidl::tests::INamedCallback> in_service; bool _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::SetOtherTestService::cppServer"); _aidl_ret_status = _aidl_data.readString16(&in_name); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readStrongBinder(&in_service); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(SetOtherTestService(in_name, in_service, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeBool(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_VerifyName: { ::android::sp<::android::aidl::tests::INamedCallback> in_service; ::android::String16 in_name; bool _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::VerifyName::cppServer"); _aidl_ret_status = _aidl_data.readStrongBinder(&in_service); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readString16(&in_name); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(VerifyName(in_service, in_name, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeBool(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_GetInterfaceArray: { ::std::vector<::android::String16> in_names; ::std::vector<::android::sp<::android::aidl::tests::INamedCallback>> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetInterfaceArray::cppServer"); _aidl_ret_status = _aidl_data.readString16Vector(&in_names); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(GetInterfaceArray(in_names, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_VerifyNamesWithInterfaceArray: { ::std::vector<::android::sp<::android::aidl::tests::INamedCallback>> in_services; ::std::vector<::android::String16> in_names; bool _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::VerifyNamesWithInterfaceArray::cppServer"); _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_services); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readString16Vector(&in_names); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(VerifyNamesWithInterfaceArray(in_services, in_names, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeBool(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_GetNullableInterfaceArray: { ::std::optional<::std::vector<::std::optional<::android::String16>>> in_names; ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetNullableInterfaceArray::cppServer"); _aidl_ret_status = _aidl_data.readString16Vector(&in_names); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(GetNullableInterfaceArray(in_names, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_VerifyNamesWithNullableInterfaceArray: { ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>> in_services; ::std::optional<::std::vector<::std::optional<::android::String16>>> in_names; bool _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::VerifyNamesWithNullableInterfaceArray::cppServer"); _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_services); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readString16Vector(&in_names); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(VerifyNamesWithNullableInterfaceArray(in_services, in_names, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeBool(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_GetInterfaceList: { ::std::optional<::std::vector<::std::optional<::android::String16>>> in_names; ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetInterfaceList::cppServer"); _aidl_ret_status = _aidl_data.readString16Vector(&in_names); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(GetInterfaceList(in_names, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_VerifyNamesWithInterfaceList: { ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>> in_services; ::std::optional<::std::vector<::std::optional<::android::String16>>> in_names; bool _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::VerifyNamesWithInterfaceList::cppServer"); _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_services); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readString16Vector(&in_names); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(VerifyNamesWithInterfaceList(in_services, in_names, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeBool(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseStringList: { ::std::vector<::android::String16> in_input; ::std::vector<::android::String16> out_repeated; ::std::vector<::android::String16> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseStringList::cppServer"); _aidl_ret_status = _aidl_data.readString16Vector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseStringList(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeString16Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeString16Vector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatParcelFileDescriptor: { ::android::os::ParcelFileDescriptor in_read; ::android::os::ParcelFileDescriptor _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatParcelFileDescriptor::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_read); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatParcelFileDescriptor(in_read, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseParcelFileDescriptorArray: { ::std::vector<::android::os::ParcelFileDescriptor> in_input; ::std::vector<::android::os::ParcelFileDescriptor> out_repeated; ::std::vector<::android::os::ParcelFileDescriptor> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseParcelFileDescriptorArray::cppServer"); _aidl_ret_status = _aidl_data.readParcelableVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseParcelFileDescriptorArray(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelableVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeParcelableVector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ThrowServiceException: { int32_t in_code; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ThrowServiceException::cppServer"); _aidl_ret_status = _aidl_data.readInt32(&in_code); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ThrowServiceException(in_code)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; case BnTestService::TRANSACTION_RepeatNullableIntArray: { ::std::optional<::std::vector> in_input; ::std::optional<::std::vector> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableIntArray::cppServer"); _aidl_ret_status = _aidl_data.readInt32Vector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatNullableIntArray(in_input, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeInt32Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatNullableByteEnumArray: { ::std::optional<::std::vector<::android::aidl::tests::ByteEnum>> in_input; ::std::optional<::std::vector<::android::aidl::tests::ByteEnum>> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableByteEnumArray::cppServer"); _aidl_ret_status = _aidl_data.readEnumVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatNullableByteEnumArray(in_input, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeEnumVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatNullableIntEnumArray: { ::std::optional<::std::vector<::android::aidl::tests::IntEnum>> in_input; ::std::optional<::std::vector<::android::aidl::tests::IntEnum>> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableIntEnumArray::cppServer"); _aidl_ret_status = _aidl_data.readEnumVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatNullableIntEnumArray(in_input, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeEnumVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatNullableLongEnumArray: { ::std::optional<::std::vector<::android::aidl::tests::LongEnum>> in_input; ::std::optional<::std::vector<::android::aidl::tests::LongEnum>> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableLongEnumArray::cppServer"); _aidl_ret_status = _aidl_data.readEnumVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatNullableLongEnumArray(in_input, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeEnumVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatNullableString: { ::std::optional<::android::String16> in_input; ::std::optional<::android::String16> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableString::cppServer"); _aidl_ret_status = _aidl_data.readString16(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatNullableString(in_input, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeString16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatNullableStringList: { ::std::optional<::std::vector<::std::optional<::android::String16>>> in_input; ::std::optional<::std::vector<::std::optional<::android::String16>>> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableStringList::cppServer"); _aidl_ret_status = _aidl_data.readString16Vector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatNullableStringList(in_input, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeString16Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatNullableParcelable: { ::std::optional<::android::aidl::tests::ITestService::Empty> in_input; ::std::optional<::android::aidl::tests::ITestService::Empty> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableParcelable::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatNullableParcelable(in_input, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeNullableParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatNullableParcelableArray: { ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>> in_input; ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableParcelableArray::cppServer"); _aidl_ret_status = _aidl_data.readParcelableVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatNullableParcelableArray(in_input, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelableVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatNullableParcelableList: { ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>> in_input; ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableParcelableList::cppServer"); _aidl_ret_status = _aidl_data.readParcelableVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatNullableParcelableList(in_input, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelableVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_TakesAnIBinder: { ::android::sp<::android::IBinder> in_input; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::TakesAnIBinder::cppServer"); _aidl_ret_status = _aidl_data.readStrongBinder(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(TakesAnIBinder(in_input)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; case BnTestService::TRANSACTION_TakesANullableIBinder: { ::android::sp<::android::IBinder> in_input; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::TakesANullableIBinder::cppServer"); _aidl_ret_status = _aidl_data.readNullableStrongBinder(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(TakesANullableIBinder(in_input)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; case BnTestService::TRANSACTION_TakesAnIBinderList: { ::std::vector<::android::sp<::android::IBinder>> in_input; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::TakesAnIBinderList::cppServer"); _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(TakesAnIBinderList(in_input)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; case BnTestService::TRANSACTION_TakesANullableIBinderList: { ::std::optional<::std::vector<::android::sp<::android::IBinder>>> in_input; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::TakesANullableIBinderList::cppServer"); _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(TakesANullableIBinderList(in_input)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; case BnTestService::TRANSACTION_RepeatUtf8CppString: { ::std::string in_token; ::std::string _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatUtf8CppString::cppServer"); _aidl_ret_status = _aidl_data.readUtf8FromUtf16(&in_token); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatUtf8CppString(in_token, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeUtf8AsUtf16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatNullableUtf8CppString: { ::std::optional<::std::string> in_token; ::std::optional<::std::string> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatNullableUtf8CppString::cppServer"); _aidl_ret_status = _aidl_data.readUtf8FromUtf16(&in_token); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatNullableUtf8CppString(in_token, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeUtf8AsUtf16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseUtf8CppString: { ::std::vector<::std::string> in_input; ::std::vector<::std::string> out_repeated; ::std::vector<::std::string> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseUtf8CppString::cppServer"); _aidl_ret_status = _aidl_data.readUtf8VectorFromUtf16Vector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseUtf8CppString(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeUtf8VectorAsUtf16Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeUtf8VectorAsUtf16Vector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseNullableUtf8CppString: { ::std::optional<::std::vector<::std::optional<::std::string>>> in_input; ::std::optional<::std::vector<::std::optional<::std::string>>> out_repeated; ::std::optional<::std::vector<::std::optional<::std::string>>> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseNullableUtf8CppString::cppServer"); _aidl_ret_status = _aidl_data.readUtf8VectorFromUtf16Vector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseNullableUtf8CppString(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeUtf8VectorAsUtf16Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeUtf8VectorAsUtf16Vector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseUtf8CppStringList: { ::std::optional<::std::vector<::std::optional<::std::string>>> in_input; ::std::optional<::std::vector<::std::optional<::std::string>>> out_repeated; ::std::optional<::std::vector<::std::optional<::std::string>>> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseUtf8CppStringList::cppServer"); _aidl_ret_status = _aidl_data.readUtf8VectorFromUtf16Vector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseUtf8CppStringList(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeUtf8VectorAsUtf16Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeUtf8VectorAsUtf16Vector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_GetCallback: { bool in_return_null; ::android::sp<::android::aidl::tests::INamedCallback> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetCallback::cppServer"); _aidl_ret_status = _aidl_data.readBool(&in_return_null); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(GetCallback(in_return_null, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinder(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_FillOutStructuredParcelable: { ::android::aidl::tests::StructuredParcelable in_parcel; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::FillOutStructuredParcelable::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_parcel); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(FillOutStructuredParcelable(&in_parcel)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(in_parcel); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatExtendableParcelable: { ::android::aidl::tests::extension::ExtendableParcelable in_ep; ::android::aidl::tests::extension::ExtendableParcelable out_ep2; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatExtendableParcelable::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_ep); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatExtendableParcelable(in_ep, &out_ep2)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(out_ep2); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseList: { ::android::aidl::tests::RecursiveList in_list; ::android::aidl::tests::RecursiveList _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseList::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_list); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseList(in_list, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseIBinderArray: { ::std::vector<::android::sp<::android::IBinder>> in_input; ::std::vector<::android::sp<::android::IBinder>> out_repeated; ::std::vector<::android::sp<::android::IBinder>> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseIBinderArray::cppServer"); _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseIBinderArray(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseNullableIBinderArray: { ::std::optional<::std::vector<::android::sp<::android::IBinder>>> in_input; ::std::optional<::std::vector<::android::sp<::android::IBinder>>> out_repeated; ::std::optional<::std::vector<::android::sp<::android::IBinder>>> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseNullableIBinderArray::cppServer"); _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseNullableIBinderArray(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_RepeatSimpleParcelable: { ::android::aidl::tests::SimpleParcelable in_input; ::android::aidl::tests::SimpleParcelable out_repeat; ::android::aidl::tests::SimpleParcelable _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::RepeatSimpleParcelable::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(RepeatSimpleParcelable(in_input, &out_repeat, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(out_repeat); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_ReverseSimpleParcelables: { ::std::vector<::android::aidl::tests::SimpleParcelable> in_input; ::std::vector<::android::aidl::tests::SimpleParcelable> out_repeated; ::std::vector<::android::aidl::tests::SimpleParcelable> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::ReverseSimpleParcelables::cppServer"); _aidl_ret_status = _aidl_data.readParcelableVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.resizeOutVector(&out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ReverseSimpleParcelables(in_input, &out_repeated, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelableVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeParcelableVector(out_repeated); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_GetOldNameInterface: { ::android::sp<::android::aidl::tests::IOldName> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetOldNameInterface::cppServer"); ::android::binder::Status _aidl_status(GetOldNameInterface(&_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinder(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_GetNewNameInterface: { ::android::sp<::android::aidl::tests::INewName> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetNewNameInterface::cppServer"); ::android::binder::Status _aidl_status(GetNewNameInterface(&_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinder(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_GetUnionTags: { ::std::vector<::android::aidl::tests::Union> in_input; ::std::vector<::android::aidl::tests::Union::Tag> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetUnionTags::cppServer"); _aidl_ret_status = _aidl_data.readParcelableVector(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(GetUnionTags(in_input, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeEnumVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_GetCppJavaTests: { ::android::sp<::android::IBinder> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetCppJavaTests::cppServer"); ::android::binder::Status _aidl_status(GetCppJavaTests(&_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinder(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_getBackendType: { ::android::aidl::tests::BackendType _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::getBackendType::cppServer"); ::android::binder::Status _aidl_status(getBackendType(&_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeByte(static_cast(_aidl_return)); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTestService::TRANSACTION_GetCircular: { ::android::aidl::tests::CircularParcelable out_cp; ::android::sp<::android::aidl::tests::ICircular> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITestService::GetCircular::cppServer"); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(GetCircular(&out_cp, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinder(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(out_cp); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } #pragma clang diagnostic pop } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { ::android::status_t ITestService::Empty::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t ITestService::Empty::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { ::android::status_t ITestService::CompilerChecks::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readStrongBinder(&binder); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readNullableStrongBinder(&nullable_binder); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readStrongBinderVector(&binder_array); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readStrongBinderVector(&nullable_binder_array); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readStrongBinderVector(&binder_list); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readStrongBinderVector(&nullable_binder_list); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelable(&pfd); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelable(&nullable_pfd); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelableVector(&pfd_array); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelableVector(&nullable_pfd_array); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelableVector(&pfd_list); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelableVector(&nullable_pfd_list); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelable(&parcel); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelable(&nullable_parcel); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelableVector(&parcel_array); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelableVector(&nullable_parcel_array); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelableVector(&parcel_list); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelableVector(&nullable_parcel_list); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t ITestService::CompilerChecks::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeStrongBinder(binder); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeStrongBinder(nullable_binder); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeStrongBinderVector(binder_array); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeStrongBinderVector(nullable_binder_array); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeStrongBinderVector(binder_list); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeStrongBinderVector(nullable_binder_list); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelable(pfd); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeNullableParcelable(nullable_pfd); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelableVector(pfd_array); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelableVector(nullable_pfd_array); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelableVector(pfd_list); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelableVector(nullable_pfd_list); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelable(parcel); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeNullableParcelable(nullable_parcel); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelableVector(parcel_array); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelableVector(nullable_parcel_array); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelableVector(parcel_list); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelableVector(nullable_parcel_list); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android #include #include namespace android { namespace aidl { namespace tests { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_NESTED_INTERFACE(ITestService::CompilerChecks, Foo, "android.aidl.tests.ITestService.CompilerChecks.Foo") } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { ITestService::CompilerChecks::BpFoo::BpFoo(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { ITestService::CompilerChecks::BnFoo::BnFoo() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t ITestService::CompilerChecks::BnFoo::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" ::android::status_t ITestService::CompilerChecks::HasDeprecated::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&deprecated); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t ITestService::CompilerChecks::HasDeprecated::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeInt32(deprecated); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } #pragma clang diagnostic pop } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { ::android::status_t ITestService::CompilerChecks::UsingHasDeprecated::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_tag)) != ::android::OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case n: { int32_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case m: { ::android::aidl::tests::ITestService::CompilerChecks::HasDeprecated _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readParcelable(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::android::aidl::tests::ITestService::CompilerChecks::HasDeprecated>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } } return ::android::BAD_VALUE; } ::android::status_t ITestService::CompilerChecks::UsingHasDeprecated::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(getTag())); if (_aidl_ret_status != ::android::OK) return _aidl_ret_status; switch (getTag()) { case n: return _aidl_parcel->writeInt32(get()); case m: return _aidl_parcel->writeParcelable(get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace aidl } // namespace android #include #include namespace android { namespace aidl { namespace tests { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_NESTED_INTERFACE(ITestService::CompilerChecks, NoPrefixInterface, "android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface") } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { ITestService::CompilerChecks::BpNoPrefixInterface::BpNoPrefixInterface(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } ::android::binder::Status ITestService::CompilerChecks::BpNoPrefixInterface::foo() { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::NoPrefixInterface::foo::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(ITestService::CompilerChecks::BnNoPrefixInterface::TRANSACTION_foo, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && INoPrefixInterface::getDefaultImpl()) [[unlikely]] { return INoPrefixInterface::getDefaultImpl()->foo(); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { ITestService::CompilerChecks::BnNoPrefixInterface::BnNoPrefixInterface() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t ITestService::CompilerChecks::BnNoPrefixInterface::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnNoPrefixInterface::TRANSACTION_foo: { if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::NoPrefixInterface::foo::cppServer"); ::android::binder::Status _aidl_status(foo()); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { ::android::status_t ITestService::CompilerChecks::INoPrefixInterface::Nested::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t ITestService::CompilerChecks::INoPrefixInterface::Nested::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android #include #include namespace android { namespace aidl { namespace tests { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_NESTED_INTERFACE(ITestService::CompilerChecks::INoPrefixInterface, NestedNoPrefixInterface, "android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.NestedNoPrefixInterface") } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { ITestService::CompilerChecks::INoPrefixInterface::BpNestedNoPrefixInterface::BpNestedNoPrefixInterface(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } ::android::binder::Status ITestService::CompilerChecks::INoPrefixInterface::BpNestedNoPrefixInterface::foo() { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::NestedNoPrefixInterface::foo::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(ITestService::CompilerChecks::INoPrefixInterface::BnNestedNoPrefixInterface::TRANSACTION_foo, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && INestedNoPrefixInterface::getDefaultImpl()) [[unlikely]] { return INestedNoPrefixInterface::getDefaultImpl()->foo(); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { ITestService::CompilerChecks::INoPrefixInterface::BnNestedNoPrefixInterface::BnNestedNoPrefixInterface() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t ITestService::CompilerChecks::INoPrefixInterface::BnNestedNoPrefixInterface::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnNestedNoPrefixInterface::TRANSACTION_foo: { if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::NestedNoPrefixInterface::foo::cppServer"); ::android::binder::Status _aidl_status(foo()); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_ITe0100644 0000000 0000000 00000000034 15172120304 033203 xustar000000000 0000000 28 mtime=1776853188.5900000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/ITestService.cpp.d0100644 0000000 0000000 00000002225 15172120304 032603 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/ITestService.cpp : \ system/tools/aidl/tests/android/aidl/tests/ITestService.aidl \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ICircular.aidl \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl \ system/tools/aidl/tests/android/aidl/tests/SimpleParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Int0100644 0000000 0000000 00000000034 15172120304 033254 xustar000000000 0000000 28 mtime=1776853188.5910000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/IntEnum.cpp0100644 0000000 0000000 00000001231 15172120304 031363 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/IntEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl */ // This file is intentionally left blank as placeholder for enum declaration. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Int0100644 0000000 0000000 00000000034 15172120304 033254 xustar000000000 0000000 28 mtime=1776853188.5910000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/IntEnum.cpp.d0100644 0000000 0000000 00000000253 15172120304 031610 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/IntEnum.cpp : \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Lis0100644 0000000 0000000 00000000213 15172120304 033250 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/ListOfInterfaces.cpp 28 mtime=1776853188.5910000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/ListOfInterfaces.cp0100644 0000000 0000000 00000047237 15172120304 033050 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ListOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ListOfInterfaces.aidl */ #include namespace android { namespace aidl { namespace tests { ::android::status_t ListOfInterfaces::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t ListOfInterfaces::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android #include #include namespace android { namespace aidl { namespace tests { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_NESTED_INTERFACE(ListOfInterfaces, EmptyInterface, "android.aidl.tests.ListOfInterfaces.IEmptyInterface") } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { ListOfInterfaces::BpEmptyInterface::BpEmptyInterface(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { ListOfInterfaces::BnEmptyInterface::BnEmptyInterface() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t ListOfInterfaces::BnEmptyInterface::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android #include #include namespace android { namespace aidl { namespace tests { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_NESTED_INTERFACE(ListOfInterfaces, MyInterface, "android.aidl.tests.ListOfInterfaces.IMyInterface") } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { ListOfInterfaces::BpMyInterface::BpMyInterface(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } ::android::binder::Status ListOfInterfaces::BpMyInterface::methodWithInterfaces(const ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& iface, const ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& nullable_iface, const ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>& iface_list_in, ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>* iface_list_out, ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>* iface_list_inout, const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>& nullable_iface_list_in, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>* nullable_iface_list_out, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>* nullable_iface_list_inout, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyInterface::methodWithInterfaces::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinder(iface); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinder(nullable_iface); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinderVector(iface_list_in); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinderVector(*iface_list_inout); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinderVector(nullable_iface_list_in); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinderVector(*nullable_iface_list_inout); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(ListOfInterfaces::BnMyInterface::TRANSACTION_methodWithInterfaces, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IMyInterface::getDefaultImpl()) [[unlikely]] { return IMyInterface::getDefaultImpl()->methodWithInterfaces(iface, nullable_iface, iface_list_in, iface_list_out, iface_list_inout, nullable_iface_list_in, nullable_iface_list_out, nullable_iface_list_inout, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(iface_list_out); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(iface_list_inout); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(nullable_iface_list_out); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readStrongBinderVector(nullable_iface_list_inout); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { ListOfInterfaces::BnMyInterface::BnMyInterface() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t ListOfInterfaces::BnMyInterface::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnMyInterface::TRANSACTION_methodWithInterfaces: { ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface> in_iface; ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface> in_nullable_iface; ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>> in_iface_list_in; ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>> out_iface_list_out; ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>> in_iface_list_inout; ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>> in_nullable_iface_list_in; ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>> out_nullable_iface_list_out; ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>> in_nullable_iface_list_inout; ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyInterface::methodWithInterfaces::cppServer"); _aidl_ret_status = _aidl_data.readStrongBinder(&in_iface); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readNullableStrongBinder(&in_nullable_iface); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_iface_list_in); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_iface_list_inout); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_nullable_iface_list_in); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readStrongBinderVector(&in_nullable_iface_list_inout); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(methodWithInterfaces(in_iface, in_nullable_iface, in_iface_list_in, &out_iface_list_out, &in_iface_list_inout, in_nullable_iface_list_in, &out_nullable_iface_list_out, &in_nullable_iface_list_inout, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(out_iface_list_out); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(in_iface_list_inout); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(out_nullable_iface_list_out); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeStrongBinderVector(in_nullable_iface_list_inout); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { ::android::status_t ListOfInterfaces::MyParcelable::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readStrongBinder(&iface); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readNullableStrongBinder(&nullable_iface); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readStrongBinderVector(&iface_list); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readStrongBinderVector(&nullable_iface_list); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t ListOfInterfaces::MyParcelable::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeStrongBinder(iface); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeStrongBinder(nullable_iface); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeStrongBinderVector(iface_list); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeStrongBinderVector(nullable_iface_list); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { ::android::status_t ListOfInterfaces::MyUnion::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_tag)) != ::android::OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case iface: { ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface> _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readStrongBinder(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case nullable_iface: { ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface> _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readNullableStrongBinder(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case iface_list: { ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>> _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readStrongBinderVector(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case nullable_iface_list: { ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>> _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readStrongBinderVector(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } } return ::android::BAD_VALUE; } ::android::status_t ListOfInterfaces::MyUnion::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(getTag())); if (_aidl_ret_status != ::android::OK) return _aidl_ret_status; switch (getTag()) { case iface: return _aidl_parcel->writeStrongBinder(get()); case nullable_iface: return _aidl_parcel->writeStrongBinder(get()); case iface_list: return _aidl_parcel->writeStrongBinderVector(get()); case nullable_iface_list: return _aidl_parcel->writeStrongBinderVector(get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Lis0100644 0000000 0000000 00000000215 15172120304 033252 xustar000000000 0000000 113 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/ListOfInterfaces.cpp.d 28 mtime=1776853188.5920000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/ListOfInterfaces.cp0100644 0000000 0000000 00000000275 15172120304 033037 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/ListOfInterfaces.cpp : \ system/tools/aidl/tests/android/aidl/tests/ListOfInterfaces.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Lon0100644 0000000 0000000 00000000034 15172120304 033252 xustar000000000 0000000 28 mtime=1776853188.5920000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/LongEnum.cpp0100644 0000000 0000000 00000001233 15172120304 031532 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/LongEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl */ // This file is intentionally left blank as placeholder for enum declaration. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Lon0100644 0000000 0000000 00000000034 15172120304 033252 xustar000000000 0000000 28 mtime=1776853188.5920000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/LongEnum.cpp.d0100644 0000000 0000000 00000000255 15172120304 031757 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/LongEnum.cpp : \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Oth0100644 0000000 0000000 00000000225 15172120304 033256 xustar000000000 0000000 121 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/OtherParcelableForToString.cpp 28 mtime=1776853188.5920000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/OtherParcelableForT0100644 0000000 0000000 00000004753 15172120304 033066 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/OtherParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl */ #include namespace android { namespace aidl { namespace tests { ::android::status_t OtherParcelableForToString::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readString16(&field); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t OtherParcelableForToString::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeString16(field); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Oth0100644 0000000 0000000 00000000227 15172120304 033260 xustar000000000 0000000 123 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/OtherParcelableForToString.cpp.d 28 mtime=1776853188.5920000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/OtherParcelableForT0100644 0000000 0000000 00000000321 15172120304 033051 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/OtherParcelableForToString.cpp : \ system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Par0100644 0000000 0000000 00000000220 15172120304 033241 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/ParcelableForToString.cpp 28 mtime=1776853188.5920000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/ParcelableForToStri0100644 0000000 0000000 00000031601 15172120304 033075 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ParcelableForToString.aidl */ #include namespace android { namespace aidl { namespace tests { ::android::status_t ParcelableForToString::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&intValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32Vector(&intArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt64(&longValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt64Vector(&longArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readDouble(&doubleValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readDoubleVector(&doubleArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFloat(&floatValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFloatVector(&floatArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readByte(&byteValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readByteVector(&byteArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readBool(&booleanValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readBoolVector(&booleanArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readString16(&stringValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readString16Vector(&stringArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readString16Vector(&stringList); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelable(&parcelableValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelableVector(&parcelableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast(&enumValue)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readEnumVector(&enumArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readString16Vector(&nullArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readString16Vector(&nullList); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelable(&parcelableGeneric); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelable(&unionValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t ParcelableForToString::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeInt32(intValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32Vector(intArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt64(longValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt64Vector(longArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeDouble(doubleValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeDoubleVector(doubleArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFloat(floatValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFloatVector(floatArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeByte(byteValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeByteVector(byteArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeBool(booleanValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeBoolVector(booleanArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeString16(stringValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeString16Vector(stringArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeString16Vector(stringList); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelable(parcelableValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelableVector(parcelableArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(enumValue)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeEnumVector(enumArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeString16Vector(nullArray); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeString16Vector(nullList); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelable(parcelableGeneric); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelable(unionValue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Par0100644 0000000 0000000 00000000222 15172120304 033243 xustar000000000 0000000 118 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/ParcelableForToString.cpp.d 28 mtime=1776853188.5920000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/ParcelableForToStri0100644 0000000 0000000 00000001352 15172120304 033075 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/ParcelableForToString.cpp : \ system/tools/aidl/tests/android/aidl/tests/ParcelableForToString.aidl \ system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Rec0100644 0000000 0000000 00000000034 15172120304 033233 xustar000000000 0000000 28 mtime=1776853188.5920000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/RecursiveList.cpp0100644 0000000 0000000 00000005602 15172120304 032615 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/RecursiveList.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl */ #include namespace android { namespace aidl { namespace tests { ::android::status_t RecursiveList::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&value); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelable(&next); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t RecursiveList::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeInt32(value); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeNullableParcelable(next); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Rec0100644 0000000 0000000 00000000212 15172120304 033231 xustar000000000 0000000 110 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/RecursiveList.cpp.d 28 mtime=1776853188.5930000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/RecursiveList.cpp.d0100644 0000000 0000000 00000000267 15172120304 033041 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/RecursiveList.cpp : \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Str0100644 0000000 0000000 00000000217 15172120304 033275 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/StructuredParcelable.cpp 28 mtime=1776853188.5930000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/StructuredParcelabl0100644 0000000 0000000 00000074175 15172120304 033216 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/StructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl */ #include namespace android { namespace aidl { namespace tests { ::android::status_t StructuredParcelable::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32Vector(&shouldContainThreeFs); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&f); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readUtf8FromUtf16(&shouldBeJerry); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readByte(reinterpret_cast(&shouldBeByteBar)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast(&shouldBeIntBar)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt64(reinterpret_cast(&shouldBeLongBar)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readEnumVector(&shouldContainTwoByteFoos); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readEnumVector(&shouldContainTwoIntFoos); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readEnumVector(&shouldContainTwoLongFoos); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readString16(&stringDefaultsToFoo); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readByte(&byteDefaultsToFour); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&intDefaultsToFive); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt64(&longDefaultsToNegativeSeven); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readBool(&booleanDefaultsToTrue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readChar(&charDefaultsToC); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFloat(&floatDefaultsToPi); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readDouble(&doubleWithDefault); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32Vector(&arrayDefaultsTo123); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32Vector(&arrayDefaultsToEmpty); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readBool(&boolDefault); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readByte(&byteDefault); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&intDefault); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt64(&longDefault); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readFloat(&floatDefault); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readDouble(&doubleDefault); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readDouble(&checkDoubleFromFloat); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readString16Vector(&checkStringArray1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readUtf8VectorFromUtf16Vector(&checkStringArray2); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&int32_min); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&int32_max); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt64(&int64_max); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&hexInt32_neg_1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readNullableStrongBinder(&ibinder); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelable(&empty); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readByteVector(&int8_1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32Vector(&int32_1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt64Vector(&int64_1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&hexInt32_pos_1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&hexInt64_pos_1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast(&const_exprs_1)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast(&const_exprs_2)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast(&const_exprs_3)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast(&const_exprs_4)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast(&const_exprs_5)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast(&const_exprs_6)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast(&const_exprs_7)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast(&const_exprs_8)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast(&const_exprs_9)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast(&const_exprs_10)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readUtf8FromUtf16(&addString1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readUtf8FromUtf16(&addString2); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&shouldSetBit0AndBit2); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelable(&u); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelable(&shouldBeConstS1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast(&defaultWithFoo)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t StructuredParcelable::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeInt32Vector(shouldContainThreeFs); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(f); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeUtf8AsUtf16(shouldBeJerry); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeByte(static_cast(shouldBeByteBar)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(shouldBeIntBar)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt64(static_cast(shouldBeLongBar)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeEnumVector(shouldContainTwoByteFoos); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeEnumVector(shouldContainTwoIntFoos); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeEnumVector(shouldContainTwoLongFoos); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeString16(stringDefaultsToFoo); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeByte(byteDefaultsToFour); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(intDefaultsToFive); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt64(longDefaultsToNegativeSeven); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeBool(booleanDefaultsToTrue); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeChar(charDefaultsToC); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFloat(floatDefaultsToPi); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeDouble(doubleWithDefault); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32Vector(arrayDefaultsTo123); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32Vector(arrayDefaultsToEmpty); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeBool(boolDefault); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeByte(byteDefault); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(intDefault); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt64(longDefault); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeFloat(floatDefault); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeDouble(doubleDefault); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeDouble(checkDoubleFromFloat); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeString16Vector(checkStringArray1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeUtf8VectorAsUtf16Vector(checkStringArray2); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(int32_min); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(int32_max); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt64(int64_max); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(hexInt32_neg_1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeStrongBinder(ibinder); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelable(empty); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeByteVector(int8_1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32Vector(int32_1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt64Vector(int64_1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(hexInt32_pos_1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(hexInt64_pos_1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(const_exprs_1)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(const_exprs_2)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(const_exprs_3)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(const_exprs_4)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(const_exprs_5)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(const_exprs_6)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(const_exprs_7)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(const_exprs_8)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(const_exprs_9)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(const_exprs_10)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeUtf8AsUtf16(addString1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeUtf8AsUtf16(addString2); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(shouldSetBit0AndBit2); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeNullableParcelable(u); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeNullableParcelable(shouldBeConstS1); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(defaultWithFoo)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { ::android::status_t StructuredParcelable::Empty::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t StructuredParcelable::Empty::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Str0100644 0000000 0000000 00000000221 15172120304 033270 xustar000000000 0000000 117 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/StructuredParcelable.cpp.d 28 mtime=1776853188.5930000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/StructuredParcelabl0100644 0000000 0000000 00000001000 15172120304 033167 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/StructuredParcelable.cpp : \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Uni0100644 0000000 0000000 00000000034 15172120304 033255 xustar000000000 0000000 28 mtime=1776853188.5930000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/Union.cpp0100644 0000000 0000000 00000011401 15172120304 031074 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/Union.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/Union.aidl */ #include namespace android { namespace aidl { namespace tests { const ::std::string& Union::S1() { static const ::std::string value("a string constant in union"); return value; } ::android::status_t Union::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_tag)) != ::android::OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case ns: { ::std::vector _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32Vector(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::std::vector>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case n: { int32_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case m: { int32_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case s: { ::std::string _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readUtf8FromUtf16(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::std::string>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case ibinder: { ::android::sp<::android::IBinder> _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readNullableStrongBinder(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::android::sp<::android::IBinder>>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case ss: { ::std::vector<::std::string> _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readUtf8VectorFromUtf16Vector(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::std::vector<::std::string>>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case be: { ::android::aidl::tests::ByteEnum _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readByte(reinterpret_cast(&_aidl_value))) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::android::aidl::tests::ByteEnum>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } } return ::android::BAD_VALUE; } ::android::status_t Union::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(getTag())); if (_aidl_ret_status != ::android::OK) return _aidl_ret_status; switch (getTag()) { case ns: return _aidl_parcel->writeInt32Vector(get()); case n: return _aidl_parcel->writeInt32(get()); case m: return _aidl_parcel->writeInt32(get()); case s: return _aidl_parcel->writeUtf8AsUtf16(get()); case ibinder: return _aidl_parcel->writeStrongBinder(get()); case ss: return _aidl_parcel->writeUtf8VectorAsUtf16Vector(get()); case be: return _aidl_parcel->writeByte(static_cast(get())); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Uni0100644 0000000 0000000 00000000034 15172120304 033255 xustar000000000 0000000 28 mtime=1776853188.5930000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/Union.cpp.d0100644 0000000 0000000 00000000344 15172120304 031322 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/Union.cpp : \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Uni0100644 0000000 0000000 00000000034 15172120304 033255 xustar000000000 0000000 28 mtime=1776853188.5930000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/UnionWithFd.cpp0100644 0000000 0000000 00000004517 15172120304 032214 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/UnionWithFd.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/UnionWithFd.aidl */ #include namespace android { namespace aidl { namespace tests { ::android::status_t UnionWithFd::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_tag)) != ::android::OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case num: { int32_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case pfd: { ::android::os::ParcelFileDescriptor _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readParcelable(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::android::os::ParcelFileDescriptor>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } } return ::android::BAD_VALUE; } ::android::status_t UnionWithFd::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(getTag())); if (_aidl_ret_status != ::android::OK) return _aidl_ret_status; switch (getTag()) { case num: return _aidl_parcel->writeInt32(get()); case pfd: return _aidl_parcel->writeParcelable(get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_Uni0100644 0000000 0000000 00000000034 15172120304 033255 xustar000000000 0000000 28 mtime=1776853188.5930000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/UnionWithFd.cpp.d0100644 0000000 0000000 00000000263 15172120304 032430 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/UnionWithFd.cpp : \ system/tools/aidl/tests/android/aidl/tests/UnionWithFd.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_ext0100644 0000000 0000000 00000000034 15172120304 033322 xustar000000000 0000000 28 mtime=1776853188.5930000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/0040755 0000000 0000000 00000000000 15172120304 031322 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_ext0100644 0000000 0000000 00000000231 15172120304 033321 xustar000000000 0000000 125 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/ExtendableParcelable.cpp 28 mtime=1776853188.5930000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/Extendabl0100644 0000000 0000000 00000010521 15172120304 033147 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/extension/ExtendableParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl */ #include namespace android { namespace aidl { namespace tests { namespace extension { ::android::status_t ExtendableParcelable::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&a); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readUtf8FromUtf16(&b); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelable(&ext); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt64(&c); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelable(&ext2); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t ExtendableParcelable::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeInt32(a); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeUtf8AsUtf16(b); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelable(ext); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt64(c); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelable(ext2); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace extension } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_ext0100644 0000000 0000000 00000000233 15172120304 033323 xustar000000000 0000000 127 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/ExtendableParcelable.cpp.d 28 mtime=1776853188.5940000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/Extendabl0100644 0000000 0000000 00000000331 15172120304 033145 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/ExtendableParcelable.cpp : \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_ext0100644 0000000 0000000 00000000212 15172120304 033320 xustar000000000 0000000 110 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/MyExt.cpp 28 mtime=1776853188.5940000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/MyExt.cpp0100644 0000000 0000000 00000005626 15172120304 033102 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/extension/MyExt.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl */ #include namespace android { namespace aidl { namespace tests { namespace extension { ::android::status_t MyExt::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&a); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readUtf8FromUtf16(&b); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t MyExt::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeInt32(a); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeUtf8AsUtf16(b); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace extension } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_ext0100644 0000000 0000000 00000000214 15172120304 033322 xustar000000000 0000000 112 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/MyExt.cpp.d 28 mtime=1776853188.5940000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/MyExt.cpp0100644 0000000 0000000 00000000273 15172120304 033073 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/MyExt.cpp : \ system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_ext0100644 0000000 0000000 00000000213 15172120304 033321 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/MyExt2.cpp 28 mtime=1776853188.5940000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/MyExt2.cp0100644 0000000 0000000 00000006553 15172120304 033004 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/extension/MyExt2.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt2.aidl */ #include namespace android { namespace aidl { namespace tests { namespace extension { ::android::status_t MyExt2::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&a); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelable(&b); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readUtf8FromUtf16(&c); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t MyExt2::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeInt32(a); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelable(b); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeUtf8AsUtf16(c); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace extension } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_ext0100644 0000000 0000000 00000000215 15172120304 033323 xustar000000000 0000000 113 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/MyExt2.cpp.d 28 mtime=1776853188.5940000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/MyExt2.cp0100644 0000000 0000000 00000000401 15172120304 032766 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/MyExt2.cpp : \ system/tools/aidl/tests/android/aidl/tests/extension/MyExt2.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_ext0100644 0000000 0000000 00000000216 15172120304 033324 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/MyExtLike.cpp 28 mtime=1776853188.5940000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/MyExtLike0100644 0000000 0000000 00000005642 15172120304 033124 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/extension/MyExtLike.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExtLike.aidl */ #include namespace android { namespace aidl { namespace tests { namespace extension { ::android::status_t MyExtLike::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&a); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readString16(&b); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t MyExtLike::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeInt32(a); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeString16(b); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace extension } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_ext0100644 0000000 0000000 00000000220 15172120304 033317 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/MyExtLike.cpp.d 28 mtime=1776853188.5940000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/MyExtLike0100644 0000000 0000000 00000000303 15172120304 033111 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/extension/MyExtLike.cpp : \ system/tools/aidl/tests/android/aidl/tests/extension/MyExtLike.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_nes0100644 0000000 0000000 00000000034 15172120304 033307 xustar000000000 0000000 28 mtime=1776853188.5940000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/nested/0040755 0000000 0000000 00000000000 15172120304 030570 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_nes0100644 0000000 0000000 00000000216 15172120304 033311 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/nested/DeeplyNested.cpp 28 mtime=1776853188.5940000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/nested/DeeplyNested0100644 0000000 0000000 00000020343 15172120304 033077 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/nested/DeeplyNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/DeeplyNested.aidl */ #include namespace android { namespace aidl { namespace tests { namespace nested { ::android::status_t DeeplyNested::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t DeeplyNested::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { namespace nested { ::android::status_t DeeplyNested::A::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readByte(reinterpret_cast(&e)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t DeeplyNested::A::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeByte(static_cast(e)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { namespace nested { ::android::status_t DeeplyNested::B::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t DeeplyNested::B::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { namespace nested { ::android::status_t DeeplyNested::B::C::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t DeeplyNested::B::C::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { namespace nested { ::android::status_t DeeplyNested::B::C::D::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t DeeplyNested::B::C::D::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_nes0100644 0000000 0000000 00000000220 15172120304 033304 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/nested/DeeplyNested.cpp.d 28 mtime=1776853188.5940000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/nested/DeeplyNested0100644 0000000 0000000 00000000303 15172120304 033071 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/nested/DeeplyNested.cpp : \ system/tools/aidl/tests/android/aidl/tests/nested/DeeplyNested.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_nes0100644 0000000 0000000 00000000220 15172120304 033304 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/nested/INestedService.cpp 28 mtime=1776853188.5940000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/nested/INestedServi0100644 0000000 0000000 00000033347 15172120304 033066 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/nested/INestedService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/INestedService.aidl */ #include #include namespace android { namespace aidl { namespace tests { namespace nested { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE(NestedService, "android.aidl.tests.nested.INestedService") } // namespace nested } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { namespace nested { BpNestedService::BpNestedService(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } ::android::binder::Status BpNestedService::flipStatus(const ::android::aidl::tests::nested::ParcelableWithNested& p, ::android::aidl::tests::nested::INestedService::Result* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::INestedService::flipStatus::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(p); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnNestedService::TRANSACTION_flipStatus, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && INestedService::getDefaultImpl()) [[unlikely]] { return INestedService::getDefaultImpl()->flipStatus(p, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpNestedService::flipStatusWithCallback(::android::aidl::tests::nested::ParcelableWithNested::Status status, const ::android::sp<::android::aidl::tests::nested::INestedService::ICallback>& cb) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::INestedService::flipStatusWithCallback::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeByte(static_cast(status)); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinder(cb); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnNestedService::TRANSACTION_flipStatusWithCallback, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && INestedService::getDefaultImpl()) [[unlikely]] { return INestedService::getDefaultImpl()->flipStatusWithCallback(status, cb); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { namespace nested { BnNestedService::BnNestedService() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t BnNestedService::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnNestedService::TRANSACTION_flipStatus: { ::android::aidl::tests::nested::ParcelableWithNested in_p; ::android::aidl::tests::nested::INestedService::Result _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::INestedService::flipStatus::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_p); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(flipStatus(in_p, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnNestedService::TRANSACTION_flipStatusWithCallback: { ::android::aidl::tests::nested::ParcelableWithNested::Status in_status; ::android::sp<::android::aidl::tests::nested::INestedService::ICallback> in_cb; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::INestedService::flipStatusWithCallback::cppServer"); _aidl_ret_status = _aidl_data.readByte(reinterpret_cast(&in_status)); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readStrongBinder(&in_cb); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(flipStatusWithCallback(in_status, in_cb)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { namespace nested { ::android::status_t INestedService::Result::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readByte(reinterpret_cast(&status)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t INestedService::Result::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeByte(static_cast(status)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android #include #include namespace android { namespace aidl { namespace tests { namespace nested { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_NESTED_INTERFACE(INestedService, Callback, "android.aidl.tests.nested.INestedService.ICallback") } // namespace nested } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { namespace nested { INestedService::BpCallback::BpCallback(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } ::android::binder::Status INestedService::BpCallback::done(::android::aidl::tests::nested::ParcelableWithNested::Status status) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICallback::done::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeByte(static_cast(status)); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(INestedService::BnCallback::TRANSACTION_done, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ICallback::getDefaultImpl()) [[unlikely]] { return ICallback::getDefaultImpl()->done(status); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace tests { namespace nested { INestedService::BnCallback::BnCallback() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t INestedService::BnCallback::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnCallback::TRANSACTION_done: { ::android::aidl::tests::nested::ParcelableWithNested::Status in_status; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ICallback::done::cppServer"); _aidl_ret_status = _aidl_data.readByte(reinterpret_cast(&in_status)); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(done(in_status)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_nes0100644 0000000 0000000 00000000222 15172120304 033306 xustar000000000 0000000 118 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/nested/INestedService.cpp.d 28 mtime=1776853188.5950000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/nested/INestedServi0100644 0000000 0000000 00000000427 15172120304 033057 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/nested/INestedService.cpp : \ system/tools/aidl/tests/android/aidl/tests/nested/INestedService.aidl \ system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_nes0100644 0000000 0000000 00000000226 15172120304 033312 xustar000000000 0000000 122 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/nested/ParcelableWithNested.cpp 28 mtime=1776853188.5950000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/nested/ParcelableWi0100644 0000000 0000000 00000005067 15172120304 033052 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/nested/ParcelableWithNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl */ #include namespace android { namespace aidl { namespace tests { namespace nested { ::android::status_t ParcelableWithNested::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readByte(reinterpret_cast(&status)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t ParcelableWithNested::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeByte(static_cast(status)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_nes0100644 0000000 0000000 00000000230 15172120304 033305 xustar000000000 0000000 124 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/nested/ParcelableWithNested.cpp.d 28 mtime=1776853188.5950000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/nested/ParcelableWi0100644 0000000 0000000 00000000323 15172120304 033040 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/nested/ParcelableWithNested.cpp : \ system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_uni0100644 0000000 0000000 00000000034 15172120304 033315 xustar000000000 0000000 28 mtime=1776853188.5950000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/unions/0040755 0000000 0000000 00000000000 15172120304 030621 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_uni0100644 0000000 0000000 00000000213 15172120304 033314 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/unions/EnumUnion.cpp 28 mtime=1776853188.5950000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/unions/EnumUnion.cp0100644 0000000 0000000 00000006432 15172120304 033064 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/unions/EnumUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl */ #include namespace android { namespace aidl { namespace tests { namespace unions { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" ::android::status_t EnumUnion::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_tag)) != ::android::OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case intEnum: { ::android::aidl::tests::IntEnum _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32(reinterpret_cast(&_aidl_value))) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::android::aidl::tests::IntEnum>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case longEnum: { ::android::aidl::tests::LongEnum _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt64(reinterpret_cast(&_aidl_value))) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::android::aidl::tests::LongEnum>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case deprecatedField: { int32_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } } return ::android::BAD_VALUE; } ::android::status_t EnumUnion::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(getTag())); if (_aidl_ret_status != ::android::OK) return _aidl_ret_status; switch (getTag()) { case intEnum: return _aidl_parcel->writeInt32(static_cast(get())); case longEnum: return _aidl_parcel->writeInt64(static_cast(get())); #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" case deprecatedField: return _aidl_parcel->writeInt32(get()); #pragma clang diagnostic pop } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } #pragma clang diagnostic pop } // namespace unions } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_uni0100644 0000000 0000000 00000000215 15172120304 033316 xustar000000000 0000000 113 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/unions/EnumUnion.cpp.d 28 mtime=1776853188.5960000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/unions/EnumUnion.cp0100644 0000000 0000000 00000000466 15172120304 033065 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/unions/EnumUnion.cpp : \ system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_uni0100644 0000000 0000000 00000000216 15172120304 033317 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/unions/UnionInUnion.cpp 28 mtime=1776853188.5960000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/unions/UnionInUnion0100644 0000000 0000000 00000004670 15172120304 033140 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/unions/UnionInUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/UnionInUnion.aidl */ #include namespace android { namespace aidl { namespace tests { namespace unions { ::android::status_t UnionInUnion::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_tag)) != ::android::OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case first: { ::android::aidl::tests::unions::EnumUnion _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readParcelable(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::android::aidl::tests::unions::EnumUnion>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case second: { int32_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } } return ::android::BAD_VALUE; } ::android::status_t UnionInUnion::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(getTag())); if (_aidl_ret_status != ::android::OK) return _aidl_ret_status; switch (getTag()) { case first: return _aidl_parcel->writeParcelable(get()); case second: return _aidl_parcel->writeInt32(get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace unions } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_android_aidl_tests_uni0100644 0000000 0000000 00000000220 15172120304 033312 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/unions/UnionInUnion.cpp.d 28 mtime=1776853188.5960000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/android/aidl/tests/unions/UnionInUnion0100644 0000000 0000000 00000000601 15172120304 033126 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/android/aidl/tests/unions/UnionInUnion.cpp : \ system/tools/aidl/tests/android/aidl/tests/unions/UnionInUnion.aidl \ system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_0100644 0000000 0000000 00000000034 15172120304 030371 xustar000000000 0000000 28 mtime=1776853188.5960000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/0040755 0000000 0000000 00000000000 15172120304 025236 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_0100644 0000000 0000000 00000000034 15172120304 032071 xustar000000000 0000000 28 mtime=1776853188.5960000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/0040755 0000000 0000000 00000000000 15172120304 026656 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_0100644 0000000 0000000 00000000034 15172120304 033062 xustar000000000 0000000 28 mtime=1776853188.5960000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/0040755 0000000 0000000 00000000000 15172120304 027567 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000034 15172120304 033246 xustar000000000 0000000 28 mtime=1776853188.5960000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/0040755 0000000 0000000 00000000000 15172120304 030731 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000222 15172120304 033245 xustar000000000 0000000 118 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/ArrayOfInterfaces.h 28 mtime=1776853188.5970000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/ArrayOfInte0100644 0000000 0000000 00000043637 15172120304 033051 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ArrayOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ArrayOfInterfaces.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace android { namespace aidl { namespace tests { class ArrayOfInterfaces : public ::android::Parcelable { public: class IEmptyInterfaceDelegator; class IEmptyInterface : public ::android::IInterface { public: typedef IEmptyInterfaceDelegator DefaultDelegator; DECLARE_META_INTERFACE(EmptyInterface) }; // class IEmptyInterface class IEmptyInterfaceDefault : public IEmptyInterface { public: ::android::IBinder* onAsBinder() override { return nullptr; } }; // class IEmptyInterfaceDefault class BpEmptyInterface : public ::android::BpInterface { public: explicit BpEmptyInterface(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpEmptyInterface() = default; }; // class BpEmptyInterface class BnEmptyInterface : public ::android::BnInterface { public: explicit BnEmptyInterface(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnEmptyInterface class IEmptyInterfaceDelegator : public BnEmptyInterface { public: explicit IEmptyInterfaceDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } private: ::android::sp _aidl_delegate; }; // class IEmptyInterfaceDelegator class IMyInterfaceDelegator; class IMyInterface : public ::android::IInterface { public: typedef IMyInterfaceDelegator DefaultDelegator; DECLARE_META_INTERFACE(MyInterface) virtual ::android::binder::Status methodWithInterfaces(const ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& iface, const ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& nullable_iface, const ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>& iface_array_in, ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>* iface_array_out, ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>* iface_array_inout, const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>& nullable_iface_array_in, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>* nullable_iface_array_out, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>* nullable_iface_array_inout, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>* _aidl_return) = 0; }; // class IMyInterface class IMyInterfaceDefault : public IMyInterface { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status methodWithInterfaces(const ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& /*iface*/, const ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& /*nullable_iface*/, const ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>& /*iface_array_in*/, ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>* /*iface_array_out*/, ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>* /*iface_array_inout*/, const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>& /*nullable_iface_array_in*/, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>* /*nullable_iface_array_out*/, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>* /*nullable_iface_array_inout*/, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } }; // class IMyInterfaceDefault class BpMyInterface : public ::android::BpInterface { public: explicit BpMyInterface(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpMyInterface() = default; ::android::binder::Status methodWithInterfaces(const ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& iface, const ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& nullable_iface, const ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>& iface_array_in, ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>* iface_array_out, ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>* iface_array_inout, const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>& nullable_iface_array_in, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>* nullable_iface_array_out, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>* nullable_iface_array_inout, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>* _aidl_return) override; }; // class BpMyInterface class BnMyInterface : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_methodWithInterfaces = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; explicit BnMyInterface(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnMyInterface class IMyInterfaceDelegator : public BnMyInterface { public: explicit IMyInterfaceDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status methodWithInterfaces(const ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& iface, const ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& nullable_iface, const ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>& iface_array_in, ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>* iface_array_out, ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>* iface_array_inout, const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>& nullable_iface_array_in, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>* nullable_iface_array_out, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>* nullable_iface_array_inout, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>* _aidl_return) override { ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterfaceDelegator> _iface; if (iface) { _iface = ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterfaceDelegator>::cast(delegate(iface)); } ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterfaceDelegator> _nullable_iface; if (nullable_iface) { _nullable_iface = ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterfaceDelegator>::cast(delegate(nullable_iface)); } return _aidl_delegate->methodWithInterfaces(_iface, _nullable_iface, iface_array_in, iface_array_out, iface_array_inout, nullable_iface_array_in, nullable_iface_array_out, nullable_iface_array_inout, _aidl_return); } private: ::android::sp _aidl_delegate; }; // class IMyInterfaceDelegator class MyParcelable : public ::android::Parcelable { public: ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface> iface; ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface> nullable_iface; ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>> iface_array; ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>> nullable_iface_array; inline bool operator==(const MyParcelable& _rhs) const { return std::tie(iface, nullable_iface, iface_array, nullable_iface_array) == std::tie(_rhs.iface, _rhs.nullable_iface, _rhs.iface_array, _rhs.nullable_iface_array); } inline bool operator<(const MyParcelable& _rhs) const { return std::tie(iface, nullable_iface, iface_array, nullable_iface_array) < std::tie(_rhs.iface, _rhs.nullable_iface, _rhs.iface_array, _rhs.nullable_iface_array); } inline bool operator!=(const MyParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyParcelable& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.ArrayOfInterfaces.MyParcelable"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "MyParcelable{"; _aidl_os << "iface: " << ::android::internal::ToString(iface); _aidl_os << ", nullable_iface: " << ::android::internal::ToString(nullable_iface); _aidl_os << ", iface_array: " << ::android::internal::ToString(iface_array); _aidl_os << ", nullable_iface_array: " << ::android::internal::ToString(nullable_iface_array); _aidl_os << "}"; return _aidl_os.str(); } }; // class MyParcelable class MyUnion : public ::android::Parcelable { public: enum class Tag : int32_t { iface = 0, nullable_iface = 1, iface_array = 2, nullable_iface_array = 3, }; // Expose tag symbols for legacy code static const inline Tag iface = Tag::iface; static const inline Tag nullable_iface = Tag::nullable_iface; static const inline Tag iface_array = Tag::iface_array; static const inline Tag nullable_iface_array = Tag::nullable_iface_array; template static constexpr bool _not_self = !std::is_same_v>, MyUnion>; MyUnion() : _value(std::in_place_index(iface)>, ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>()) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr MyUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit MyUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static MyUnion make(_Tp&&... _args) { return MyUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static MyUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return MyUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } inline bool operator==(const MyUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const MyUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const MyUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyUnion& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.ArrayOfInterfaces.MyUnion"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream os; os << "MyUnion{"; switch (getTag()) { case iface: os << "iface: " << ::android::internal::ToString(get()); break; case nullable_iface: os << "nullable_iface: " << ::android::internal::ToString(get()); break; case iface_array: os << "iface_array: " << ::android::internal::ToString(get()); break; case nullable_iface_array: os << "nullable_iface_array: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>, ::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>, ::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>>>> _value; }; // class MyUnion inline bool operator==(const ArrayOfInterfaces&) const { return std::tie() == std::tie(); } inline bool operator<(const ArrayOfInterfaces&) const { return std::tie() < std::tie(); } inline bool operator!=(const ArrayOfInterfaces& _rhs) const { return !(*this == _rhs); } inline bool operator>(const ArrayOfInterfaces& _rhs) const { return _rhs < *this; } inline bool operator>=(const ArrayOfInterfaces& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const ArrayOfInterfaces& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.ArrayOfInterfaces"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "ArrayOfInterfaces{"; _aidl_os << "}"; return _aidl_os.str(); } }; // class ArrayOfInterfaces } // namespace tests } // namespace aidl } // namespace android namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(ArrayOfInterfaces::MyUnion::Tag val) { switch(val) { case ArrayOfInterfaces::MyUnion::Tag::iface: return "iface"; case ArrayOfInterfaces::MyUnion::Tag::nullable_iface: return "nullable_iface"; case ArrayOfInterfaces::MyUnion::Tag::iface_array: return "iface_array"; case ArrayOfInterfaces::MyUnion::Tag::nullable_iface_array: return "nullable_iface_array"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::tests::ArrayOfInterfaces::MyUnion::Tag, 4> enum_values<::android::aidl::tests::ArrayOfInterfaces::MyUnion::Tag> = { ::android::aidl::tests::ArrayOfInterfaces::MyUnion::Tag::iface, ::android::aidl::tests::ArrayOfInterfaces::MyUnion::Tag::nullable_iface, ::android::aidl::tests::ArrayOfInterfaces::MyUnion::Tag::iface_array, ::android::aidl::tests::ArrayOfInterfaces::MyUnion::Tag::nullable_iface_array, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000214 15172120304 033246 xustar000000000 0000000 112 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BackendType.h 28 mtime=1776853188.5970000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BackendType0100644 0000000 0000000 00000003510 15172120304 033041 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/BackendType.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/BackendType.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { enum class BackendType : int8_t { CPP = 0, JAVA = 1, NDK = 2, RUST = 3, }; } // namespace tests } // namespace aidl } // namespace android namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(BackendType val) { switch(val) { case BackendType::CPP: return "CPP"; case BackendType::JAVA: return "JAVA"; case BackendType::NDK: return "NDK"; case BackendType::RUST: return "RUST"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::tests::BackendType, 4> enum_values<::android::aidl::tests::BackendType> = { ::android::aidl::tests::BackendType::CPP, ::android::aidl::tests::BackendType::JAVA, ::android::aidl::tests::BackendType::NDK, ::android::aidl::tests::BackendType::RUST, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000224 15172120304 033247 xustar000000000 0000000 120 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnArrayOfInterfaces.h 28 mtime=1776853188.5970000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnArrayOfIn0100644 0000000 0000000 00000001232 15172120304 032761 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ArrayOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ArrayOfInterfaces.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000216 15172120304 033250 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnBackendType.h 28 mtime=1776853188.5970000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnBackendTy0100644 0000000 0000000 00000001210 15172120304 032767 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/BackendType.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/BackendType.aidl */ #error TODO(b/111362593) enums do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000213 15172120304 033245 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnByteEnum.h 28 mtime=1776853188.5980000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnByteEnum.0100644 0000000 0000000 00000001202 15172120304 032732 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ByteEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl */ #error TODO(b/111362593) enums do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000213 15172120304 033245 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnCircular.h 28 mtime=1776853188.5980000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnCircular.0100644 0000000 0000000 00000003642 15172120304 032760 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ICircular.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ICircular.aidl */ #pragma once #include #include #include #include #include namespace android { namespace aidl { namespace tests { class BnCircular : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_GetTestService = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; explicit BnCircular(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnCircular class ICircularDelegator : public BnCircular { public: explicit ICircularDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status GetTestService(::android::sp<::android::aidl::tests::ITestService>* _aidl_return) override { auto _status = _aidl_delegate->GetTestService(_aidl_return); if (*_aidl_return) { *_aidl_return = ::android::sp<::android::aidl::tests::ITestServiceDelegator>::cast(delegate(*_aidl_return)); } return _status; } private: ::android::sp _aidl_delegate; }; // class ICircularDelegator } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000225 15172120304 033250 xustar000000000 0000000 121 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnCircularParcelable.h 28 mtime=1776853188.5980000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnCircularP0100644 0000000 0000000 00000001234 15172120304 033015 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/CircularParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000231 15172120304 033245 xustar000000000 0000000 125 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnConstantExpressionEnum.h 28 mtime=1776853188.5980000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnConstantE0100644 0000000 0000000 00000001236 15172120304 033031 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ConstantExpressionEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl */ #error TODO(b/111362593) enums do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000215 15172120304 033247 xustar000000000 0000000 113 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnDeprecated.h 28 mtime=1776853188.5980000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnDeprecate0100644 0000000 0000000 00000003015 15172120304 033024 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/IDeprecated.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IDeprecated.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { class __attribute__((deprecated("test"))) BnDeprecated : public ::android::BnInterface { public: explicit BnDeprecated(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnDeprecated class __attribute__((deprecated("test"))) IDeprecatedDelegator : public BnDeprecated { public: explicit IDeprecatedDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } private: ::android::sp _aidl_delegate; }; // class IDeprecatedDelegator } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000221 15172120304 033244 xustar000000000 0000000 117 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnDeprecatedEnum.h 28 mtime=1776853188.5980000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnDeprecate0100644 0000000 0000000 00000001216 15172120304 033025 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/DeprecatedEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedEnum.aidl */ #error TODO(b/111362593) enums do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000227 15172120304 033252 xustar000000000 0000000 123 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnDeprecatedParcelable.h 28 mtime=1776853188.5980000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnDeprecate0100644 0000000 0000000 00000001240 15172120304 033022 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/DeprecatedParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedParcelable.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000214 15172120304 033246 xustar000000000 0000000 112 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnFixedSize.h 28 mtime=1776853188.5980000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnFixedSize0100644 0000000 0000000 00000001212 15172120304 033017 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/FixedSize.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/FixedSize.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000236 15172120304 033252 xustar000000000 0000000 130 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnGenericStructuredParcelable.h 28 mtime=1776853188.5980000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnGenericSt0100644 0000000 0000000 00000001256 15172120304 033020 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/GenericStructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000212 15172120304 033244 xustar000000000 0000000 110 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnIntEnum.h 28 mtime=1776853188.5980000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnIntEnum.h0100644 0000000 0000000 00000001200 15172120304 032727 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/IntEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl */ #error TODO(b/111362593) enums do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000223 15172120304 033246 xustar000000000 0000000 119 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnListOfInterfaces.h 28 mtime=1776853188.5980000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnListOfInt0100644 0000000 0000000 00000001230 15172120304 033000 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ListOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ListOfInterfaces.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000213 15172120304 033245 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnLongEnum.h 28 mtime=1776853188.5980000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnLongEnum.0100644 0000000 0000000 00000001202 15172120304 032726 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/LongEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl */ #error TODO(b/111362593) enums do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000220 15172120304 033243 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnNamedCallback.h 28 mtime=1776853188.5980000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnNamedCall0100644 0000000 0000000 00000003334 15172120304 032754 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/INamedCallback.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { class BnNamedCallback : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_GetName = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; explicit BnNamedCallback(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnNamedCallback class INamedCallbackDelegator : public BnNamedCallback { public: explicit INamedCallbackDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status GetName(::android::String16* _aidl_return) override { return _aidl_delegate->GetName(_aidl_return); } private: ::android::sp _aidl_delegate; }; // class INamedCallbackDelegator } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000212 15172120304 033244 xustar000000000 0000000 110 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnNewName.h 28 mtime=1776853188.5990000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnNewName.h0100644 0000000 0000000 00000003205 15172120304 032711 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/INewName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INewName.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { class BnNewName : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_RealName = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; explicit BnNewName(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnNewName class INewNameDelegator : public BnNewName { public: explicit INewNameDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status RealName(::android::String16* _aidl_return) override { return _aidl_delegate->RealName(_aidl_return); } private: ::android::sp _aidl_delegate; }; // class INewNameDelegator } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000212 15172120304 033244 xustar000000000 0000000 110 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnOldName.h 28 mtime=1776853188.6000000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnOldName.h0100644 0000000 0000000 00000003205 15172120304 032676 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/IOldName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IOldName.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { class BnOldName : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_RealName = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; explicit BnOldName(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnOldName class IOldNameDelegator : public BnOldName { public: explicit IOldNameDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status RealName(::android::String16* _aidl_return) override { return _aidl_delegate->RealName(_aidl_return); } private: ::android::sp _aidl_delegate; }; // class IOldNameDelegator } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000235 15172120304 033251 xustar000000000 0000000 129 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnOtherParcelableForToString.h 28 mtime=1776853188.6010000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnOtherParc0100644 0000000 0000000 00000001254 15172120304 033022 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/OtherParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000230 15172120304 033244 xustar000000000 0000000 124 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnParcelableForToString.h 28 mtime=1776853188.6010000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnParcelabl0100644 0000000 0000000 00000001242 15172120304 033015 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ParcelableForToString.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000220 15172120304 033243 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnRecursiveList.h 28 mtime=1776853188.6010000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnRecursive0100644 0000000 0000000 00000001222 15172120304 033075 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/RecursiveList.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000227 15172120304 033252 xustar000000000 0000000 123 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnStructuredParcelable.h 28 mtime=1776853188.6010000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnStructure0100644 0000000 0000000 00000001240 15172120304 033126 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/StructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000216 15172120304 033250 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnTestService.h 28 mtime=1776853188.6010000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnTestServi0100644 0000000 0000000 00000066644 15172120304 033101 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ITestService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ITestService.aidl */ #pragma once #include #include #include #include #include #include #include #include #include namespace android { namespace aidl { namespace tests { class BnTestService : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_UnimplementedMethod = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_Deprecated = ::android::IBinder::FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_TestOneway = ::android::IBinder::FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_RepeatBoolean = ::android::IBinder::FIRST_CALL_TRANSACTION + 3; static constexpr uint32_t TRANSACTION_RepeatByte = ::android::IBinder::FIRST_CALL_TRANSACTION + 4; static constexpr uint32_t TRANSACTION_RepeatChar = ::android::IBinder::FIRST_CALL_TRANSACTION + 5; static constexpr uint32_t TRANSACTION_RepeatInt = ::android::IBinder::FIRST_CALL_TRANSACTION + 6; static constexpr uint32_t TRANSACTION_RepeatLong = ::android::IBinder::FIRST_CALL_TRANSACTION + 7; static constexpr uint32_t TRANSACTION_RepeatFloat = ::android::IBinder::FIRST_CALL_TRANSACTION + 8; static constexpr uint32_t TRANSACTION_RepeatDouble = ::android::IBinder::FIRST_CALL_TRANSACTION + 9; static constexpr uint32_t TRANSACTION_RepeatString = ::android::IBinder::FIRST_CALL_TRANSACTION + 10; static constexpr uint32_t TRANSACTION_RepeatByteEnum = ::android::IBinder::FIRST_CALL_TRANSACTION + 11; static constexpr uint32_t TRANSACTION_RepeatIntEnum = ::android::IBinder::FIRST_CALL_TRANSACTION + 12; static constexpr uint32_t TRANSACTION_RepeatLongEnum = ::android::IBinder::FIRST_CALL_TRANSACTION + 13; static constexpr uint32_t TRANSACTION_ReverseBoolean = ::android::IBinder::FIRST_CALL_TRANSACTION + 14; static constexpr uint32_t TRANSACTION_ReverseByte = ::android::IBinder::FIRST_CALL_TRANSACTION + 15; static constexpr uint32_t TRANSACTION_ReverseChar = ::android::IBinder::FIRST_CALL_TRANSACTION + 16; static constexpr uint32_t TRANSACTION_ReverseInt = ::android::IBinder::FIRST_CALL_TRANSACTION + 17; static constexpr uint32_t TRANSACTION_ReverseLong = ::android::IBinder::FIRST_CALL_TRANSACTION + 18; static constexpr uint32_t TRANSACTION_ReverseFloat = ::android::IBinder::FIRST_CALL_TRANSACTION + 19; static constexpr uint32_t TRANSACTION_ReverseDouble = ::android::IBinder::FIRST_CALL_TRANSACTION + 20; static constexpr uint32_t TRANSACTION_ReverseString = ::android::IBinder::FIRST_CALL_TRANSACTION + 21; static constexpr uint32_t TRANSACTION_ReverseByteEnum = ::android::IBinder::FIRST_CALL_TRANSACTION + 22; static constexpr uint32_t TRANSACTION_ReverseIntEnum = ::android::IBinder::FIRST_CALL_TRANSACTION + 23; static constexpr uint32_t TRANSACTION_ReverseLongEnum = ::android::IBinder::FIRST_CALL_TRANSACTION + 24; static constexpr uint32_t TRANSACTION_GetOtherTestService = ::android::IBinder::FIRST_CALL_TRANSACTION + 25; static constexpr uint32_t TRANSACTION_SetOtherTestService = ::android::IBinder::FIRST_CALL_TRANSACTION + 26; static constexpr uint32_t TRANSACTION_VerifyName = ::android::IBinder::FIRST_CALL_TRANSACTION + 27; static constexpr uint32_t TRANSACTION_GetInterfaceArray = ::android::IBinder::FIRST_CALL_TRANSACTION + 28; static constexpr uint32_t TRANSACTION_VerifyNamesWithInterfaceArray = ::android::IBinder::FIRST_CALL_TRANSACTION + 29; static constexpr uint32_t TRANSACTION_GetNullableInterfaceArray = ::android::IBinder::FIRST_CALL_TRANSACTION + 30; static constexpr uint32_t TRANSACTION_VerifyNamesWithNullableInterfaceArray = ::android::IBinder::FIRST_CALL_TRANSACTION + 31; static constexpr uint32_t TRANSACTION_GetInterfaceList = ::android::IBinder::FIRST_CALL_TRANSACTION + 32; static constexpr uint32_t TRANSACTION_VerifyNamesWithInterfaceList = ::android::IBinder::FIRST_CALL_TRANSACTION + 33; static constexpr uint32_t TRANSACTION_ReverseStringList = ::android::IBinder::FIRST_CALL_TRANSACTION + 34; static constexpr uint32_t TRANSACTION_RepeatParcelFileDescriptor = ::android::IBinder::FIRST_CALL_TRANSACTION + 35; static constexpr uint32_t TRANSACTION_ReverseParcelFileDescriptorArray = ::android::IBinder::FIRST_CALL_TRANSACTION + 36; static constexpr uint32_t TRANSACTION_ThrowServiceException = ::android::IBinder::FIRST_CALL_TRANSACTION + 37; static constexpr uint32_t TRANSACTION_RepeatNullableIntArray = ::android::IBinder::FIRST_CALL_TRANSACTION + 38; static constexpr uint32_t TRANSACTION_RepeatNullableByteEnumArray = ::android::IBinder::FIRST_CALL_TRANSACTION + 39; static constexpr uint32_t TRANSACTION_RepeatNullableIntEnumArray = ::android::IBinder::FIRST_CALL_TRANSACTION + 40; static constexpr uint32_t TRANSACTION_RepeatNullableLongEnumArray = ::android::IBinder::FIRST_CALL_TRANSACTION + 41; static constexpr uint32_t TRANSACTION_RepeatNullableString = ::android::IBinder::FIRST_CALL_TRANSACTION + 42; static constexpr uint32_t TRANSACTION_RepeatNullableStringList = ::android::IBinder::FIRST_CALL_TRANSACTION + 43; static constexpr uint32_t TRANSACTION_RepeatNullableParcelable = ::android::IBinder::FIRST_CALL_TRANSACTION + 44; static constexpr uint32_t TRANSACTION_RepeatNullableParcelableArray = ::android::IBinder::FIRST_CALL_TRANSACTION + 45; static constexpr uint32_t TRANSACTION_RepeatNullableParcelableList = ::android::IBinder::FIRST_CALL_TRANSACTION + 46; static constexpr uint32_t TRANSACTION_TakesAnIBinder = ::android::IBinder::FIRST_CALL_TRANSACTION + 47; static constexpr uint32_t TRANSACTION_TakesANullableIBinder = ::android::IBinder::FIRST_CALL_TRANSACTION + 48; static constexpr uint32_t TRANSACTION_TakesAnIBinderList = ::android::IBinder::FIRST_CALL_TRANSACTION + 49; static constexpr uint32_t TRANSACTION_TakesANullableIBinderList = ::android::IBinder::FIRST_CALL_TRANSACTION + 50; static constexpr uint32_t TRANSACTION_RepeatUtf8CppString = ::android::IBinder::FIRST_CALL_TRANSACTION + 51; static constexpr uint32_t TRANSACTION_RepeatNullableUtf8CppString = ::android::IBinder::FIRST_CALL_TRANSACTION + 52; static constexpr uint32_t TRANSACTION_ReverseUtf8CppString = ::android::IBinder::FIRST_CALL_TRANSACTION + 53; static constexpr uint32_t TRANSACTION_ReverseNullableUtf8CppString = ::android::IBinder::FIRST_CALL_TRANSACTION + 54; static constexpr uint32_t TRANSACTION_ReverseUtf8CppStringList = ::android::IBinder::FIRST_CALL_TRANSACTION + 55; static constexpr uint32_t TRANSACTION_GetCallback = ::android::IBinder::FIRST_CALL_TRANSACTION + 56; static constexpr uint32_t TRANSACTION_FillOutStructuredParcelable = ::android::IBinder::FIRST_CALL_TRANSACTION + 57; static constexpr uint32_t TRANSACTION_RepeatExtendableParcelable = ::android::IBinder::FIRST_CALL_TRANSACTION + 58; static constexpr uint32_t TRANSACTION_ReverseList = ::android::IBinder::FIRST_CALL_TRANSACTION + 59; static constexpr uint32_t TRANSACTION_ReverseIBinderArray = ::android::IBinder::FIRST_CALL_TRANSACTION + 60; static constexpr uint32_t TRANSACTION_ReverseNullableIBinderArray = ::android::IBinder::FIRST_CALL_TRANSACTION + 61; static constexpr uint32_t TRANSACTION_RepeatSimpleParcelable = ::android::IBinder::FIRST_CALL_TRANSACTION + 62; static constexpr uint32_t TRANSACTION_ReverseSimpleParcelables = ::android::IBinder::FIRST_CALL_TRANSACTION + 63; static constexpr uint32_t TRANSACTION_GetOldNameInterface = ::android::IBinder::FIRST_CALL_TRANSACTION + 64; static constexpr uint32_t TRANSACTION_GetNewNameInterface = ::android::IBinder::FIRST_CALL_TRANSACTION + 65; static constexpr uint32_t TRANSACTION_GetUnionTags = ::android::IBinder::FIRST_CALL_TRANSACTION + 66; static constexpr uint32_t TRANSACTION_GetCppJavaTests = ::android::IBinder::FIRST_CALL_TRANSACTION + 67; static constexpr uint32_t TRANSACTION_getBackendType = ::android::IBinder::FIRST_CALL_TRANSACTION + 68; static constexpr uint32_t TRANSACTION_GetCircular = ::android::IBinder::FIRST_CALL_TRANSACTION + 69; explicit BnTestService(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnTestService class ITestServiceDelegator : public BnTestService { public: explicit ITestServiceDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status UnimplementedMethod(int32_t arg, int32_t* _aidl_return) override { return _aidl_delegate->UnimplementedMethod(arg, _aidl_return); } ::android::binder::Status Deprecated() override __attribute__((deprecated("to make sure we have something in system/tools/aidl which does a compile check of deprecated and make sure this is reflected in goldens"))) { return _aidl_delegate->Deprecated(); } ::android::binder::Status TestOneway() override { return _aidl_delegate->TestOneway(); } ::android::binder::Status RepeatBoolean(bool token, bool* _aidl_return) override { return _aidl_delegate->RepeatBoolean(token, _aidl_return); } ::android::binder::Status RepeatByte(int8_t token, int8_t* _aidl_return) override { return _aidl_delegate->RepeatByte(token, _aidl_return); } ::android::binder::Status RepeatChar(char16_t token, char16_t* _aidl_return) override { return _aidl_delegate->RepeatChar(token, _aidl_return); } ::android::binder::Status RepeatInt(int32_t token, int32_t* _aidl_return) override { return _aidl_delegate->RepeatInt(token, _aidl_return); } ::android::binder::Status RepeatLong(int64_t token, int64_t* _aidl_return) override { return _aidl_delegate->RepeatLong(token, _aidl_return); } ::android::binder::Status RepeatFloat(float token, float* _aidl_return) override { return _aidl_delegate->RepeatFloat(token, _aidl_return); } ::android::binder::Status RepeatDouble(double token, double* _aidl_return) override { return _aidl_delegate->RepeatDouble(token, _aidl_return); } ::android::binder::Status RepeatString(const ::android::String16& token, ::android::String16* _aidl_return) override { return _aidl_delegate->RepeatString(token, _aidl_return); } ::android::binder::Status RepeatByteEnum(::android::aidl::tests::ByteEnum token, ::android::aidl::tests::ByteEnum* _aidl_return) override { return _aidl_delegate->RepeatByteEnum(token, _aidl_return); } ::android::binder::Status RepeatIntEnum(::android::aidl::tests::IntEnum token, ::android::aidl::tests::IntEnum* _aidl_return) override { return _aidl_delegate->RepeatIntEnum(token, _aidl_return); } ::android::binder::Status RepeatLongEnum(::android::aidl::tests::LongEnum token, ::android::aidl::tests::LongEnum* _aidl_return) override { return _aidl_delegate->RepeatLongEnum(token, _aidl_return); } ::android::binder::Status ReverseBoolean(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) override { return _aidl_delegate->ReverseBoolean(input, repeated, _aidl_return); } ::android::binder::Status ReverseByte(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) override { return _aidl_delegate->ReverseByte(input, repeated, _aidl_return); } ::android::binder::Status ReverseChar(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) override { return _aidl_delegate->ReverseChar(input, repeated, _aidl_return); } ::android::binder::Status ReverseInt(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) override { return _aidl_delegate->ReverseInt(input, repeated, _aidl_return); } ::android::binder::Status ReverseLong(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) override { return _aidl_delegate->ReverseLong(input, repeated, _aidl_return); } ::android::binder::Status ReverseFloat(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) override { return _aidl_delegate->ReverseFloat(input, repeated, _aidl_return); } ::android::binder::Status ReverseDouble(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) override { return _aidl_delegate->ReverseDouble(input, repeated, _aidl_return); } ::android::binder::Status ReverseString(const ::std::vector<::android::String16>& input, ::std::vector<::android::String16>* repeated, ::std::vector<::android::String16>* _aidl_return) override { return _aidl_delegate->ReverseString(input, repeated, _aidl_return); } ::android::binder::Status ReverseByteEnum(const ::std::vector<::android::aidl::tests::ByteEnum>& input, ::std::vector<::android::aidl::tests::ByteEnum>* repeated, ::std::vector<::android::aidl::tests::ByteEnum>* _aidl_return) override { return _aidl_delegate->ReverseByteEnum(input, repeated, _aidl_return); } ::android::binder::Status ReverseIntEnum(const ::std::vector<::android::aidl::tests::IntEnum>& input, ::std::vector<::android::aidl::tests::IntEnum>* repeated, ::std::vector<::android::aidl::tests::IntEnum>* _aidl_return) override { return _aidl_delegate->ReverseIntEnum(input, repeated, _aidl_return); } ::android::binder::Status ReverseLongEnum(const ::std::vector<::android::aidl::tests::LongEnum>& input, ::std::vector<::android::aidl::tests::LongEnum>* repeated, ::std::vector<::android::aidl::tests::LongEnum>* _aidl_return) override { return _aidl_delegate->ReverseLongEnum(input, repeated, _aidl_return); } ::android::binder::Status GetOtherTestService(const ::android::String16& name, ::android::sp<::android::aidl::tests::INamedCallback>* _aidl_return) override { auto _status = _aidl_delegate->GetOtherTestService(name, _aidl_return); if (*_aidl_return) { *_aidl_return = ::android::sp<::android::aidl::tests::INamedCallbackDelegator>::cast(delegate(*_aidl_return)); } return _status; } ::android::binder::Status SetOtherTestService(const ::android::String16& name, const ::android::sp<::android::aidl::tests::INamedCallback>& service, bool* _aidl_return) override { ::android::sp<::android::aidl::tests::INamedCallbackDelegator> _service; if (service) { _service = ::android::sp<::android::aidl::tests::INamedCallbackDelegator>::cast(delegate(service)); } return _aidl_delegate->SetOtherTestService(name, _service, _aidl_return); } ::android::binder::Status VerifyName(const ::android::sp<::android::aidl::tests::INamedCallback>& service, const ::android::String16& name, bool* _aidl_return) override { ::android::sp<::android::aidl::tests::INamedCallbackDelegator> _service; if (service) { _service = ::android::sp<::android::aidl::tests::INamedCallbackDelegator>::cast(delegate(service)); } return _aidl_delegate->VerifyName(_service, name, _aidl_return); } ::android::binder::Status GetInterfaceArray(const ::std::vector<::android::String16>& names, ::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>* _aidl_return) override { return _aidl_delegate->GetInterfaceArray(names, _aidl_return); } ::android::binder::Status VerifyNamesWithInterfaceArray(const ::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>& services, const ::std::vector<::android::String16>& names, bool* _aidl_return) override { return _aidl_delegate->VerifyNamesWithInterfaceArray(services, names, _aidl_return); } ::android::binder::Status GetNullableInterfaceArray(const ::std::optional<::std::vector<::std::optional<::android::String16>>>& names, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>* _aidl_return) override { return _aidl_delegate->GetNullableInterfaceArray(names, _aidl_return); } ::android::binder::Status VerifyNamesWithNullableInterfaceArray(const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>& services, const ::std::optional<::std::vector<::std::optional<::android::String16>>>& names, bool* _aidl_return) override { return _aidl_delegate->VerifyNamesWithNullableInterfaceArray(services, names, _aidl_return); } ::android::binder::Status GetInterfaceList(const ::std::optional<::std::vector<::std::optional<::android::String16>>>& names, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>* _aidl_return) override { return _aidl_delegate->GetInterfaceList(names, _aidl_return); } ::android::binder::Status VerifyNamesWithInterfaceList(const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>& services, const ::std::optional<::std::vector<::std::optional<::android::String16>>>& names, bool* _aidl_return) override { return _aidl_delegate->VerifyNamesWithInterfaceList(services, names, _aidl_return); } ::android::binder::Status ReverseStringList(const ::std::vector<::android::String16>& input, ::std::vector<::android::String16>* repeated, ::std::vector<::android::String16>* _aidl_return) override { return _aidl_delegate->ReverseStringList(input, repeated, _aidl_return); } ::android::binder::Status RepeatParcelFileDescriptor(const ::android::os::ParcelFileDescriptor& read, ::android::os::ParcelFileDescriptor* _aidl_return) override { return _aidl_delegate->RepeatParcelFileDescriptor(read, _aidl_return); } ::android::binder::Status ReverseParcelFileDescriptorArray(const ::std::vector<::android::os::ParcelFileDescriptor>& input, ::std::vector<::android::os::ParcelFileDescriptor>* repeated, ::std::vector<::android::os::ParcelFileDescriptor>* _aidl_return) override { return _aidl_delegate->ReverseParcelFileDescriptorArray(input, repeated, _aidl_return); } ::android::binder::Status ThrowServiceException(int32_t code) override { return _aidl_delegate->ThrowServiceException(code); } ::android::binder::Status RepeatNullableIntArray(const ::std::optional<::std::vector>& input, ::std::optional<::std::vector>* _aidl_return) override { return _aidl_delegate->RepeatNullableIntArray(input, _aidl_return); } ::android::binder::Status RepeatNullableByteEnumArray(const ::std::optional<::std::vector<::android::aidl::tests::ByteEnum>>& input, ::std::optional<::std::vector<::android::aidl::tests::ByteEnum>>* _aidl_return) override { return _aidl_delegate->RepeatNullableByteEnumArray(input, _aidl_return); } ::android::binder::Status RepeatNullableIntEnumArray(const ::std::optional<::std::vector<::android::aidl::tests::IntEnum>>& input, ::std::optional<::std::vector<::android::aidl::tests::IntEnum>>* _aidl_return) override { return _aidl_delegate->RepeatNullableIntEnumArray(input, _aidl_return); } ::android::binder::Status RepeatNullableLongEnumArray(const ::std::optional<::std::vector<::android::aidl::tests::LongEnum>>& input, ::std::optional<::std::vector<::android::aidl::tests::LongEnum>>* _aidl_return) override { return _aidl_delegate->RepeatNullableLongEnumArray(input, _aidl_return); } ::android::binder::Status RepeatNullableString(const ::std::optional<::android::String16>& input, ::std::optional<::android::String16>* _aidl_return) override { return _aidl_delegate->RepeatNullableString(input, _aidl_return); } ::android::binder::Status RepeatNullableStringList(const ::std::optional<::std::vector<::std::optional<::android::String16>>>& input, ::std::optional<::std::vector<::std::optional<::android::String16>>>* _aidl_return) override { return _aidl_delegate->RepeatNullableStringList(input, _aidl_return); } ::android::binder::Status RepeatNullableParcelable(const ::std::optional<::android::aidl::tests::ITestService::Empty>& input, ::std::optional<::android::aidl::tests::ITestService::Empty>* _aidl_return) override { return _aidl_delegate->RepeatNullableParcelable(input, _aidl_return); } ::android::binder::Status RepeatNullableParcelableArray(const ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>& input, ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>* _aidl_return) override { return _aidl_delegate->RepeatNullableParcelableArray(input, _aidl_return); } ::android::binder::Status RepeatNullableParcelableList(const ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>& input, ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>* _aidl_return) override { return _aidl_delegate->RepeatNullableParcelableList(input, _aidl_return); } ::android::binder::Status TakesAnIBinder(const ::android::sp<::android::IBinder>& input) override { return _aidl_delegate->TakesAnIBinder(input); } ::android::binder::Status TakesANullableIBinder(const ::android::sp<::android::IBinder>& input) override { return _aidl_delegate->TakesANullableIBinder(input); } ::android::binder::Status TakesAnIBinderList(const ::std::vector<::android::sp<::android::IBinder>>& input) override { return _aidl_delegate->TakesAnIBinderList(input); } ::android::binder::Status TakesANullableIBinderList(const ::std::optional<::std::vector<::android::sp<::android::IBinder>>>& input) override { return _aidl_delegate->TakesANullableIBinderList(input); } ::android::binder::Status RepeatUtf8CppString(const ::std::string& token, ::std::string* _aidl_return) override { return _aidl_delegate->RepeatUtf8CppString(token, _aidl_return); } ::android::binder::Status RepeatNullableUtf8CppString(const ::std::optional<::std::string>& token, ::std::optional<::std::string>* _aidl_return) override { return _aidl_delegate->RepeatNullableUtf8CppString(token, _aidl_return); } ::android::binder::Status ReverseUtf8CppString(const ::std::vector<::std::string>& input, ::std::vector<::std::string>* repeated, ::std::vector<::std::string>* _aidl_return) override { return _aidl_delegate->ReverseUtf8CppString(input, repeated, _aidl_return); } ::android::binder::Status ReverseNullableUtf8CppString(const ::std::optional<::std::vector<::std::optional<::std::string>>>& input, ::std::optional<::std::vector<::std::optional<::std::string>>>* repeated, ::std::optional<::std::vector<::std::optional<::std::string>>>* _aidl_return) override { return _aidl_delegate->ReverseNullableUtf8CppString(input, repeated, _aidl_return); } ::android::binder::Status ReverseUtf8CppStringList(const ::std::optional<::std::vector<::std::optional<::std::string>>>& input, ::std::optional<::std::vector<::std::optional<::std::string>>>* repeated, ::std::optional<::std::vector<::std::optional<::std::string>>>* _aidl_return) override { return _aidl_delegate->ReverseUtf8CppStringList(input, repeated, _aidl_return); } ::android::binder::Status GetCallback(bool return_null, ::android::sp<::android::aidl::tests::INamedCallback>* _aidl_return) override { auto _status = _aidl_delegate->GetCallback(return_null, _aidl_return); if (*_aidl_return) { *_aidl_return = ::android::sp<::android::aidl::tests::INamedCallbackDelegator>::cast(delegate(*_aidl_return)); } return _status; } ::android::binder::Status FillOutStructuredParcelable(::android::aidl::tests::StructuredParcelable* parcel) override { return _aidl_delegate->FillOutStructuredParcelable(parcel); } ::android::binder::Status RepeatExtendableParcelable(const ::android::aidl::tests::extension::ExtendableParcelable& ep, ::android::aidl::tests::extension::ExtendableParcelable* ep2) override { return _aidl_delegate->RepeatExtendableParcelable(ep, ep2); } ::android::binder::Status ReverseList(const ::android::aidl::tests::RecursiveList& list, ::android::aidl::tests::RecursiveList* _aidl_return) override { return _aidl_delegate->ReverseList(list, _aidl_return); } ::android::binder::Status ReverseIBinderArray(const ::std::vector<::android::sp<::android::IBinder>>& input, ::std::vector<::android::sp<::android::IBinder>>* repeated, ::std::vector<::android::sp<::android::IBinder>>* _aidl_return) override { return _aidl_delegate->ReverseIBinderArray(input, repeated, _aidl_return); } ::android::binder::Status ReverseNullableIBinderArray(const ::std::optional<::std::vector<::android::sp<::android::IBinder>>>& input, ::std::optional<::std::vector<::android::sp<::android::IBinder>>>* repeated, ::std::optional<::std::vector<::android::sp<::android::IBinder>>>* _aidl_return) override { return _aidl_delegate->ReverseNullableIBinderArray(input, repeated, _aidl_return); } ::android::binder::Status RepeatSimpleParcelable(const ::android::aidl::tests::SimpleParcelable& input, ::android::aidl::tests::SimpleParcelable* repeat, ::android::aidl::tests::SimpleParcelable* _aidl_return) override { return _aidl_delegate->RepeatSimpleParcelable(input, repeat, _aidl_return); } ::android::binder::Status ReverseSimpleParcelables(const ::std::vector<::android::aidl::tests::SimpleParcelable>& input, ::std::vector<::android::aidl::tests::SimpleParcelable>* repeated, ::std::vector<::android::aidl::tests::SimpleParcelable>* _aidl_return) override { return _aidl_delegate->ReverseSimpleParcelables(input, repeated, _aidl_return); } ::android::binder::Status GetOldNameInterface(::android::sp<::android::aidl::tests::IOldName>* _aidl_return) override { auto _status = _aidl_delegate->GetOldNameInterface(_aidl_return); if (*_aidl_return) { *_aidl_return = ::android::sp<::android::aidl::tests::IOldNameDelegator>::cast(delegate(*_aidl_return)); } return _status; } ::android::binder::Status GetNewNameInterface(::android::sp<::android::aidl::tests::INewName>* _aidl_return) override { auto _status = _aidl_delegate->GetNewNameInterface(_aidl_return); if (*_aidl_return) { *_aidl_return = ::android::sp<::android::aidl::tests::INewNameDelegator>::cast(delegate(*_aidl_return)); } return _status; } ::android::binder::Status GetUnionTags(const ::std::vector<::android::aidl::tests::Union>& input, ::std::vector<::android::aidl::tests::Union::Tag>* _aidl_return) override { return _aidl_delegate->GetUnionTags(input, _aidl_return); } ::android::binder::Status GetCppJavaTests(::android::sp<::android::IBinder>* _aidl_return) override { return _aidl_delegate->GetCppJavaTests(_aidl_return); } ::android::binder::Status getBackendType(::android::aidl::tests::BackendType* _aidl_return) override { return _aidl_delegate->getBackendType(_aidl_return); } ::android::binder::Status GetCircular(::android::aidl::tests::CircularParcelable* cp, ::android::sp<::android::aidl::tests::ICircular>* _aidl_return) override { auto _status = _aidl_delegate->GetCircular(cp, _aidl_return); if (*_aidl_return) { *_aidl_return = ::android::sp<::android::aidl::tests::ICircularDelegator>::cast(delegate(*_aidl_return)); } return _status; } private: ::android::sp _aidl_delegate; }; // class ITestServiceDelegator } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000034 15172120304 033246 xustar000000000 0000000 28 mtime=1776853188.6020000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnUnion.h0100644 0000000 0000000 00000001202 15172120304 032442 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/Union.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/Union.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000216 15172120304 033250 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnUnionWithFd.h 28 mtime=1776853188.6020000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BnUnionWith0100644 0000000 0000000 00000001216 15172120304 033055 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/UnionWithFd.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/UnionWithFd.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000224 15172120304 033247 xustar000000000 0000000 120 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpArrayOfInterfaces.h 28 mtime=1776853188.6020000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpArrayOfIn0100644 0000000 0000000 00000001232 15172120304 032763 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ArrayOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ArrayOfInterfaces.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000216 15172120304 033250 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpBackendType.h 28 mtime=1776853188.6020000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpBackendTy0100644 0000000 0000000 00000001210 15172120304 032771 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/BackendType.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/BackendType.aidl */ #error TODO(b/111362593) enums do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000213 15172120304 033245 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpByteEnum.h 28 mtime=1776853188.6020000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpByteEnum.0100644 0000000 0000000 00000001202 15172120304 032734 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ByteEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl */ #error TODO(b/111362593) enums do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000213 15172120304 033245 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpCircular.h 28 mtime=1776853188.6020000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpCircular.0100644 0000000 0000000 00000002234 15172120304 032756 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ICircular.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ICircular.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { class BpCircular : public ::android::BpInterface { public: explicit BpCircular(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpCircular() = default; ::android::binder::Status GetTestService(::android::sp<::android::aidl::tests::ITestService>* _aidl_return) override; }; // class BpCircular } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000225 15172120304 033250 xustar000000000 0000000 121 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpCircularParcelable.h 28 mtime=1776853188.6020000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpCircularP0100644 0000000 0000000 00000001234 15172120304 033017 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/CircularParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000231 15172120304 033245 xustar000000000 0000000 125 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpConstantExpressionEnum.h 28 mtime=1776853188.6020000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpConstantE0100644 0000000 0000000 00000001236 15172120304 033033 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ConstantExpressionEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl */ #error TODO(b/111362593) enums do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000215 15172120304 033247 xustar000000000 0000000 113 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpDeprecated.h 28 mtime=1776853188.6030000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpDeprecate0100644 0000000 0000000 00000002130 15172120304 033023 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/IDeprecated.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IDeprecated.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { class __attribute__((deprecated("test"))) BpDeprecated : public ::android::BpInterface { public: explicit BpDeprecated(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpDeprecated() = default; }; // class BpDeprecated } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000221 15172120304 033244 xustar000000000 0000000 117 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpDeprecatedEnum.h 28 mtime=1776853188.6030000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpDeprecate0100644 0000000 0000000 00000001216 15172120304 033027 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/DeprecatedEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedEnum.aidl */ #error TODO(b/111362593) enums do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000227 15172120304 033252 xustar000000000 0000000 123 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpDeprecatedParcelable.h 28 mtime=1776853188.6030000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpDeprecate0100644 0000000 0000000 00000001240 15172120304 033024 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/DeprecatedParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedParcelable.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000214 15172120304 033246 xustar000000000 0000000 112 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpFixedSize.h 28 mtime=1776853188.6030000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpFixedSize0100644 0000000 0000000 00000001212 15172120304 033021 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/FixedSize.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/FixedSize.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000236 15172120304 033252 xustar000000000 0000000 130 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpGenericStructuredParcelable.h 28 mtime=1776853188.6030000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpGenericSt0100644 0000000 0000000 00000001256 15172120304 033022 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/GenericStructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000212 15172120304 033244 xustar000000000 0000000 110 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpIntEnum.h 28 mtime=1776853188.6030000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpIntEnum.h0100644 0000000 0000000 00000001200 15172120304 032731 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/IntEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl */ #error TODO(b/111362593) enums do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000223 15172120304 033246 xustar000000000 0000000 119 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpListOfInterfaces.h 28 mtime=1776853188.6030000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpListOfInt0100644 0000000 0000000 00000001230 15172120304 033002 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ListOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ListOfInterfaces.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000213 15172120304 033245 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpLongEnum.h 28 mtime=1776853188.6030000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpLongEnum.0100644 0000000 0000000 00000001202 15172120304 032730 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/LongEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl */ #error TODO(b/111362593) enums do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000220 15172120304 033243 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpNamedCallback.h 28 mtime=1776853188.6030000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpNamedCall0100644 0000000 0000000 00000002235 15172120304 032755 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/INamedCallback.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { class BpNamedCallback : public ::android::BpInterface { public: explicit BpNamedCallback(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpNamedCallback() = default; ::android::binder::Status GetName(::android::String16* _aidl_return) override; }; // class BpNamedCallback } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000212 15172120304 033244 xustar000000000 0000000 110 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpNewName.h 28 mtime=1776853188.6030000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpNewName.h0100644 0000000 0000000 00000002156 15172120304 032717 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/INewName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INewName.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { class BpNewName : public ::android::BpInterface { public: explicit BpNewName(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpNewName() = default; ::android::binder::Status RealName(::android::String16* _aidl_return) override; }; // class BpNewName } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000212 15172120304 033244 xustar000000000 0000000 110 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpOldName.h 28 mtime=1776853188.6030000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpOldName.h0100644 0000000 0000000 00000002156 15172120304 032704 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/IOldName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IOldName.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { class BpOldName : public ::android::BpInterface { public: explicit BpOldName(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpOldName() = default; ::android::binder::Status RealName(::android::String16* _aidl_return) override; }; // class BpOldName } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000235 15172120304 033251 xustar000000000 0000000 129 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpOtherParcelableForToString.h 28 mtime=1776853188.6030000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpOtherParc0100644 0000000 0000000 00000001254 15172120304 033024 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/OtherParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000230 15172120304 033244 xustar000000000 0000000 124 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpParcelableForToString.h 28 mtime=1776853188.6030000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpParcelabl0100644 0000000 0000000 00000001242 15172120304 033017 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ParcelableForToString.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000220 15172120304 033243 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpRecursiveList.h 28 mtime=1776853188.6030000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpRecursive0100644 0000000 0000000 00000001222 15172120304 033077 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/RecursiveList.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000227 15172120304 033252 xustar000000000 0000000 123 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpStructuredParcelable.h 28 mtime=1776853188.6030000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpStructure0100644 0000000 0000000 00000001240 15172120304 033130 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/StructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000216 15172120304 033250 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpTestService.h 28 mtime=1776853188.6040000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpTestServi0100644 0000000 0000000 00000031663 15172120304 033074 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ITestService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ITestService.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { class BpTestService : public ::android::BpInterface { public: explicit BpTestService(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpTestService() = default; ::android::binder::Status UnimplementedMethod(int32_t arg, int32_t* _aidl_return) override; ::android::binder::Status Deprecated() override __attribute__((deprecated("to make sure we have something in system/tools/aidl which does a compile check of deprecated and make sure this is reflected in goldens"))); ::android::binder::Status TestOneway() override; ::android::binder::Status RepeatBoolean(bool token, bool* _aidl_return) override; ::android::binder::Status RepeatByte(int8_t token, int8_t* _aidl_return) override; ::android::binder::Status RepeatChar(char16_t token, char16_t* _aidl_return) override; ::android::binder::Status RepeatInt(int32_t token, int32_t* _aidl_return) override; ::android::binder::Status RepeatLong(int64_t token, int64_t* _aidl_return) override; ::android::binder::Status RepeatFloat(float token, float* _aidl_return) override; ::android::binder::Status RepeatDouble(double token, double* _aidl_return) override; ::android::binder::Status RepeatString(const ::android::String16& token, ::android::String16* _aidl_return) override; ::android::binder::Status RepeatByteEnum(::android::aidl::tests::ByteEnum token, ::android::aidl::tests::ByteEnum* _aidl_return) override; ::android::binder::Status RepeatIntEnum(::android::aidl::tests::IntEnum token, ::android::aidl::tests::IntEnum* _aidl_return) override; ::android::binder::Status RepeatLongEnum(::android::aidl::tests::LongEnum token, ::android::aidl::tests::LongEnum* _aidl_return) override; ::android::binder::Status ReverseBoolean(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) override; ::android::binder::Status ReverseByte(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) override; ::android::binder::Status ReverseChar(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) override; ::android::binder::Status ReverseInt(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) override; ::android::binder::Status ReverseLong(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) override; ::android::binder::Status ReverseFloat(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) override; ::android::binder::Status ReverseDouble(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) override; ::android::binder::Status ReverseString(const ::std::vector<::android::String16>& input, ::std::vector<::android::String16>* repeated, ::std::vector<::android::String16>* _aidl_return) override; ::android::binder::Status ReverseByteEnum(const ::std::vector<::android::aidl::tests::ByteEnum>& input, ::std::vector<::android::aidl::tests::ByteEnum>* repeated, ::std::vector<::android::aidl::tests::ByteEnum>* _aidl_return) override; ::android::binder::Status ReverseIntEnum(const ::std::vector<::android::aidl::tests::IntEnum>& input, ::std::vector<::android::aidl::tests::IntEnum>* repeated, ::std::vector<::android::aidl::tests::IntEnum>* _aidl_return) override; ::android::binder::Status ReverseLongEnum(const ::std::vector<::android::aidl::tests::LongEnum>& input, ::std::vector<::android::aidl::tests::LongEnum>* repeated, ::std::vector<::android::aidl::tests::LongEnum>* _aidl_return) override; ::android::binder::Status GetOtherTestService(const ::android::String16& name, ::android::sp<::android::aidl::tests::INamedCallback>* _aidl_return) override; ::android::binder::Status SetOtherTestService(const ::android::String16& name, const ::android::sp<::android::aidl::tests::INamedCallback>& service, bool* _aidl_return) override; ::android::binder::Status VerifyName(const ::android::sp<::android::aidl::tests::INamedCallback>& service, const ::android::String16& name, bool* _aidl_return) override; ::android::binder::Status GetInterfaceArray(const ::std::vector<::android::String16>& names, ::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>* _aidl_return) override; ::android::binder::Status VerifyNamesWithInterfaceArray(const ::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>& services, const ::std::vector<::android::String16>& names, bool* _aidl_return) override; ::android::binder::Status GetNullableInterfaceArray(const ::std::optional<::std::vector<::std::optional<::android::String16>>>& names, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>* _aidl_return) override; ::android::binder::Status VerifyNamesWithNullableInterfaceArray(const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>& services, const ::std::optional<::std::vector<::std::optional<::android::String16>>>& names, bool* _aidl_return) override; ::android::binder::Status GetInterfaceList(const ::std::optional<::std::vector<::std::optional<::android::String16>>>& names, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>* _aidl_return) override; ::android::binder::Status VerifyNamesWithInterfaceList(const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>& services, const ::std::optional<::std::vector<::std::optional<::android::String16>>>& names, bool* _aidl_return) override; ::android::binder::Status ReverseStringList(const ::std::vector<::android::String16>& input, ::std::vector<::android::String16>* repeated, ::std::vector<::android::String16>* _aidl_return) override; ::android::binder::Status RepeatParcelFileDescriptor(const ::android::os::ParcelFileDescriptor& read, ::android::os::ParcelFileDescriptor* _aidl_return) override; ::android::binder::Status ReverseParcelFileDescriptorArray(const ::std::vector<::android::os::ParcelFileDescriptor>& input, ::std::vector<::android::os::ParcelFileDescriptor>* repeated, ::std::vector<::android::os::ParcelFileDescriptor>* _aidl_return) override; ::android::binder::Status ThrowServiceException(int32_t code) override; ::android::binder::Status RepeatNullableIntArray(const ::std::optional<::std::vector>& input, ::std::optional<::std::vector>* _aidl_return) override; ::android::binder::Status RepeatNullableByteEnumArray(const ::std::optional<::std::vector<::android::aidl::tests::ByteEnum>>& input, ::std::optional<::std::vector<::android::aidl::tests::ByteEnum>>* _aidl_return) override; ::android::binder::Status RepeatNullableIntEnumArray(const ::std::optional<::std::vector<::android::aidl::tests::IntEnum>>& input, ::std::optional<::std::vector<::android::aidl::tests::IntEnum>>* _aidl_return) override; ::android::binder::Status RepeatNullableLongEnumArray(const ::std::optional<::std::vector<::android::aidl::tests::LongEnum>>& input, ::std::optional<::std::vector<::android::aidl::tests::LongEnum>>* _aidl_return) override; ::android::binder::Status RepeatNullableString(const ::std::optional<::android::String16>& input, ::std::optional<::android::String16>* _aidl_return) override; ::android::binder::Status RepeatNullableStringList(const ::std::optional<::std::vector<::std::optional<::android::String16>>>& input, ::std::optional<::std::vector<::std::optional<::android::String16>>>* _aidl_return) override; ::android::binder::Status RepeatNullableParcelable(const ::std::optional<::android::aidl::tests::ITestService::Empty>& input, ::std::optional<::android::aidl::tests::ITestService::Empty>* _aidl_return) override; ::android::binder::Status RepeatNullableParcelableArray(const ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>& input, ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>* _aidl_return) override; ::android::binder::Status RepeatNullableParcelableList(const ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>& input, ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>* _aidl_return) override; ::android::binder::Status TakesAnIBinder(const ::android::sp<::android::IBinder>& input) override; ::android::binder::Status TakesANullableIBinder(const ::android::sp<::android::IBinder>& input) override; ::android::binder::Status TakesAnIBinderList(const ::std::vector<::android::sp<::android::IBinder>>& input) override; ::android::binder::Status TakesANullableIBinderList(const ::std::optional<::std::vector<::android::sp<::android::IBinder>>>& input) override; ::android::binder::Status RepeatUtf8CppString(const ::std::string& token, ::std::string* _aidl_return) override; ::android::binder::Status RepeatNullableUtf8CppString(const ::std::optional<::std::string>& token, ::std::optional<::std::string>* _aidl_return) override; ::android::binder::Status ReverseUtf8CppString(const ::std::vector<::std::string>& input, ::std::vector<::std::string>* repeated, ::std::vector<::std::string>* _aidl_return) override; ::android::binder::Status ReverseNullableUtf8CppString(const ::std::optional<::std::vector<::std::optional<::std::string>>>& input, ::std::optional<::std::vector<::std::optional<::std::string>>>* repeated, ::std::optional<::std::vector<::std::optional<::std::string>>>* _aidl_return) override; ::android::binder::Status ReverseUtf8CppStringList(const ::std::optional<::std::vector<::std::optional<::std::string>>>& input, ::std::optional<::std::vector<::std::optional<::std::string>>>* repeated, ::std::optional<::std::vector<::std::optional<::std::string>>>* _aidl_return) override; ::android::binder::Status GetCallback(bool return_null, ::android::sp<::android::aidl::tests::INamedCallback>* _aidl_return) override; ::android::binder::Status FillOutStructuredParcelable(::android::aidl::tests::StructuredParcelable* parcel) override; ::android::binder::Status RepeatExtendableParcelable(const ::android::aidl::tests::extension::ExtendableParcelable& ep, ::android::aidl::tests::extension::ExtendableParcelable* ep2) override; ::android::binder::Status ReverseList(const ::android::aidl::tests::RecursiveList& list, ::android::aidl::tests::RecursiveList* _aidl_return) override; ::android::binder::Status ReverseIBinderArray(const ::std::vector<::android::sp<::android::IBinder>>& input, ::std::vector<::android::sp<::android::IBinder>>* repeated, ::std::vector<::android::sp<::android::IBinder>>* _aidl_return) override; ::android::binder::Status ReverseNullableIBinderArray(const ::std::optional<::std::vector<::android::sp<::android::IBinder>>>& input, ::std::optional<::std::vector<::android::sp<::android::IBinder>>>* repeated, ::std::optional<::std::vector<::android::sp<::android::IBinder>>>* _aidl_return) override; ::android::binder::Status RepeatSimpleParcelable(const ::android::aidl::tests::SimpleParcelable& input, ::android::aidl::tests::SimpleParcelable* repeat, ::android::aidl::tests::SimpleParcelable* _aidl_return) override; ::android::binder::Status ReverseSimpleParcelables(const ::std::vector<::android::aidl::tests::SimpleParcelable>& input, ::std::vector<::android::aidl::tests::SimpleParcelable>* repeated, ::std::vector<::android::aidl::tests::SimpleParcelable>* _aidl_return) override; ::android::binder::Status GetOldNameInterface(::android::sp<::android::aidl::tests::IOldName>* _aidl_return) override; ::android::binder::Status GetNewNameInterface(::android::sp<::android::aidl::tests::INewName>* _aidl_return) override; ::android::binder::Status GetUnionTags(const ::std::vector<::android::aidl::tests::Union>& input, ::std::vector<::android::aidl::tests::Union::Tag>* _aidl_return) override; ::android::binder::Status GetCppJavaTests(::android::sp<::android::IBinder>* _aidl_return) override; ::android::binder::Status getBackendType(::android::aidl::tests::BackendType* _aidl_return) override; ::android::binder::Status GetCircular(::android::aidl::tests::CircularParcelable* cp, ::android::sp<::android::aidl::tests::ICircular>* _aidl_return) override; }; // class BpTestService } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000034 15172120304 033246 xustar000000000 0000000 28 mtime=1776853188.6040000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpUnion.h0100644 0000000 0000000 00000001202 15172120304 032444 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/Union.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/Union.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000216 15172120304 033250 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpUnionWithFd.h 28 mtime=1776853188.6040000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/BpUnionWith0100644 0000000 0000000 00000001216 15172120304 033057 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/UnionWithFd.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/UnionWithFd.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000034 15172120304 033246 xustar000000000 0000000 28 mtime=1776853188.6040000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/ByteEnum.h0100644 0000000 0000000 00000003272 15172120304 032633 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ByteEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { enum class ByteEnum : int8_t { FOO = 1, BAR = 2, BAZ = 3, }; } // namespace tests } // namespace aidl } // namespace android namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(ByteEnum val) { switch(val) { case ByteEnum::FOO: return "FOO"; case ByteEnum::BAR: return "BAR"; case ByteEnum::BAZ: return "BAZ"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::tests::ByteEnum, 3> enum_values<::android::aidl::tests::ByteEnum> = { ::android::aidl::tests::ByteEnum::FOO, ::android::aidl::tests::ByteEnum::BAR, ::android::aidl::tests::ByteEnum::BAZ, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000223 15172120304 033246 xustar000000000 0000000 119 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/CircularParcelable.h 28 mtime=1776853188.6040000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/CircularPar0100644 0000000 0000000 00000004622 15172120304 033064 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/CircularParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl */ #pragma once #include #include #include #include #include #include #include namespace android::aidl::tests { class ITestService; } // namespace android::aidl::tests namespace android { namespace aidl { namespace tests { class CircularParcelable : public ::android::Parcelable { public: ::android::sp<::android::aidl::tests::ITestService> testService; inline bool operator==(const CircularParcelable& _rhs) const { return std::tie(testService) == std::tie(_rhs.testService); } inline bool operator<(const CircularParcelable& _rhs) const { return std::tie(testService) < std::tie(_rhs.testService); } inline bool operator!=(const CircularParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const CircularParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const CircularParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const CircularParcelable& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.CircularParcelable"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "CircularParcelable{"; _aidl_os << "testService: " << ::android::internal::ToString(testService); _aidl_os << "}"; return _aidl_os.str(); } }; // class CircularParcelable } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000227 15172120304 033252 xustar000000000 0000000 123 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/ConstantExpressionEnum.h 28 mtime=1776853188.6040000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/ConstantExp0100644 0000000 0000000 00000004541 15172120304 033123 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ConstantExpressionEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { enum class ConstantExpressionEnum : int32_t { decInt32_1 = 1, decInt32_2 = 1, decInt64_1 = 1, decInt64_2 = 1, decInt64_3 = 1, decInt64_4 = 1, hexInt32_1 = 1, hexInt32_2 = 1, hexInt32_3 = 1, hexInt64_1 = 1, }; } // namespace tests } // namespace aidl } // namespace android namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(ConstantExpressionEnum val) { switch(val) { case ConstantExpressionEnum::decInt32_1: return "decInt32_1"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::tests::ConstantExpressionEnum, 10> enum_values<::android::aidl::tests::ConstantExpressionEnum> = { ::android::aidl::tests::ConstantExpressionEnum::decInt32_1, ::android::aidl::tests::ConstantExpressionEnum::decInt32_2, ::android::aidl::tests::ConstantExpressionEnum::decInt64_1, ::android::aidl::tests::ConstantExpressionEnum::decInt64_2, ::android::aidl::tests::ConstantExpressionEnum::decInt64_3, ::android::aidl::tests::ConstantExpressionEnum::decInt64_4, ::android::aidl::tests::ConstantExpressionEnum::hexInt32_1, ::android::aidl::tests::ConstantExpressionEnum::hexInt32_2, ::android::aidl::tests::ConstantExpressionEnum::hexInt32_3, ::android::aidl::tests::ConstantExpressionEnum::hexInt64_1, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000217 15172120304 033251 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/DeprecatedEnum.h 28 mtime=1776853188.6040000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/DeprecatedE0100644 0000000 0000000 00000003705 15172120304 033023 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/DeprecatedEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedEnum.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { enum class __attribute__((deprecated("test"))) DeprecatedEnum : int32_t { A = 0, B = 1, C = 2, }; } // namespace tests } // namespace aidl } // namespace android namespace android { namespace aidl { namespace tests { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" [[nodiscard]] static inline std::string toString(DeprecatedEnum val) { switch(val) { case DeprecatedEnum::A: return "A"; case DeprecatedEnum::B: return "B"; case DeprecatedEnum::C: return "C"; default: return std::to_string(static_cast(val)); } } #pragma clang diagnostic pop } // namespace tests } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" #pragma clang diagnostic ignored "-Wdeprecated-declarations" template <> constexpr inline std::array<::android::aidl::tests::DeprecatedEnum, 3> enum_values<::android::aidl::tests::DeprecatedEnum> = { ::android::aidl::tests::DeprecatedEnum::A, ::android::aidl::tests::DeprecatedEnum::B, ::android::aidl::tests::DeprecatedEnum::C, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000225 15172120304 033250 xustar000000000 0000000 121 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/DeprecatedParcelable.h 28 mtime=1776853188.6040000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/DeprecatedP0100644 0000000 0000000 00000004141 15172120304 033031 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/DeprecatedParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedParcelable.aidl */ #pragma once #include #include #include #include #include namespace android { namespace aidl { namespace tests { class __attribute__((deprecated("test"))) DeprecatedParcelable : public ::android::Parcelable { public: inline bool operator==(const DeprecatedParcelable&) const { return std::tie() == std::tie(); } inline bool operator<(const DeprecatedParcelable&) const { return std::tie() < std::tie(); } inline bool operator!=(const DeprecatedParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const DeprecatedParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const DeprecatedParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const DeprecatedParcelable& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.DeprecatedParcelable"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "DeprecatedParcelable{"; _aidl_os << "}"; return _aidl_os.str(); } }; // class DeprecatedParcelable } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000212 15172120304 033244 xustar000000000 0000000 110 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/FixedSize.h 28 mtime=1776853188.6050000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/FixedSize.h0100644 0000000 0000000 00000027365 15172120304 033006 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/FixedSize.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/FixedSize.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace android { namespace aidl { namespace tests { class FixedSize : public ::android::Parcelable { public: class FixedUnion : public ::android::Parcelable { public: enum class Tag : int8_t { booleanValue = 0, byteValue = 1, charValue = 2, intValue = 3, longValue = 4, floatValue = 5, doubleValue = 6, enumValue = 7, }; // Expose tag symbols for legacy code static const inline Tag booleanValue = Tag::booleanValue; static const inline Tag byteValue = Tag::byteValue; static const inline Tag charValue = Tag::charValue; static const inline Tag intValue = Tag::intValue; static const inline Tag longValue = Tag::longValue; static const inline Tag floatValue = Tag::floatValue; static const inline Tag doubleValue = Tag::doubleValue; static const inline Tag enumValue = Tag::enumValue; template using _at = typename std::tuple_element(_Tag), std::tuple>::type; template static FixedUnion make(_Type&& _arg) { FixedUnion _inst; _inst.set<_Tag>(std::forward<_Type>(_arg)); return _inst; } constexpr Tag getTag() const { return _tag; } template const _at<_Tag>& get() const { if (_Tag != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return *(_at<_Tag>*)(&_value); } template _at<_Tag>& get() { if (_Tag != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return *(_at<_Tag>*)(&_value); } template void set(_Type&& _arg) { _tag = _Tag; get<_Tag>() = std::forward<_Type>(_arg); } static int _cmp(const FixedUnion& _lhs, const FixedUnion& _rhs) { return _cmp_value(_lhs.getTag(), _rhs.getTag()) || _cmp_value_at(_lhs, _rhs); } template static int _cmp_value_at(const FixedUnion& _lhs, const FixedUnion& _rhs) { if constexpr (_Tag == booleanValue) { return _cmp_value(_lhs.get<_Tag>(), _rhs.get<_Tag>()); } else { return (_lhs.getTag() == _Tag) ? _cmp_value(_lhs.get<_Tag>(), _rhs.get<_Tag>()) : _cmp_value_at(static_cast(_Tag)-1)>(_lhs, _rhs); } } template static int _cmp_value(const _Type& _lhs, const _Type& _rhs) { return (_lhs == _rhs) ? 0 : (_lhs < _rhs) ? -1 : 1; } inline bool operator!=(const FixedUnion&_rhs) const { return _cmp(*this, _rhs) != 0; } inline bool operator<(const FixedUnion&_rhs) const { return _cmp(*this, _rhs) < 0; } inline bool operator<=(const FixedUnion&_rhs) const { return _cmp(*this, _rhs) <= 0; } inline bool operator==(const FixedUnion&_rhs) const { return _cmp(*this, _rhs) == 0; } inline bool operator>(const FixedUnion&_rhs) const { return _cmp(*this, _rhs) > 0; } inline bool operator>=(const FixedUnion&_rhs) const { return _cmp(*this, _rhs) >= 0; } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.FixedSize.FixedUnion"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream os; os << "FixedUnion{"; switch (getTag()) { case booleanValue: os << "booleanValue: " << ::android::internal::ToString(get()); break; case byteValue: os << "byteValue: " << ::android::internal::ToString(get()); break; case charValue: os << "charValue: " << ::android::internal::ToString(get()); break; case intValue: os << "intValue: " << ::android::internal::ToString(get()); break; case longValue: os << "longValue: " << ::android::internal::ToString(get()); break; case floatValue: os << "floatValue: " << ::android::internal::ToString(get()); break; case doubleValue: os << "doubleValue: " << ::android::internal::ToString(get()); break; case enumValue: os << "enumValue: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: Tag _tag = booleanValue; union _value_t { _value_t() {} ~_value_t() {} bool booleanValue __attribute__((aligned (1))) = bool(false); int8_t byteValue __attribute__((aligned (1))); char16_t charValue __attribute__((aligned (2))); int32_t intValue __attribute__((aligned (4))); int64_t longValue __attribute__((aligned (8))); float floatValue __attribute__((aligned (4))); double doubleValue __attribute__((aligned (8))); ::android::aidl::tests::LongEnum enumValue __attribute__((aligned (8))); } _value; }; // class FixedUnion class FixedParcelable : public ::android::Parcelable { public: bool booleanValue = false; int8_t byteValue = 0; char16_t charValue = '\0'; int32_t intValue = 0; int64_t longValue = 0L; float floatValue = 0.000000f; double doubleValue = 0.000000; ::android::aidl::tests::LongEnum enumValue = ::android::aidl::tests::LongEnum::FOO; ::android::aidl::tests::FixedSize::FixedUnion parcelableValue; inline bool operator==(const FixedParcelable& _rhs) const { return std::tie(booleanValue, byteValue, charValue, intValue, longValue, floatValue, doubleValue, enumValue, parcelableValue) == std::tie(_rhs.booleanValue, _rhs.byteValue, _rhs.charValue, _rhs.intValue, _rhs.longValue, _rhs.floatValue, _rhs.doubleValue, _rhs.enumValue, _rhs.parcelableValue); } inline bool operator<(const FixedParcelable& _rhs) const { return std::tie(booleanValue, byteValue, charValue, intValue, longValue, floatValue, doubleValue, enumValue, parcelableValue) < std::tie(_rhs.booleanValue, _rhs.byteValue, _rhs.charValue, _rhs.intValue, _rhs.longValue, _rhs.floatValue, _rhs.doubleValue, _rhs.enumValue, _rhs.parcelableValue); } inline bool operator!=(const FixedParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const FixedParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const FixedParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const FixedParcelable& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.FixedSize.FixedParcelable"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "FixedParcelable{"; _aidl_os << "booleanValue: " << ::android::internal::ToString(booleanValue); _aidl_os << ", byteValue: " << ::android::internal::ToString(byteValue); _aidl_os << ", charValue: " << ::android::internal::ToString(charValue); _aidl_os << ", intValue: " << ::android::internal::ToString(intValue); _aidl_os << ", longValue: " << ::android::internal::ToString(longValue); _aidl_os << ", floatValue: " << ::android::internal::ToString(floatValue); _aidl_os << ", doubleValue: " << ::android::internal::ToString(doubleValue); _aidl_os << ", enumValue: " << ::android::internal::ToString(enumValue); _aidl_os << ", parcelableValue: " << ::android::internal::ToString(parcelableValue); _aidl_os << "}"; return _aidl_os.str(); } }; // class FixedParcelable inline bool operator==(const FixedSize&) const { return std::tie() == std::tie(); } inline bool operator<(const FixedSize&) const { return std::tie() < std::tie(); } inline bool operator!=(const FixedSize& _rhs) const { return !(*this == _rhs); } inline bool operator>(const FixedSize& _rhs) const { return _rhs < *this; } inline bool operator>=(const FixedSize& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const FixedSize& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.FixedSize"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "FixedSize{"; _aidl_os << "}"; return _aidl_os.str(); } }; // class FixedSize } // namespace tests } // namespace aidl } // namespace android namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(FixedSize::FixedUnion::Tag val) { switch(val) { case FixedSize::FixedUnion::Tag::booleanValue: return "booleanValue"; case FixedSize::FixedUnion::Tag::byteValue: return "byteValue"; case FixedSize::FixedUnion::Tag::charValue: return "charValue"; case FixedSize::FixedUnion::Tag::intValue: return "intValue"; case FixedSize::FixedUnion::Tag::longValue: return "longValue"; case FixedSize::FixedUnion::Tag::floatValue: return "floatValue"; case FixedSize::FixedUnion::Tag::doubleValue: return "doubleValue"; case FixedSize::FixedUnion::Tag::enumValue: return "enumValue"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::tests::FixedSize::FixedUnion::Tag, 8> enum_values<::android::aidl::tests::FixedSize::FixedUnion::Tag> = { ::android::aidl::tests::FixedSize::FixedUnion::Tag::booleanValue, ::android::aidl::tests::FixedSize::FixedUnion::Tag::byteValue, ::android::aidl::tests::FixedSize::FixedUnion::Tag::charValue, ::android::aidl::tests::FixedSize::FixedUnion::Tag::intValue, ::android::aidl::tests::FixedSize::FixedUnion::Tag::longValue, ::android::aidl::tests::FixedSize::FixedUnion::Tag::floatValue, ::android::aidl::tests::FixedSize::FixedUnion::Tag::doubleValue, ::android::aidl::tests::FixedSize::FixedUnion::Tag::enumValue, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000234 15172120304 033250 xustar000000000 0000000 128 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/GenericStructuredParcelable.h 28 mtime=1776853188.6050000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/GenericStru0100644 0000000 0000000 00000011471 15172120304 033107 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/GenericStructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl */ #pragma once #include #include #include #include #include #include namespace android { namespace aidl { namespace tests { template class GenericStructuredParcelable : public ::android::Parcelable { public: int32_t a = 0; int32_t b = 0; inline bool operator==(const GenericStructuredParcelable& _rhs) const { return std::tie(a, b) == std::tie(_rhs.a, _rhs.b); } inline bool operator<(const GenericStructuredParcelable& _rhs) const { return std::tie(a, b) < std::tie(_rhs.a, _rhs.b); } inline bool operator!=(const GenericStructuredParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const GenericStructuredParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const GenericStructuredParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const GenericStructuredParcelable& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.GenericStructuredParcelable"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "GenericStructuredParcelable{"; _aidl_os << "a: " << ::android::internal::ToString(a); _aidl_os << ", b: " << ::android::internal::ToString(b); _aidl_os << "}"; return _aidl_os.str(); } }; // class GenericStructuredParcelable } // namespace tests } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace tests { template ::android::status_t GenericStructuredParcelable::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&a); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&b); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } template ::android::status_t GenericStructuredParcelable::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeInt32(a); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(b); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000212 15172120304 033244 xustar000000000 0000000 110 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/ICircular.h 28 mtime=1776853188.6050000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/ICircular.h0100644 0000000 0000000 00000003251 15172120304 032755 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ICircular.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ICircular.aidl */ #pragma once #include #include #include #include #include #include #include namespace android::aidl::tests { class ITestService; } // namespace android::aidl::tests namespace android { namespace aidl { namespace tests { class ICircularDelegator; class ICircular : public ::android::IInterface { public: typedef ICircularDelegator DefaultDelegator; DECLARE_META_INTERFACE(Circular) virtual ::android::binder::Status GetTestService(::android::sp<::android::aidl::tests::ITestService>* _aidl_return) = 0; }; // class ICircular class ICircularDefault : public ICircular { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status GetTestService(::android::sp<::android::aidl::tests::ITestService>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } }; // class ICircularDefault } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000214 15172120304 033246 xustar000000000 0000000 112 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/IDeprecated.h 28 mtime=1776853188.6050000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/IDeprecated0100644 0000000 0000000 00000002433 15172120304 033024 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/IDeprecated.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IDeprecated.aidl */ #pragma once #include #include #include #include #include namespace android { namespace aidl { namespace tests { class IDeprecatedDelegator; class __attribute__((deprecated("test"))) IDeprecated : public ::android::IInterface { public: typedef IDeprecatedDelegator DefaultDelegator; DECLARE_META_INTERFACE(Deprecated) }; // class IDeprecated class __attribute__((deprecated("test"))) IDeprecatedDefault : public IDeprecated { public: ::android::IBinder* onAsBinder() override { return nullptr; } }; // class IDeprecatedDefault } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000217 15172120304 033251 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/INamedCallback.h 28 mtime=1776853188.6050000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/INamedCallb0100644 0000000 0000000 00000003016 15172120304 032744 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/INamedCallback.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl */ #pragma once #include #include #include #include #include #include namespace android { namespace aidl { namespace tests { class INamedCallbackDelegator; class INamedCallback : public ::android::IInterface { public: typedef INamedCallbackDelegator DefaultDelegator; DECLARE_META_INTERFACE(NamedCallback) virtual ::android::binder::Status GetName(::android::String16* _aidl_return) = 0; }; // class INamedCallback class INamedCallbackDefault : public INamedCallback { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status GetName(::android::String16* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } }; // class INamedCallbackDefault } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000034 15172120304 033246 xustar000000000 0000000 28 mtime=1776853188.6050000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/INewName.h0100644 0000000 0000000 00000002724 15172120304 032547 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/INewName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INewName.aidl */ #pragma once #include #include #include #include #include #include namespace android { namespace aidl { namespace tests { class INewNameDelegator; class INewName : public ::android::IInterface { public: typedef INewNameDelegator DefaultDelegator; DECLARE_META_INTERFACE(NewName) virtual ::android::binder::Status RealName(::android::String16* _aidl_return) = 0; }; // class INewName class INewNameDefault : public INewName { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status RealName(::android::String16* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } }; // class INewNameDefault } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000034 15172120304 033246 xustar000000000 0000000 28 mtime=1776853188.6050000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/IOldName.h0100644 0000000 0000000 00000002724 15172120304 032534 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/IOldName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IOldName.aidl */ #pragma once #include #include #include #include #include #include namespace android { namespace aidl { namespace tests { class IOldNameDelegator; class IOldName : public ::android::IInterface { public: typedef IOldNameDelegator DefaultDelegator; DECLARE_META_INTERFACE(OldName) virtual ::android::binder::Status RealName(::android::String16* _aidl_return) = 0; }; // class IOldName class IOldNameDefault : public IOldName { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status RealName(::android::String16* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } }; // class IOldNameDefault } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000215 15172120304 033247 xustar000000000 0000000 113 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/ITestService.h 28 mtime=1776853188.6050000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/ITestServic0100644 0000000 0000000 00000156770 15172120304 033075 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ITestService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ITestService.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace android::aidl::tests { class CircularParcelable; class ICircular; class INamedCallback; class INewName; class IOldName; class RecursiveList; class StructuredParcelable; } // namespace android::aidl::tests namespace android::aidl::tests::extension { class ExtendableParcelable; } // namespace android::aidl::tests::extension namespace android { namespace aidl { namespace tests { class ITestServiceDelegator; class ITestService : public ::android::IInterface { public: typedef ITestServiceDelegator DefaultDelegator; DECLARE_META_INTERFACE(TestService) class Empty : public ::android::Parcelable { public: inline bool operator==(const Empty&) const { return std::tie() == std::tie(); } inline bool operator<(const Empty&) const { return std::tie() < std::tie(); } inline bool operator!=(const Empty& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Empty& _rhs) const { return _rhs < *this; } inline bool operator>=(const Empty& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Empty& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.ITestService.Empty"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "Empty{"; _aidl_os << "}"; return _aidl_os.str(); } }; // class Empty class CompilerChecks : public ::android::Parcelable { public: class IFooDelegator; class IFoo : public ::android::IInterface { public: typedef IFooDelegator DefaultDelegator; DECLARE_META_INTERFACE(Foo) }; // class IFoo class IFooDefault : public IFoo { public: ::android::IBinder* onAsBinder() override { return nullptr; } }; // class IFooDefault class BpFoo : public ::android::BpInterface { public: explicit BpFoo(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpFoo() = default; }; // class BpFoo class BnFoo : public ::android::BnInterface { public: explicit BnFoo(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnFoo class IFooDelegator : public BnFoo { public: explicit IFooDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } private: ::android::sp _aidl_delegate; }; // class IFooDelegator #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" class HasDeprecated : public ::android::Parcelable { public: int32_t __attribute__((deprecated("field"))) deprecated = 0; inline bool operator==(const HasDeprecated& _rhs) const { return std::tie(deprecated) == std::tie(_rhs.deprecated); } inline bool operator<(const HasDeprecated& _rhs) const { return std::tie(deprecated) < std::tie(_rhs.deprecated); } inline bool operator!=(const HasDeprecated& _rhs) const { return !(*this == _rhs); } inline bool operator>(const HasDeprecated& _rhs) const { return _rhs < *this; } inline bool operator>=(const HasDeprecated& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const HasDeprecated& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.ITestService.CompilerChecks.HasDeprecated"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "HasDeprecated{"; _aidl_os << "deprecated: " << ::android::internal::ToString(deprecated); _aidl_os << "}"; return _aidl_os.str(); } }; // class HasDeprecated #pragma clang diagnostic pop class UsingHasDeprecated : public ::android::Parcelable { public: enum class Tag : int32_t { n = 0, m = 1, }; // Expose tag symbols for legacy code static const inline Tag n = Tag::n; static const inline Tag m = Tag::m; template static constexpr bool _not_self = !std::is_same_v>, UsingHasDeprecated>; UsingHasDeprecated() : _value(std::in_place_index(n)>, int32_t(0)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr UsingHasDeprecated(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit UsingHasDeprecated(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static UsingHasDeprecated make(_Tp&&... _args) { return UsingHasDeprecated(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static UsingHasDeprecated make(std::initializer_list<_Tp> _il, _Up&&... _args) { return UsingHasDeprecated(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } inline bool operator==(const UsingHasDeprecated& _rhs) const { return _value == _rhs._value; } inline bool operator<(const UsingHasDeprecated& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const UsingHasDeprecated& _rhs) const { return !(*this == _rhs); } inline bool operator>(const UsingHasDeprecated& _rhs) const { return _rhs < *this; } inline bool operator>=(const UsingHasDeprecated& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const UsingHasDeprecated& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.ITestService.CompilerChecks.UsingHasDeprecated"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream os; os << "UsingHasDeprecated{"; switch (getTag()) { case n: os << "n: " << ::android::internal::ToString(get()); break; case m: os << "m: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant _value; }; // class UsingHasDeprecated class INoPrefixInterfaceDelegator; class INoPrefixInterface : public ::android::IInterface { public: typedef INoPrefixInterfaceDelegator DefaultDelegator; DECLARE_META_INTERFACE(NoPrefixInterface) class Nested : public ::android::Parcelable { public: inline bool operator==(const Nested&) const { return std::tie() == std::tie(); } inline bool operator<(const Nested&) const { return std::tie() < std::tie(); } inline bool operator!=(const Nested& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Nested& _rhs) const { return _rhs < *this; } inline bool operator>=(const Nested& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Nested& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.Nested"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "Nested{"; _aidl_os << "}"; return _aidl_os.str(); } }; // class Nested class INestedNoPrefixInterfaceDelegator; class INestedNoPrefixInterface : public ::android::IInterface { public: typedef INestedNoPrefixInterfaceDelegator DefaultDelegator; DECLARE_META_INTERFACE(NestedNoPrefixInterface) virtual ::android::binder::Status foo() = 0; }; // class INestedNoPrefixInterface class INestedNoPrefixInterfaceDefault : public INestedNoPrefixInterface { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status foo() override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } }; // class INestedNoPrefixInterfaceDefault class BpNestedNoPrefixInterface : public ::android::BpInterface { public: explicit BpNestedNoPrefixInterface(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpNestedNoPrefixInterface() = default; ::android::binder::Status foo() override; }; // class BpNestedNoPrefixInterface class BnNestedNoPrefixInterface : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_foo = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; explicit BnNestedNoPrefixInterface(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnNestedNoPrefixInterface class INestedNoPrefixInterfaceDelegator : public BnNestedNoPrefixInterface { public: explicit INestedNoPrefixInterfaceDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status foo() override { return _aidl_delegate->foo(); } private: ::android::sp _aidl_delegate; }; // class INestedNoPrefixInterfaceDelegator virtual ::android::binder::Status foo() = 0; }; // class INoPrefixInterface class INoPrefixInterfaceDefault : public INoPrefixInterface { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status foo() override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } }; // class INoPrefixInterfaceDefault class BpNoPrefixInterface : public ::android::BpInterface { public: explicit BpNoPrefixInterface(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpNoPrefixInterface() = default; ::android::binder::Status foo() override; }; // class BpNoPrefixInterface class BnNoPrefixInterface : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_foo = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; explicit BnNoPrefixInterface(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnNoPrefixInterface class INoPrefixInterfaceDelegator : public BnNoPrefixInterface { public: explicit INoPrefixInterfaceDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status foo() override { return _aidl_delegate->foo(); } private: ::android::sp _aidl_delegate; }; // class INoPrefixInterfaceDelegator ::android::sp<::android::IBinder> binder; ::android::sp<::android::IBinder> nullable_binder; ::std::vector<::android::sp<::android::IBinder>> binder_array; ::std::optional<::std::vector<::android::sp<::android::IBinder>>> nullable_binder_array; ::std::vector<::android::sp<::android::IBinder>> binder_list; ::std::optional<::std::vector<::android::sp<::android::IBinder>>> nullable_binder_list; ::android::os::ParcelFileDescriptor pfd; ::std::optional<::android::os::ParcelFileDescriptor> nullable_pfd; ::std::vector<::android::os::ParcelFileDescriptor> pfd_array; ::std::optional<::std::vector<::std::optional<::android::os::ParcelFileDescriptor>>> nullable_pfd_array; ::std::vector<::android::os::ParcelFileDescriptor> pfd_list; ::std::optional<::std::vector<::std::optional<::android::os::ParcelFileDescriptor>>> nullable_pfd_list; ::android::aidl::tests::ITestService::Empty parcel; ::std::optional<::android::aidl::tests::ITestService::Empty> nullable_parcel; ::std::vector<::android::aidl::tests::ITestService::Empty> parcel_array; ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>> nullable_parcel_array; ::std::vector<::android::aidl::tests::ITestService::Empty> parcel_list; ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>> nullable_parcel_list; inline bool operator==(const CompilerChecks& _rhs) const { return std::tie(binder, nullable_binder, binder_array, nullable_binder_array, binder_list, nullable_binder_list, pfd, nullable_pfd, pfd_array, nullable_pfd_array, pfd_list, nullable_pfd_list, parcel, nullable_parcel, parcel_array, nullable_parcel_array, parcel_list, nullable_parcel_list) == std::tie(_rhs.binder, _rhs.nullable_binder, _rhs.binder_array, _rhs.nullable_binder_array, _rhs.binder_list, _rhs.nullable_binder_list, _rhs.pfd, _rhs.nullable_pfd, _rhs.pfd_array, _rhs.nullable_pfd_array, _rhs.pfd_list, _rhs.nullable_pfd_list, _rhs.parcel, _rhs.nullable_parcel, _rhs.parcel_array, _rhs.nullable_parcel_array, _rhs.parcel_list, _rhs.nullable_parcel_list); } inline bool operator<(const CompilerChecks& _rhs) const { return std::tie(binder, nullable_binder, binder_array, nullable_binder_array, binder_list, nullable_binder_list, pfd, nullable_pfd, pfd_array, nullable_pfd_array, pfd_list, nullable_pfd_list, parcel, nullable_parcel, parcel_array, nullable_parcel_array, parcel_list, nullable_parcel_list) < std::tie(_rhs.binder, _rhs.nullable_binder, _rhs.binder_array, _rhs.nullable_binder_array, _rhs.binder_list, _rhs.nullable_binder_list, _rhs.pfd, _rhs.nullable_pfd, _rhs.pfd_array, _rhs.nullable_pfd_array, _rhs.pfd_list, _rhs.nullable_pfd_list, _rhs.parcel, _rhs.nullable_parcel, _rhs.parcel_array, _rhs.nullable_parcel_array, _rhs.parcel_list, _rhs.nullable_parcel_list); } inline bool operator!=(const CompilerChecks& _rhs) const { return !(*this == _rhs); } inline bool operator>(const CompilerChecks& _rhs) const { return _rhs < *this; } inline bool operator>=(const CompilerChecks& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const CompilerChecks& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.ITestService.CompilerChecks"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "CompilerChecks{"; _aidl_os << "binder: " << ::android::internal::ToString(binder); _aidl_os << ", nullable_binder: " << ::android::internal::ToString(nullable_binder); _aidl_os << ", binder_array: " << ::android::internal::ToString(binder_array); _aidl_os << ", nullable_binder_array: " << ::android::internal::ToString(nullable_binder_array); _aidl_os << ", binder_list: " << ::android::internal::ToString(binder_list); _aidl_os << ", nullable_binder_list: " << ::android::internal::ToString(nullable_binder_list); _aidl_os << ", pfd: " << ::android::internal::ToString(pfd); _aidl_os << ", nullable_pfd: " << ::android::internal::ToString(nullable_pfd); _aidl_os << ", pfd_array: " << ::android::internal::ToString(pfd_array); _aidl_os << ", nullable_pfd_array: " << ::android::internal::ToString(nullable_pfd_array); _aidl_os << ", pfd_list: " << ::android::internal::ToString(pfd_list); _aidl_os << ", nullable_pfd_list: " << ::android::internal::ToString(nullable_pfd_list); _aidl_os << ", parcel: " << ::android::internal::ToString(parcel); _aidl_os << ", nullable_parcel: " << ::android::internal::ToString(nullable_parcel); _aidl_os << ", parcel_array: " << ::android::internal::ToString(parcel_array); _aidl_os << ", nullable_parcel_array: " << ::android::internal::ToString(nullable_parcel_array); _aidl_os << ", parcel_list: " << ::android::internal::ToString(parcel_list); _aidl_os << ", nullable_parcel_list: " << ::android::internal::ToString(nullable_parcel_list); _aidl_os << "}"; return _aidl_os.str(); } }; // class CompilerChecks enum : int32_t { CONSTANT = 42 }; enum : int32_t { CONSTANT2 = -42 }; enum : int32_t { CONSTANT3 = 42 }; enum : int32_t { CONSTANT4 = 4 }; enum : int32_t { CONSTANT5 = -4 }; enum : int32_t { CONSTANT6 = 0 }; enum : int32_t { CONSTANT7 = 0 }; enum : int32_t { CONSTANT8 = 0 }; enum : int32_t { CONSTANT9 = 86 }; enum : int32_t { CONSTANT10 = 165 }; enum : int32_t { CONSTANT11 = 250 }; enum : int32_t { CONSTANT12 = -1 }; enum : int8_t { BYTE_CONSTANT = 17 }; enum : int64_t { LONG_CONSTANT = 1099511627776L }; static const ::android::String16& STRING_CONSTANT(); static const ::android::String16& STRING_CONSTANT2(); static constexpr float FLOAT_CONSTANT = 1.000000f; static constexpr float FLOAT_CONSTANT2 = -1.000000f; static constexpr float FLOAT_CONSTANT3 = 1.000000f; static constexpr float FLOAT_CONSTANT4 = 2.200000f; static constexpr float FLOAT_CONSTANT5 = -2.200000f; static constexpr float FLOAT_CONSTANT6 = -0.000000f; static constexpr float FLOAT_CONSTANT7 = 0.000000f; static constexpr double DOUBLE_CONSTANT = 1.000000; static constexpr double DOUBLE_CONSTANT2 = -1.000000; static constexpr double DOUBLE_CONSTANT3 = 1.000000; static constexpr double DOUBLE_CONSTANT4 = 2.200000; static constexpr double DOUBLE_CONSTANT5 = -2.200000; static constexpr double DOUBLE_CONSTANT6 = -0.000000; static constexpr double DOUBLE_CONSTANT7 = 0.000000; static constexpr double DOUBLE_CONSTANT8 = 1.100000; static constexpr double DOUBLE_CONSTANT9 = -1.100000; static const ::std::string& STRING_CONSTANT_UTF8(); enum : int32_t { A1 = 1 }; enum : int32_t { A2 = 1 }; enum : int32_t { A3 = 1 }; enum : int32_t { A4 = 1 }; enum : int32_t { A5 = 1 }; enum : int32_t { A6 = 1 }; enum : int32_t { A7 = 1 }; enum : int32_t { A8 = 1 }; enum : int32_t { A9 = 1 }; enum : int32_t { A10 = 1 }; enum : int32_t { A11 = 1 }; enum : int32_t { A12 = 1 }; enum : int32_t { A13 = 1 }; enum : int32_t { A14 = 1 }; enum : int32_t { A15 = 1 }; enum : int32_t { A16 = 1 }; enum : int32_t { A17 = 1 }; enum : int32_t { A18 = 1 }; enum : int32_t { A19 = 1 }; enum : int32_t { A20 = 1 }; enum : int32_t { A21 = 1 }; enum : int32_t { A22 = 1 }; enum : int32_t { A23 = 1 }; enum : int32_t { A24 = 1 }; enum : int32_t { A25 = 1 }; enum : int32_t { A26 = 1 }; enum : int32_t { A27 = 1 }; enum : int32_t { A28 = 1 }; enum : int32_t { A29 = 1 }; enum : int32_t { A30 = 1 }; enum : int32_t { A31 = 1 }; enum : int32_t { A32 = 1 }; enum : int32_t { A33 = 1 }; enum : int32_t { A34 = 1 }; enum : int32_t { A35 = 1 }; enum : int32_t { A36 = 1 }; enum : int32_t { A37 = 1 }; enum : int32_t { A38 = 1 }; enum : int32_t { A39 = 1 }; enum : int32_t { A40 = 1 }; enum : int32_t { A41 = 1 }; enum : int32_t { A42 = 1 }; enum : int32_t { A43 = 1 }; enum : int32_t { A44 = 1 }; enum : int32_t { A45 = 1 }; enum : int32_t { A46 = 1 }; enum : int32_t { A47 = 1 }; enum : int32_t { A48 = 1 }; enum : int32_t { A49 = 1 }; enum : int32_t { A50 = 1 }; enum : int32_t { A51 = 1 }; enum : int32_t { A52 = 1 }; enum : int32_t { A53 = 1 }; enum : int32_t { A54 = 1 }; enum : int32_t { A55 = 1 }; enum : int32_t { A56 = 1 }; enum : int32_t { A57 = 1 }; virtual ::android::binder::Status UnimplementedMethod(int32_t arg, int32_t* _aidl_return) = 0; virtual ::android::binder::Status Deprecated() __attribute__((deprecated("to make sure we have something in system/tools/aidl which does a compile check of deprecated and make sure this is reflected in goldens"))) = 0; virtual ::android::binder::Status TestOneway() = 0; virtual ::android::binder::Status RepeatBoolean(bool token, bool* _aidl_return) = 0; virtual ::android::binder::Status RepeatByte(int8_t token, int8_t* _aidl_return) = 0; virtual ::android::binder::Status RepeatChar(char16_t token, char16_t* _aidl_return) = 0; virtual ::android::binder::Status RepeatInt(int32_t token, int32_t* _aidl_return) = 0; virtual ::android::binder::Status RepeatLong(int64_t token, int64_t* _aidl_return) = 0; virtual ::android::binder::Status RepeatFloat(float token, float* _aidl_return) = 0; virtual ::android::binder::Status RepeatDouble(double token, double* _aidl_return) = 0; virtual ::android::binder::Status RepeatString(const ::android::String16& token, ::android::String16* _aidl_return) = 0; virtual ::android::binder::Status RepeatByteEnum(::android::aidl::tests::ByteEnum token, ::android::aidl::tests::ByteEnum* _aidl_return) = 0; virtual ::android::binder::Status RepeatIntEnum(::android::aidl::tests::IntEnum token, ::android::aidl::tests::IntEnum* _aidl_return) = 0; virtual ::android::binder::Status RepeatLongEnum(::android::aidl::tests::LongEnum token, ::android::aidl::tests::LongEnum* _aidl_return) = 0; virtual ::android::binder::Status ReverseBoolean(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) = 0; virtual ::android::binder::Status ReverseByte(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) = 0; virtual ::android::binder::Status ReverseChar(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) = 0; virtual ::android::binder::Status ReverseInt(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) = 0; virtual ::android::binder::Status ReverseLong(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) = 0; virtual ::android::binder::Status ReverseFloat(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) = 0; virtual ::android::binder::Status ReverseDouble(const ::std::vector& input, ::std::vector* repeated, ::std::vector* _aidl_return) = 0; virtual ::android::binder::Status ReverseString(const ::std::vector<::android::String16>& input, ::std::vector<::android::String16>* repeated, ::std::vector<::android::String16>* _aidl_return) = 0; virtual ::android::binder::Status ReverseByteEnum(const ::std::vector<::android::aidl::tests::ByteEnum>& input, ::std::vector<::android::aidl::tests::ByteEnum>* repeated, ::std::vector<::android::aidl::tests::ByteEnum>* _aidl_return) = 0; virtual ::android::binder::Status ReverseIntEnum(const ::std::vector<::android::aidl::tests::IntEnum>& input, ::std::vector<::android::aidl::tests::IntEnum>* repeated, ::std::vector<::android::aidl::tests::IntEnum>* _aidl_return) = 0; virtual ::android::binder::Status ReverseLongEnum(const ::std::vector<::android::aidl::tests::LongEnum>& input, ::std::vector<::android::aidl::tests::LongEnum>* repeated, ::std::vector<::android::aidl::tests::LongEnum>* _aidl_return) = 0; virtual ::android::binder::Status GetOtherTestService(const ::android::String16& name, ::android::sp<::android::aidl::tests::INamedCallback>* _aidl_return) = 0; virtual ::android::binder::Status SetOtherTestService(const ::android::String16& name, const ::android::sp<::android::aidl::tests::INamedCallback>& service, bool* _aidl_return) = 0; virtual ::android::binder::Status VerifyName(const ::android::sp<::android::aidl::tests::INamedCallback>& service, const ::android::String16& name, bool* _aidl_return) = 0; virtual ::android::binder::Status GetInterfaceArray(const ::std::vector<::android::String16>& names, ::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>* _aidl_return) = 0; virtual ::android::binder::Status VerifyNamesWithInterfaceArray(const ::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>& services, const ::std::vector<::android::String16>& names, bool* _aidl_return) = 0; virtual ::android::binder::Status GetNullableInterfaceArray(const ::std::optional<::std::vector<::std::optional<::android::String16>>>& names, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>* _aidl_return) = 0; virtual ::android::binder::Status VerifyNamesWithNullableInterfaceArray(const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>& services, const ::std::optional<::std::vector<::std::optional<::android::String16>>>& names, bool* _aidl_return) = 0; virtual ::android::binder::Status GetInterfaceList(const ::std::optional<::std::vector<::std::optional<::android::String16>>>& names, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>* _aidl_return) = 0; virtual ::android::binder::Status VerifyNamesWithInterfaceList(const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>& services, const ::std::optional<::std::vector<::std::optional<::android::String16>>>& names, bool* _aidl_return) = 0; virtual ::android::binder::Status ReverseStringList(const ::std::vector<::android::String16>& input, ::std::vector<::android::String16>* repeated, ::std::vector<::android::String16>* _aidl_return) = 0; virtual ::android::binder::Status RepeatParcelFileDescriptor(const ::android::os::ParcelFileDescriptor& read, ::android::os::ParcelFileDescriptor* _aidl_return) = 0; virtual ::android::binder::Status ReverseParcelFileDescriptorArray(const ::std::vector<::android::os::ParcelFileDescriptor>& input, ::std::vector<::android::os::ParcelFileDescriptor>* repeated, ::std::vector<::android::os::ParcelFileDescriptor>* _aidl_return) = 0; virtual ::android::binder::Status ThrowServiceException(int32_t code) = 0; virtual ::android::binder::Status RepeatNullableIntArray(const ::std::optional<::std::vector>& input, ::std::optional<::std::vector>* _aidl_return) = 0; virtual ::android::binder::Status RepeatNullableByteEnumArray(const ::std::optional<::std::vector<::android::aidl::tests::ByteEnum>>& input, ::std::optional<::std::vector<::android::aidl::tests::ByteEnum>>* _aidl_return) = 0; virtual ::android::binder::Status RepeatNullableIntEnumArray(const ::std::optional<::std::vector<::android::aidl::tests::IntEnum>>& input, ::std::optional<::std::vector<::android::aidl::tests::IntEnum>>* _aidl_return) = 0; virtual ::android::binder::Status RepeatNullableLongEnumArray(const ::std::optional<::std::vector<::android::aidl::tests::LongEnum>>& input, ::std::optional<::std::vector<::android::aidl::tests::LongEnum>>* _aidl_return) = 0; virtual ::android::binder::Status RepeatNullableString(const ::std::optional<::android::String16>& input, ::std::optional<::android::String16>* _aidl_return) = 0; virtual ::android::binder::Status RepeatNullableStringList(const ::std::optional<::std::vector<::std::optional<::android::String16>>>& input, ::std::optional<::std::vector<::std::optional<::android::String16>>>* _aidl_return) = 0; virtual ::android::binder::Status RepeatNullableParcelable(const ::std::optional<::android::aidl::tests::ITestService::Empty>& input, ::std::optional<::android::aidl::tests::ITestService::Empty>* _aidl_return) = 0; virtual ::android::binder::Status RepeatNullableParcelableArray(const ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>& input, ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>* _aidl_return) = 0; virtual ::android::binder::Status RepeatNullableParcelableList(const ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>& input, ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>* _aidl_return) = 0; virtual ::android::binder::Status TakesAnIBinder(const ::android::sp<::android::IBinder>& input) = 0; virtual ::android::binder::Status TakesANullableIBinder(const ::android::sp<::android::IBinder>& input) = 0; virtual ::android::binder::Status TakesAnIBinderList(const ::std::vector<::android::sp<::android::IBinder>>& input) = 0; virtual ::android::binder::Status TakesANullableIBinderList(const ::std::optional<::std::vector<::android::sp<::android::IBinder>>>& input) = 0; virtual ::android::binder::Status RepeatUtf8CppString(const ::std::string& token, ::std::string* _aidl_return) = 0; virtual ::android::binder::Status RepeatNullableUtf8CppString(const ::std::optional<::std::string>& token, ::std::optional<::std::string>* _aidl_return) = 0; virtual ::android::binder::Status ReverseUtf8CppString(const ::std::vector<::std::string>& input, ::std::vector<::std::string>* repeated, ::std::vector<::std::string>* _aidl_return) = 0; virtual ::android::binder::Status ReverseNullableUtf8CppString(const ::std::optional<::std::vector<::std::optional<::std::string>>>& input, ::std::optional<::std::vector<::std::optional<::std::string>>>* repeated, ::std::optional<::std::vector<::std::optional<::std::string>>>* _aidl_return) = 0; virtual ::android::binder::Status ReverseUtf8CppStringList(const ::std::optional<::std::vector<::std::optional<::std::string>>>& input, ::std::optional<::std::vector<::std::optional<::std::string>>>* repeated, ::std::optional<::std::vector<::std::optional<::std::string>>>* _aidl_return) = 0; virtual ::android::binder::Status GetCallback(bool return_null, ::android::sp<::android::aidl::tests::INamedCallback>* _aidl_return) = 0; virtual ::android::binder::Status FillOutStructuredParcelable(::android::aidl::tests::StructuredParcelable* parcel) = 0; virtual ::android::binder::Status RepeatExtendableParcelable(const ::android::aidl::tests::extension::ExtendableParcelable& ep, ::android::aidl::tests::extension::ExtendableParcelable* ep2) = 0; virtual ::android::binder::Status ReverseList(const ::android::aidl::tests::RecursiveList& list, ::android::aidl::tests::RecursiveList* _aidl_return) = 0; virtual ::android::binder::Status ReverseIBinderArray(const ::std::vector<::android::sp<::android::IBinder>>& input, ::std::vector<::android::sp<::android::IBinder>>* repeated, ::std::vector<::android::sp<::android::IBinder>>* _aidl_return) = 0; virtual ::android::binder::Status ReverseNullableIBinderArray(const ::std::optional<::std::vector<::android::sp<::android::IBinder>>>& input, ::std::optional<::std::vector<::android::sp<::android::IBinder>>>* repeated, ::std::optional<::std::vector<::android::sp<::android::IBinder>>>* _aidl_return) = 0; virtual ::android::binder::Status RepeatSimpleParcelable(const ::android::aidl::tests::SimpleParcelable& input, ::android::aidl::tests::SimpleParcelable* repeat, ::android::aidl::tests::SimpleParcelable* _aidl_return) = 0; virtual ::android::binder::Status ReverseSimpleParcelables(const ::std::vector<::android::aidl::tests::SimpleParcelable>& input, ::std::vector<::android::aidl::tests::SimpleParcelable>* repeated, ::std::vector<::android::aidl::tests::SimpleParcelable>* _aidl_return) = 0; virtual ::android::binder::Status GetOldNameInterface(::android::sp<::android::aidl::tests::IOldName>* _aidl_return) = 0; virtual ::android::binder::Status GetNewNameInterface(::android::sp<::android::aidl::tests::INewName>* _aidl_return) = 0; virtual ::android::binder::Status GetUnionTags(const ::std::vector<::android::aidl::tests::Union>& input, ::std::vector<::android::aidl::tests::Union::Tag>* _aidl_return) = 0; virtual ::android::binder::Status GetCppJavaTests(::android::sp<::android::IBinder>* _aidl_return) = 0; virtual ::android::binder::Status getBackendType(::android::aidl::tests::BackendType* _aidl_return) = 0; virtual ::android::binder::Status GetCircular(::android::aidl::tests::CircularParcelable* cp, ::android::sp<::android::aidl::tests::ICircular>* _aidl_return) = 0; }; // class ITestService class ITestServiceDefault : public ITestService { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status UnimplementedMethod(int32_t /*arg*/, int32_t* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status Deprecated() override __attribute__((deprecated("to make sure we have something in system/tools/aidl which does a compile check of deprecated and make sure this is reflected in goldens"))) { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status TestOneway() override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatBoolean(bool /*token*/, bool* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatByte(int8_t /*token*/, int8_t* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatChar(char16_t /*token*/, char16_t* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatInt(int32_t /*token*/, int32_t* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatLong(int64_t /*token*/, int64_t* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatFloat(float /*token*/, float* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatDouble(double /*token*/, double* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatString(const ::android::String16& /*token*/, ::android::String16* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatByteEnum(::android::aidl::tests::ByteEnum /*token*/, ::android::aidl::tests::ByteEnum* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatIntEnum(::android::aidl::tests::IntEnum /*token*/, ::android::aidl::tests::IntEnum* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatLongEnum(::android::aidl::tests::LongEnum /*token*/, ::android::aidl::tests::LongEnum* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseBoolean(const ::std::vector& /*input*/, ::std::vector* /*repeated*/, ::std::vector* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseByte(const ::std::vector& /*input*/, ::std::vector* /*repeated*/, ::std::vector* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseChar(const ::std::vector& /*input*/, ::std::vector* /*repeated*/, ::std::vector* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseInt(const ::std::vector& /*input*/, ::std::vector* /*repeated*/, ::std::vector* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseLong(const ::std::vector& /*input*/, ::std::vector* /*repeated*/, ::std::vector* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseFloat(const ::std::vector& /*input*/, ::std::vector* /*repeated*/, ::std::vector* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseDouble(const ::std::vector& /*input*/, ::std::vector* /*repeated*/, ::std::vector* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseString(const ::std::vector<::android::String16>& /*input*/, ::std::vector<::android::String16>* /*repeated*/, ::std::vector<::android::String16>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseByteEnum(const ::std::vector<::android::aidl::tests::ByteEnum>& /*input*/, ::std::vector<::android::aidl::tests::ByteEnum>* /*repeated*/, ::std::vector<::android::aidl::tests::ByteEnum>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseIntEnum(const ::std::vector<::android::aidl::tests::IntEnum>& /*input*/, ::std::vector<::android::aidl::tests::IntEnum>* /*repeated*/, ::std::vector<::android::aidl::tests::IntEnum>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseLongEnum(const ::std::vector<::android::aidl::tests::LongEnum>& /*input*/, ::std::vector<::android::aidl::tests::LongEnum>* /*repeated*/, ::std::vector<::android::aidl::tests::LongEnum>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status GetOtherTestService(const ::android::String16& /*name*/, ::android::sp<::android::aidl::tests::INamedCallback>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status SetOtherTestService(const ::android::String16& /*name*/, const ::android::sp<::android::aidl::tests::INamedCallback>& /*service*/, bool* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status VerifyName(const ::android::sp<::android::aidl::tests::INamedCallback>& /*service*/, const ::android::String16& /*name*/, bool* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status GetInterfaceArray(const ::std::vector<::android::String16>& /*names*/, ::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status VerifyNamesWithInterfaceArray(const ::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>& /*services*/, const ::std::vector<::android::String16>& /*names*/, bool* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status GetNullableInterfaceArray(const ::std::optional<::std::vector<::std::optional<::android::String16>>>& /*names*/, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status VerifyNamesWithNullableInterfaceArray(const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>& /*services*/, const ::std::optional<::std::vector<::std::optional<::android::String16>>>& /*names*/, bool* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status GetInterfaceList(const ::std::optional<::std::vector<::std::optional<::android::String16>>>& /*names*/, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status VerifyNamesWithInterfaceList(const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::INamedCallback>>>& /*services*/, const ::std::optional<::std::vector<::std::optional<::android::String16>>>& /*names*/, bool* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseStringList(const ::std::vector<::android::String16>& /*input*/, ::std::vector<::android::String16>* /*repeated*/, ::std::vector<::android::String16>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatParcelFileDescriptor(const ::android::os::ParcelFileDescriptor& /*read*/, ::android::os::ParcelFileDescriptor* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseParcelFileDescriptorArray(const ::std::vector<::android::os::ParcelFileDescriptor>& /*input*/, ::std::vector<::android::os::ParcelFileDescriptor>* /*repeated*/, ::std::vector<::android::os::ParcelFileDescriptor>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ThrowServiceException(int32_t /*code*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatNullableIntArray(const ::std::optional<::std::vector>& /*input*/, ::std::optional<::std::vector>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatNullableByteEnumArray(const ::std::optional<::std::vector<::android::aidl::tests::ByteEnum>>& /*input*/, ::std::optional<::std::vector<::android::aidl::tests::ByteEnum>>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatNullableIntEnumArray(const ::std::optional<::std::vector<::android::aidl::tests::IntEnum>>& /*input*/, ::std::optional<::std::vector<::android::aidl::tests::IntEnum>>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatNullableLongEnumArray(const ::std::optional<::std::vector<::android::aidl::tests::LongEnum>>& /*input*/, ::std::optional<::std::vector<::android::aidl::tests::LongEnum>>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatNullableString(const ::std::optional<::android::String16>& /*input*/, ::std::optional<::android::String16>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatNullableStringList(const ::std::optional<::std::vector<::std::optional<::android::String16>>>& /*input*/, ::std::optional<::std::vector<::std::optional<::android::String16>>>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatNullableParcelable(const ::std::optional<::android::aidl::tests::ITestService::Empty>& /*input*/, ::std::optional<::android::aidl::tests::ITestService::Empty>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatNullableParcelableArray(const ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>& /*input*/, ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatNullableParcelableList(const ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>& /*input*/, ::std::optional<::std::vector<::std::optional<::android::aidl::tests::ITestService::Empty>>>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status TakesAnIBinder(const ::android::sp<::android::IBinder>& /*input*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status TakesANullableIBinder(const ::android::sp<::android::IBinder>& /*input*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status TakesAnIBinderList(const ::std::vector<::android::sp<::android::IBinder>>& /*input*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status TakesANullableIBinderList(const ::std::optional<::std::vector<::android::sp<::android::IBinder>>>& /*input*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatUtf8CppString(const ::std::string& /*token*/, ::std::string* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatNullableUtf8CppString(const ::std::optional<::std::string>& /*token*/, ::std::optional<::std::string>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseUtf8CppString(const ::std::vector<::std::string>& /*input*/, ::std::vector<::std::string>* /*repeated*/, ::std::vector<::std::string>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseNullableUtf8CppString(const ::std::optional<::std::vector<::std::optional<::std::string>>>& /*input*/, ::std::optional<::std::vector<::std::optional<::std::string>>>* /*repeated*/, ::std::optional<::std::vector<::std::optional<::std::string>>>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseUtf8CppStringList(const ::std::optional<::std::vector<::std::optional<::std::string>>>& /*input*/, ::std::optional<::std::vector<::std::optional<::std::string>>>* /*repeated*/, ::std::optional<::std::vector<::std::optional<::std::string>>>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status GetCallback(bool /*return_null*/, ::android::sp<::android::aidl::tests::INamedCallback>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status FillOutStructuredParcelable(::android::aidl::tests::StructuredParcelable* /*parcel*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatExtendableParcelable(const ::android::aidl::tests::extension::ExtendableParcelable& /*ep*/, ::android::aidl::tests::extension::ExtendableParcelable* /*ep2*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseList(const ::android::aidl::tests::RecursiveList& /*list*/, ::android::aidl::tests::RecursiveList* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseIBinderArray(const ::std::vector<::android::sp<::android::IBinder>>& /*input*/, ::std::vector<::android::sp<::android::IBinder>>* /*repeated*/, ::std::vector<::android::sp<::android::IBinder>>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseNullableIBinderArray(const ::std::optional<::std::vector<::android::sp<::android::IBinder>>>& /*input*/, ::std::optional<::std::vector<::android::sp<::android::IBinder>>>* /*repeated*/, ::std::optional<::std::vector<::android::sp<::android::IBinder>>>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status RepeatSimpleParcelable(const ::android::aidl::tests::SimpleParcelable& /*input*/, ::android::aidl::tests::SimpleParcelable* /*repeat*/, ::android::aidl::tests::SimpleParcelable* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ReverseSimpleParcelables(const ::std::vector<::android::aidl::tests::SimpleParcelable>& /*input*/, ::std::vector<::android::aidl::tests::SimpleParcelable>* /*repeated*/, ::std::vector<::android::aidl::tests::SimpleParcelable>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status GetOldNameInterface(::android::sp<::android::aidl::tests::IOldName>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status GetNewNameInterface(::android::sp<::android::aidl::tests::INewName>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status GetUnionTags(const ::std::vector<::android::aidl::tests::Union>& /*input*/, ::std::vector<::android::aidl::tests::Union::Tag>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status GetCppJavaTests(::android::sp<::android::IBinder>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status getBackendType(::android::aidl::tests::BackendType* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status GetCircular(::android::aidl::tests::CircularParcelable* /*cp*/, ::android::sp<::android::aidl::tests::ICircular>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } }; // class ITestServiceDefault } // namespace tests } // namespace aidl } // namespace android namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(ITestService::CompilerChecks::UsingHasDeprecated::Tag val) { switch(val) { case ITestService::CompilerChecks::UsingHasDeprecated::Tag::n: return "n"; case ITestService::CompilerChecks::UsingHasDeprecated::Tag::m: return "m"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::tests::ITestService::CompilerChecks::UsingHasDeprecated::Tag, 2> enum_values<::android::aidl::tests::ITestService::CompilerChecks::UsingHasDeprecated::Tag> = { ::android::aidl::tests::ITestService::CompilerChecks::UsingHasDeprecated::Tag::n, ::android::aidl::tests::ITestService::CompilerChecks::UsingHasDeprecated::Tag::m, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000034 15172120304 033246 xustar000000000 0000000 28 mtime=1776853188.6070000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/IntEnum.h0100644 0000000 0000000 00000003772 15172120304 032467 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/IntEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { enum class IntEnum : int32_t { FOO = 1000, BAR = 2000, BAZ = 2001, QUX __attribute__((deprecated("do not use this"))) = 2002, }; } // namespace tests } // namespace aidl } // namespace android namespace android { namespace aidl { namespace tests { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" [[nodiscard]] static inline std::string toString(IntEnum val) { switch(val) { case IntEnum::FOO: return "FOO"; case IntEnum::BAR: return "BAR"; case IntEnum::BAZ: return "BAZ"; case IntEnum::QUX: return "QUX"; default: return std::to_string(static_cast(val)); } } #pragma clang diagnostic pop } // namespace tests } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" #pragma clang diagnostic ignored "-Wdeprecated-declarations" template <> constexpr inline std::array<::android::aidl::tests::IntEnum, 4> enum_values<::android::aidl::tests::IntEnum> = { ::android::aidl::tests::IntEnum::FOO, ::android::aidl::tests::IntEnum::BAR, ::android::aidl::tests::IntEnum::BAZ, ::android::aidl::tests::IntEnum::QUX, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000221 15172120304 033244 xustar000000000 0000000 117 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/ListOfInterfaces.h 28 mtime=1776853188.6070000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/ListOfInter0100644 0000000 0000000 00000043426 15172120304 033064 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ListOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ListOfInterfaces.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace android { namespace aidl { namespace tests { class ListOfInterfaces : public ::android::Parcelable { public: class IEmptyInterfaceDelegator; class IEmptyInterface : public ::android::IInterface { public: typedef IEmptyInterfaceDelegator DefaultDelegator; DECLARE_META_INTERFACE(EmptyInterface) }; // class IEmptyInterface class IEmptyInterfaceDefault : public IEmptyInterface { public: ::android::IBinder* onAsBinder() override { return nullptr; } }; // class IEmptyInterfaceDefault class BpEmptyInterface : public ::android::BpInterface { public: explicit BpEmptyInterface(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpEmptyInterface() = default; }; // class BpEmptyInterface class BnEmptyInterface : public ::android::BnInterface { public: explicit BnEmptyInterface(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnEmptyInterface class IEmptyInterfaceDelegator : public BnEmptyInterface { public: explicit IEmptyInterfaceDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } private: ::android::sp _aidl_delegate; }; // class IEmptyInterfaceDelegator class IMyInterfaceDelegator; class IMyInterface : public ::android::IInterface { public: typedef IMyInterfaceDelegator DefaultDelegator; DECLARE_META_INTERFACE(MyInterface) virtual ::android::binder::Status methodWithInterfaces(const ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& iface, const ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& nullable_iface, const ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>& iface_list_in, ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>* iface_list_out, ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>* iface_list_inout, const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>& nullable_iface_list_in, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>* nullable_iface_list_out, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>* nullable_iface_list_inout, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>* _aidl_return) = 0; }; // class IMyInterface class IMyInterfaceDefault : public IMyInterface { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status methodWithInterfaces(const ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& /*iface*/, const ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& /*nullable_iface*/, const ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>& /*iface_list_in*/, ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>* /*iface_list_out*/, ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>* /*iface_list_inout*/, const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>& /*nullable_iface_list_in*/, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>* /*nullable_iface_list_out*/, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>* /*nullable_iface_list_inout*/, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } }; // class IMyInterfaceDefault class BpMyInterface : public ::android::BpInterface { public: explicit BpMyInterface(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpMyInterface() = default; ::android::binder::Status methodWithInterfaces(const ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& iface, const ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& nullable_iface, const ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>& iface_list_in, ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>* iface_list_out, ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>* iface_list_inout, const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>& nullable_iface_list_in, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>* nullable_iface_list_out, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>* nullable_iface_list_inout, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>* _aidl_return) override; }; // class BpMyInterface class BnMyInterface : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_methodWithInterfaces = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; explicit BnMyInterface(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnMyInterface class IMyInterfaceDelegator : public BnMyInterface { public: explicit IMyInterfaceDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status methodWithInterfaces(const ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& iface, const ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& nullable_iface, const ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>& iface_list_in, ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>* iface_list_out, ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>* iface_list_inout, const ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>& nullable_iface_list_in, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>* nullable_iface_list_out, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>* nullable_iface_list_inout, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>* _aidl_return) override { ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterfaceDelegator> _iface; if (iface) { _iface = ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterfaceDelegator>::cast(delegate(iface)); } ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterfaceDelegator> _nullable_iface; if (nullable_iface) { _nullable_iface = ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterfaceDelegator>::cast(delegate(nullable_iface)); } return _aidl_delegate->methodWithInterfaces(_iface, _nullable_iface, iface_list_in, iface_list_out, iface_list_inout, nullable_iface_list_in, nullable_iface_list_out, nullable_iface_list_inout, _aidl_return); } private: ::android::sp _aidl_delegate; }; // class IMyInterfaceDelegator class MyParcelable : public ::android::Parcelable { public: ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface> iface; ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface> nullable_iface; ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>> iface_list; ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>> nullable_iface_list; inline bool operator==(const MyParcelable& _rhs) const { return std::tie(iface, nullable_iface, iface_list, nullable_iface_list) == std::tie(_rhs.iface, _rhs.nullable_iface, _rhs.iface_list, _rhs.nullable_iface_list); } inline bool operator<(const MyParcelable& _rhs) const { return std::tie(iface, nullable_iface, iface_list, nullable_iface_list) < std::tie(_rhs.iface, _rhs.nullable_iface, _rhs.iface_list, _rhs.nullable_iface_list); } inline bool operator!=(const MyParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyParcelable& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.ListOfInterfaces.MyParcelable"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "MyParcelable{"; _aidl_os << "iface: " << ::android::internal::ToString(iface); _aidl_os << ", nullable_iface: " << ::android::internal::ToString(nullable_iface); _aidl_os << ", iface_list: " << ::android::internal::ToString(iface_list); _aidl_os << ", nullable_iface_list: " << ::android::internal::ToString(nullable_iface_list); _aidl_os << "}"; return _aidl_os.str(); } }; // class MyParcelable class MyUnion : public ::android::Parcelable { public: enum class Tag : int32_t { iface = 0, nullable_iface = 1, iface_list = 2, nullable_iface_list = 3, }; // Expose tag symbols for legacy code static const inline Tag iface = Tag::iface; static const inline Tag nullable_iface = Tag::nullable_iface; static const inline Tag iface_list = Tag::iface_list; static const inline Tag nullable_iface_list = Tag::nullable_iface_list; template static constexpr bool _not_self = !std::is_same_v>, MyUnion>; MyUnion() : _value(std::in_place_index(iface)>, ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>()) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr MyUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit MyUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static MyUnion make(_Tp&&... _args) { return MyUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static MyUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return MyUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } inline bool operator==(const MyUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const MyUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const MyUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyUnion& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.ListOfInterfaces.MyUnion"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream os; os << "MyUnion{"; switch (getTag()) { case iface: os << "iface: " << ::android::internal::ToString(get()); break; case nullable_iface: os << "nullable_iface: " << ::android::internal::ToString(get()); break; case iface_list: os << "iface_list: " << ::android::internal::ToString(get()); break; case nullable_iface_list: os << "nullable_iface_list: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>, ::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>, ::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>, ::std::optional<::std::vector<::android::sp<::android::aidl::tests::ListOfInterfaces::IEmptyInterface>>>> _value; }; // class MyUnion inline bool operator==(const ListOfInterfaces&) const { return std::tie() == std::tie(); } inline bool operator<(const ListOfInterfaces&) const { return std::tie() < std::tie(); } inline bool operator!=(const ListOfInterfaces& _rhs) const { return !(*this == _rhs); } inline bool operator>(const ListOfInterfaces& _rhs) const { return _rhs < *this; } inline bool operator>=(const ListOfInterfaces& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const ListOfInterfaces& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.ListOfInterfaces"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "ListOfInterfaces{"; _aidl_os << "}"; return _aidl_os.str(); } }; // class ListOfInterfaces } // namespace tests } // namespace aidl } // namespace android namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(ListOfInterfaces::MyUnion::Tag val) { switch(val) { case ListOfInterfaces::MyUnion::Tag::iface: return "iface"; case ListOfInterfaces::MyUnion::Tag::nullable_iface: return "nullable_iface"; case ListOfInterfaces::MyUnion::Tag::iface_list: return "iface_list"; case ListOfInterfaces::MyUnion::Tag::nullable_iface_list: return "nullable_iface_list"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::tests::ListOfInterfaces::MyUnion::Tag, 4> enum_values<::android::aidl::tests::ListOfInterfaces::MyUnion::Tag> = { ::android::aidl::tests::ListOfInterfaces::MyUnion::Tag::iface, ::android::aidl::tests::ListOfInterfaces::MyUnion::Tag::nullable_iface, ::android::aidl::tests::ListOfInterfaces::MyUnion::Tag::iface_list, ::android::aidl::tests::ListOfInterfaces::MyUnion::Tag::nullable_iface_list, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000034 15172120304 033246 xustar000000000 0000000 28 mtime=1776853188.6100000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/LongEnum.h0100644 0000000 0000000 00000003340 15172120304 032623 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/LongEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { enum class LongEnum : int64_t { FOO = 100000000000L, BAR = 200000000000L, BAZ = 200000000001L, }; } // namespace tests } // namespace aidl } // namespace android namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(LongEnum val) { switch(val) { case LongEnum::FOO: return "FOO"; case LongEnum::BAR: return "BAR"; case LongEnum::BAZ: return "BAZ"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::tests::LongEnum, 3> enum_values<::android::aidl::tests::LongEnum> = { ::android::aidl::tests::LongEnum::FOO, ::android::aidl::tests::LongEnum::BAR, ::android::aidl::tests::LongEnum::BAZ, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000233 15172120304 033247 xustar000000000 0000000 127 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/OtherParcelableForToString.h 28 mtime=1776853188.6100000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/OtherParcel0100644 0000000 0000000 00000004415 15172120304 033065 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/OtherParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl */ #pragma once #include #include #include #include #include namespace android { namespace aidl { namespace tests { class OtherParcelableForToString : public ::android::Parcelable { public: ::android::String16 field; inline bool operator==(const OtherParcelableForToString& _rhs) const { return std::tie(field) == std::tie(_rhs.field); } inline bool operator<(const OtherParcelableForToString& _rhs) const { return std::tie(field) < std::tie(_rhs.field); } inline bool operator!=(const OtherParcelableForToString& _rhs) const { return !(*this == _rhs); } inline bool operator>(const OtherParcelableForToString& _rhs) const { return _rhs < *this; } inline bool operator>=(const OtherParcelableForToString& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const OtherParcelableForToString& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.OtherParcelableForToString"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "OtherParcelableForToString{"; _aidl_os << "field: " << ::android::internal::ToString(field); _aidl_os << "}"; return _aidl_os.str(); } }; // class OtherParcelableForToString } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000226 15172120304 033251 xustar000000000 0000000 122 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/ParcelableForToString.h 28 mtime=1776853188.6110000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/ParcelableF0100644 0000000 0000000 00000015460 15172120304 033017 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/ParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ParcelableForToString.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include namespace android::aidl::tests { template class GenericStructuredParcelable; class OtherParcelableForToString; class StructuredParcelable; } // namespace android::aidl::tests namespace android { namespace aidl { namespace tests { class ParcelableForToString : public ::android::Parcelable { public: int32_t intValue = 0; ::std::vector intArray; int64_t longValue = 0L; ::std::vector longArray; double doubleValue = 0.000000; ::std::vector doubleArray; float floatValue = 0.000000f; ::std::vector floatArray; int8_t byteValue = 0; ::std::vector byteArray; bool booleanValue = false; ::std::vector booleanArray; ::android::String16 stringValue; ::std::vector<::android::String16> stringArray; ::std::vector<::android::String16> stringList; ::android::aidl::tests::OtherParcelableForToString parcelableValue; ::std::vector<::android::aidl::tests::OtherParcelableForToString> parcelableArray; ::android::aidl::tests::IntEnum enumValue = ::android::aidl::tests::IntEnum::FOO; ::std::vector<::android::aidl::tests::IntEnum> enumArray; ::std::vector<::android::String16> nullArray; ::std::vector<::android::String16> nullList; ::android::aidl::tests::GenericStructuredParcelable parcelableGeneric; ::android::aidl::tests::Union unionValue; inline bool operator==(const ParcelableForToString& _rhs) const { return std::tie(intValue, intArray, longValue, longArray, doubleValue, doubleArray, floatValue, floatArray, byteValue, byteArray, booleanValue, booleanArray, stringValue, stringArray, stringList, parcelableValue, parcelableArray, enumValue, enumArray, nullArray, nullList, parcelableGeneric, unionValue) == std::tie(_rhs.intValue, _rhs.intArray, _rhs.longValue, _rhs.longArray, _rhs.doubleValue, _rhs.doubleArray, _rhs.floatValue, _rhs.floatArray, _rhs.byteValue, _rhs.byteArray, _rhs.booleanValue, _rhs.booleanArray, _rhs.stringValue, _rhs.stringArray, _rhs.stringList, _rhs.parcelableValue, _rhs.parcelableArray, _rhs.enumValue, _rhs.enumArray, _rhs.nullArray, _rhs.nullList, _rhs.parcelableGeneric, _rhs.unionValue); } inline bool operator<(const ParcelableForToString& _rhs) const { return std::tie(intValue, intArray, longValue, longArray, doubleValue, doubleArray, floatValue, floatArray, byteValue, byteArray, booleanValue, booleanArray, stringValue, stringArray, stringList, parcelableValue, parcelableArray, enumValue, enumArray, nullArray, nullList, parcelableGeneric, unionValue) < std::tie(_rhs.intValue, _rhs.intArray, _rhs.longValue, _rhs.longArray, _rhs.doubleValue, _rhs.doubleArray, _rhs.floatValue, _rhs.floatArray, _rhs.byteValue, _rhs.byteArray, _rhs.booleanValue, _rhs.booleanArray, _rhs.stringValue, _rhs.stringArray, _rhs.stringList, _rhs.parcelableValue, _rhs.parcelableArray, _rhs.enumValue, _rhs.enumArray, _rhs.nullArray, _rhs.nullList, _rhs.parcelableGeneric, _rhs.unionValue); } inline bool operator!=(const ParcelableForToString& _rhs) const { return !(*this == _rhs); } inline bool operator>(const ParcelableForToString& _rhs) const { return _rhs < *this; } inline bool operator>=(const ParcelableForToString& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const ParcelableForToString& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.ParcelableForToString"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "ParcelableForToString{"; _aidl_os << "intValue: " << ::android::internal::ToString(intValue); _aidl_os << ", intArray: " << ::android::internal::ToString(intArray); _aidl_os << ", longValue: " << ::android::internal::ToString(longValue); _aidl_os << ", longArray: " << ::android::internal::ToString(longArray); _aidl_os << ", doubleValue: " << ::android::internal::ToString(doubleValue); _aidl_os << ", doubleArray: " << ::android::internal::ToString(doubleArray); _aidl_os << ", floatValue: " << ::android::internal::ToString(floatValue); _aidl_os << ", floatArray: " << ::android::internal::ToString(floatArray); _aidl_os << ", byteValue: " << ::android::internal::ToString(byteValue); _aidl_os << ", byteArray: " << ::android::internal::ToString(byteArray); _aidl_os << ", booleanValue: " << ::android::internal::ToString(booleanValue); _aidl_os << ", booleanArray: " << ::android::internal::ToString(booleanArray); _aidl_os << ", stringValue: " << ::android::internal::ToString(stringValue); _aidl_os << ", stringArray: " << ::android::internal::ToString(stringArray); _aidl_os << ", stringList: " << ::android::internal::ToString(stringList); _aidl_os << ", parcelableValue: " << ::android::internal::ToString(parcelableValue); _aidl_os << ", parcelableArray: " << ::android::internal::ToString(parcelableArray); _aidl_os << ", enumValue: " << ::android::internal::ToString(enumValue); _aidl_os << ", enumArray: " << ::android::internal::ToString(enumArray); _aidl_os << ", nullArray: " << ::android::internal::ToString(nullArray); _aidl_os << ", nullList: " << ::android::internal::ToString(nullList); _aidl_os << ", parcelableGeneric: " << ::android::internal::ToString(parcelableGeneric); _aidl_os << ", unionValue: " << ::android::internal::ToString(unionValue); _aidl_os << "}"; return _aidl_os.str(); } }; // class ParcelableForToString } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000216 15172120304 033250 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/RecursiveList.h 28 mtime=1776853188.6110000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/RecursiveLi0100644 0000000 0000000 00000004677 15172120304 033123 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/RecursiveList.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl */ #pragma once #include #include #include #include #include #include #include #include namespace android::aidl::tests { class RecursiveList; } // namespace android::aidl::tests namespace android { namespace aidl { namespace tests { class RecursiveList : public ::android::Parcelable { public: int32_t value = 0; ::std::unique_ptr<::android::aidl::tests::RecursiveList> next; inline bool operator==(const RecursiveList& _rhs) const { return std::tie(value, next) == std::tie(_rhs.value, _rhs.next); } inline bool operator<(const RecursiveList& _rhs) const { return std::tie(value, next) < std::tie(_rhs.value, _rhs.next); } inline bool operator!=(const RecursiveList& _rhs) const { return !(*this == _rhs); } inline bool operator>(const RecursiveList& _rhs) const { return _rhs < *this; } inline bool operator>=(const RecursiveList& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const RecursiveList& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.RecursiveList"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "RecursiveList{"; _aidl_os << "value: " << ::android::internal::ToString(value); _aidl_os << ", next: " << ::android::internal::ToString(next); _aidl_os << "}"; return _aidl_os.str(); } }; // class RecursiveList } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000225 15172120304 033250 xustar000000000 0000000 121 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/StructuredParcelable.h 28 mtime=1776853188.6110000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/StructuredP0100644 0000000 0000000 00000037511 15172120304 033144 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/StructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace android { namespace aidl { namespace tests { class StructuredParcelable : public ::android::Parcelable { public: class Empty : public ::android::Parcelable { public: inline bool operator==(const Empty&) const { return std::tie() == std::tie(); } inline bool operator<(const Empty&) const { return std::tie() < std::tie(); } inline bool operator!=(const Empty& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Empty& _rhs) const { return _rhs < *this; } inline bool operator>=(const Empty& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Empty& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.StructuredParcelable.Empty"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "Empty{"; _aidl_os << "}"; return _aidl_os.str(); } }; // class Empty ::std::vector shouldContainThreeFs; int32_t f = 0; ::std::string shouldBeJerry; ::android::aidl::tests::ByteEnum shouldBeByteBar = ::android::aidl::tests::ByteEnum(0); ::android::aidl::tests::IntEnum shouldBeIntBar = ::android::aidl::tests::IntEnum(0); ::android::aidl::tests::LongEnum shouldBeLongBar = ::android::aidl::tests::LongEnum(0); ::std::vector<::android::aidl::tests::ByteEnum> shouldContainTwoByteFoos; ::std::vector<::android::aidl::tests::IntEnum> shouldContainTwoIntFoos; ::std::vector<::android::aidl::tests::LongEnum> shouldContainTwoLongFoos; ::android::String16 stringDefaultsToFoo = ::android::String16("foo"); int8_t byteDefaultsToFour = 4; int32_t intDefaultsToFive = 5; int64_t longDefaultsToNegativeSeven = -7L; bool booleanDefaultsToTrue = true; char16_t charDefaultsToC = 'C'; float floatDefaultsToPi = 3.140000f; double doubleWithDefault = -314000000000000000.000000; ::std::vector arrayDefaultsTo123 = {1, 2, 3}; ::std::vector arrayDefaultsToEmpty = {}; bool boolDefault = false; int8_t byteDefault = 0; int32_t intDefault = 0; int64_t longDefault = 0L; float floatDefault = 0.000000f; double doubleDefault = 0.000000; double checkDoubleFromFloat = 3.140000; ::std::vector<::android::String16> checkStringArray1 = {::android::String16("a"), ::android::String16("b")}; ::std::vector<::std::string> checkStringArray2 = {"a", "b"}; int32_t int32_min = -2147483648; int32_t int32_max = 2147483647; int64_t int64_max = 9223372036854775807L; int32_t hexInt32_neg_1 = -1; ::android::sp<::android::IBinder> ibinder; ::android::aidl::tests::StructuredParcelable::Empty empty; ::std::vector int8_1 = {1, 1, 1, 1, 1}; ::std::vector int32_1 = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}; ::std::vector int64_1 = {1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L}; int32_t hexInt32_pos_1 = 1; int32_t hexInt64_pos_1 = 1; ::android::aidl::tests::ConstantExpressionEnum const_exprs_1 = ::android::aidl::tests::ConstantExpressionEnum(0); ::android::aidl::tests::ConstantExpressionEnum const_exprs_2 = ::android::aidl::tests::ConstantExpressionEnum(0); ::android::aidl::tests::ConstantExpressionEnum const_exprs_3 = ::android::aidl::tests::ConstantExpressionEnum(0); ::android::aidl::tests::ConstantExpressionEnum const_exprs_4 = ::android::aidl::tests::ConstantExpressionEnum(0); ::android::aidl::tests::ConstantExpressionEnum const_exprs_5 = ::android::aidl::tests::ConstantExpressionEnum(0); ::android::aidl::tests::ConstantExpressionEnum const_exprs_6 = ::android::aidl::tests::ConstantExpressionEnum(0); ::android::aidl::tests::ConstantExpressionEnum const_exprs_7 = ::android::aidl::tests::ConstantExpressionEnum(0); ::android::aidl::tests::ConstantExpressionEnum const_exprs_8 = ::android::aidl::tests::ConstantExpressionEnum(0); ::android::aidl::tests::ConstantExpressionEnum const_exprs_9 = ::android::aidl::tests::ConstantExpressionEnum(0); ::android::aidl::tests::ConstantExpressionEnum const_exprs_10 = ::android::aidl::tests::ConstantExpressionEnum(0); ::std::string addString1 = "hello world!"; ::std::string addString2 = "The quick brown fox jumps over the lazy dog."; int32_t shouldSetBit0AndBit2 = 0; ::std::optional<::android::aidl::tests::Union> u; ::std::optional<::android::aidl::tests::Union> shouldBeConstS1; ::android::aidl::tests::IntEnum defaultWithFoo = ::android::aidl::tests::IntEnum::FOO; inline bool operator==(const StructuredParcelable& _rhs) const { return std::tie(shouldContainThreeFs, f, shouldBeJerry, shouldBeByteBar, shouldBeIntBar, shouldBeLongBar, shouldContainTwoByteFoos, shouldContainTwoIntFoos, shouldContainTwoLongFoos, stringDefaultsToFoo, byteDefaultsToFour, intDefaultsToFive, longDefaultsToNegativeSeven, booleanDefaultsToTrue, charDefaultsToC, floatDefaultsToPi, doubleWithDefault, arrayDefaultsTo123, arrayDefaultsToEmpty, boolDefault, byteDefault, intDefault, longDefault, floatDefault, doubleDefault, checkDoubleFromFloat, checkStringArray1, checkStringArray2, int32_min, int32_max, int64_max, hexInt32_neg_1, ibinder, empty, int8_1, int32_1, int64_1, hexInt32_pos_1, hexInt64_pos_1, const_exprs_1, const_exprs_2, const_exprs_3, const_exprs_4, const_exprs_5, const_exprs_6, const_exprs_7, const_exprs_8, const_exprs_9, const_exprs_10, addString1, addString2, shouldSetBit0AndBit2, u, shouldBeConstS1, defaultWithFoo) == std::tie(_rhs.shouldContainThreeFs, _rhs.f, _rhs.shouldBeJerry, _rhs.shouldBeByteBar, _rhs.shouldBeIntBar, _rhs.shouldBeLongBar, _rhs.shouldContainTwoByteFoos, _rhs.shouldContainTwoIntFoos, _rhs.shouldContainTwoLongFoos, _rhs.stringDefaultsToFoo, _rhs.byteDefaultsToFour, _rhs.intDefaultsToFive, _rhs.longDefaultsToNegativeSeven, _rhs.booleanDefaultsToTrue, _rhs.charDefaultsToC, _rhs.floatDefaultsToPi, _rhs.doubleWithDefault, _rhs.arrayDefaultsTo123, _rhs.arrayDefaultsToEmpty, _rhs.boolDefault, _rhs.byteDefault, _rhs.intDefault, _rhs.longDefault, _rhs.floatDefault, _rhs.doubleDefault, _rhs.checkDoubleFromFloat, _rhs.checkStringArray1, _rhs.checkStringArray2, _rhs.int32_min, _rhs.int32_max, _rhs.int64_max, _rhs.hexInt32_neg_1, _rhs.ibinder, _rhs.empty, _rhs.int8_1, _rhs.int32_1, _rhs.int64_1, _rhs.hexInt32_pos_1, _rhs.hexInt64_pos_1, _rhs.const_exprs_1, _rhs.const_exprs_2, _rhs.const_exprs_3, _rhs.const_exprs_4, _rhs.const_exprs_5, _rhs.const_exprs_6, _rhs.const_exprs_7, _rhs.const_exprs_8, _rhs.const_exprs_9, _rhs.const_exprs_10, _rhs.addString1, _rhs.addString2, _rhs.shouldSetBit0AndBit2, _rhs.u, _rhs.shouldBeConstS1, _rhs.defaultWithFoo); } inline bool operator<(const StructuredParcelable& _rhs) const { return std::tie(shouldContainThreeFs, f, shouldBeJerry, shouldBeByteBar, shouldBeIntBar, shouldBeLongBar, shouldContainTwoByteFoos, shouldContainTwoIntFoos, shouldContainTwoLongFoos, stringDefaultsToFoo, byteDefaultsToFour, intDefaultsToFive, longDefaultsToNegativeSeven, booleanDefaultsToTrue, charDefaultsToC, floatDefaultsToPi, doubleWithDefault, arrayDefaultsTo123, arrayDefaultsToEmpty, boolDefault, byteDefault, intDefault, longDefault, floatDefault, doubleDefault, checkDoubleFromFloat, checkStringArray1, checkStringArray2, int32_min, int32_max, int64_max, hexInt32_neg_1, ibinder, empty, int8_1, int32_1, int64_1, hexInt32_pos_1, hexInt64_pos_1, const_exprs_1, const_exprs_2, const_exprs_3, const_exprs_4, const_exprs_5, const_exprs_6, const_exprs_7, const_exprs_8, const_exprs_9, const_exprs_10, addString1, addString2, shouldSetBit0AndBit2, u, shouldBeConstS1, defaultWithFoo) < std::tie(_rhs.shouldContainThreeFs, _rhs.f, _rhs.shouldBeJerry, _rhs.shouldBeByteBar, _rhs.shouldBeIntBar, _rhs.shouldBeLongBar, _rhs.shouldContainTwoByteFoos, _rhs.shouldContainTwoIntFoos, _rhs.shouldContainTwoLongFoos, _rhs.stringDefaultsToFoo, _rhs.byteDefaultsToFour, _rhs.intDefaultsToFive, _rhs.longDefaultsToNegativeSeven, _rhs.booleanDefaultsToTrue, _rhs.charDefaultsToC, _rhs.floatDefaultsToPi, _rhs.doubleWithDefault, _rhs.arrayDefaultsTo123, _rhs.arrayDefaultsToEmpty, _rhs.boolDefault, _rhs.byteDefault, _rhs.intDefault, _rhs.longDefault, _rhs.floatDefault, _rhs.doubleDefault, _rhs.checkDoubleFromFloat, _rhs.checkStringArray1, _rhs.checkStringArray2, _rhs.int32_min, _rhs.int32_max, _rhs.int64_max, _rhs.hexInt32_neg_1, _rhs.ibinder, _rhs.empty, _rhs.int8_1, _rhs.int32_1, _rhs.int64_1, _rhs.hexInt32_pos_1, _rhs.hexInt64_pos_1, _rhs.const_exprs_1, _rhs.const_exprs_2, _rhs.const_exprs_3, _rhs.const_exprs_4, _rhs.const_exprs_5, _rhs.const_exprs_6, _rhs.const_exprs_7, _rhs.const_exprs_8, _rhs.const_exprs_9, _rhs.const_exprs_10, _rhs.addString1, _rhs.addString2, _rhs.shouldSetBit0AndBit2, _rhs.u, _rhs.shouldBeConstS1, _rhs.defaultWithFoo); } inline bool operator!=(const StructuredParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const StructuredParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const StructuredParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const StructuredParcelable& _rhs) const { return !(_rhs < *this); } enum : int32_t { BIT0 = 1 }; enum : int32_t { BIT1 = 2 }; enum : int32_t { BIT2 = 4 }; ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.StructuredParcelable"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "StructuredParcelable{"; _aidl_os << "shouldContainThreeFs: " << ::android::internal::ToString(shouldContainThreeFs); _aidl_os << ", f: " << ::android::internal::ToString(f); _aidl_os << ", shouldBeJerry: " << ::android::internal::ToString(shouldBeJerry); _aidl_os << ", shouldBeByteBar: " << ::android::internal::ToString(shouldBeByteBar); _aidl_os << ", shouldBeIntBar: " << ::android::internal::ToString(shouldBeIntBar); _aidl_os << ", shouldBeLongBar: " << ::android::internal::ToString(shouldBeLongBar); _aidl_os << ", shouldContainTwoByteFoos: " << ::android::internal::ToString(shouldContainTwoByteFoos); _aidl_os << ", shouldContainTwoIntFoos: " << ::android::internal::ToString(shouldContainTwoIntFoos); _aidl_os << ", shouldContainTwoLongFoos: " << ::android::internal::ToString(shouldContainTwoLongFoos); _aidl_os << ", stringDefaultsToFoo: " << ::android::internal::ToString(stringDefaultsToFoo); _aidl_os << ", byteDefaultsToFour: " << ::android::internal::ToString(byteDefaultsToFour); _aidl_os << ", intDefaultsToFive: " << ::android::internal::ToString(intDefaultsToFive); _aidl_os << ", longDefaultsToNegativeSeven: " << ::android::internal::ToString(longDefaultsToNegativeSeven); _aidl_os << ", booleanDefaultsToTrue: " << ::android::internal::ToString(booleanDefaultsToTrue); _aidl_os << ", charDefaultsToC: " << ::android::internal::ToString(charDefaultsToC); _aidl_os << ", floatDefaultsToPi: " << ::android::internal::ToString(floatDefaultsToPi); _aidl_os << ", doubleWithDefault: " << ::android::internal::ToString(doubleWithDefault); _aidl_os << ", arrayDefaultsTo123: " << ::android::internal::ToString(arrayDefaultsTo123); _aidl_os << ", arrayDefaultsToEmpty: " << ::android::internal::ToString(arrayDefaultsToEmpty); _aidl_os << ", boolDefault: " << ::android::internal::ToString(boolDefault); _aidl_os << ", byteDefault: " << ::android::internal::ToString(byteDefault); _aidl_os << ", intDefault: " << ::android::internal::ToString(intDefault); _aidl_os << ", longDefault: " << ::android::internal::ToString(longDefault); _aidl_os << ", floatDefault: " << ::android::internal::ToString(floatDefault); _aidl_os << ", doubleDefault: " << ::android::internal::ToString(doubleDefault); _aidl_os << ", checkDoubleFromFloat: " << ::android::internal::ToString(checkDoubleFromFloat); _aidl_os << ", checkStringArray1: " << ::android::internal::ToString(checkStringArray1); _aidl_os << ", checkStringArray2: " << ::android::internal::ToString(checkStringArray2); _aidl_os << ", int32_min: " << ::android::internal::ToString(int32_min); _aidl_os << ", int32_max: " << ::android::internal::ToString(int32_max); _aidl_os << ", int64_max: " << ::android::internal::ToString(int64_max); _aidl_os << ", hexInt32_neg_1: " << ::android::internal::ToString(hexInt32_neg_1); _aidl_os << ", ibinder: " << ::android::internal::ToString(ibinder); _aidl_os << ", empty: " << ::android::internal::ToString(empty); _aidl_os << ", int8_1: " << ::android::internal::ToString(int8_1); _aidl_os << ", int32_1: " << ::android::internal::ToString(int32_1); _aidl_os << ", int64_1: " << ::android::internal::ToString(int64_1); _aidl_os << ", hexInt32_pos_1: " << ::android::internal::ToString(hexInt32_pos_1); _aidl_os << ", hexInt64_pos_1: " << ::android::internal::ToString(hexInt64_pos_1); _aidl_os << ", const_exprs_1: " << ::android::internal::ToString(const_exprs_1); _aidl_os << ", const_exprs_2: " << ::android::internal::ToString(const_exprs_2); _aidl_os << ", const_exprs_3: " << ::android::internal::ToString(const_exprs_3); _aidl_os << ", const_exprs_4: " << ::android::internal::ToString(const_exprs_4); _aidl_os << ", const_exprs_5: " << ::android::internal::ToString(const_exprs_5); _aidl_os << ", const_exprs_6: " << ::android::internal::ToString(const_exprs_6); _aidl_os << ", const_exprs_7: " << ::android::internal::ToString(const_exprs_7); _aidl_os << ", const_exprs_8: " << ::android::internal::ToString(const_exprs_8); _aidl_os << ", const_exprs_9: " << ::android::internal::ToString(const_exprs_9); _aidl_os << ", const_exprs_10: " << ::android::internal::ToString(const_exprs_10); _aidl_os << ", addString1: " << ::android::internal::ToString(addString1); _aidl_os << ", addString2: " << ::android::internal::ToString(addString2); _aidl_os << ", shouldSetBit0AndBit2: " << ::android::internal::ToString(shouldSetBit0AndBit2); _aidl_os << ", u: " << ::android::internal::ToString(u); _aidl_os << ", shouldBeConstS1: " << ::android::internal::ToString(shouldBeConstS1); _aidl_os << ", defaultWithFoo: " << ::android::internal::ToString(defaultWithFoo); _aidl_os << "}"; return _aidl_os.str(); } }; // class StructuredParcelable } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000034 15172120304 033246 xustar000000000 0000000 28 mtime=1776853188.6110000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/Union.h0100644 0000000 0000000 00000014265 15172120304 032177 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/Union.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/Union.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace android { namespace aidl { namespace tests { class Union : public ::android::Parcelable { public: enum class Tag : int32_t { ns = 0, n = 1, m = 2, s = 3, ibinder = 4, ss = 5, be = 6, }; // Expose tag symbols for legacy code static const inline Tag ns = Tag::ns; static const inline Tag n = Tag::n; static const inline Tag m = Tag::m; static const inline Tag s = Tag::s; static const inline Tag ibinder = Tag::ibinder; static const inline Tag ss = Tag::ss; static const inline Tag be = Tag::be; template static constexpr bool _not_self = !std::is_same_v>, Union>; Union() : _value(std::in_place_index(ns)>, ::std::vector({})) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr Union(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit Union(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static Union make(_Tp&&... _args) { return Union(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static Union make(std::initializer_list<_Tp> _il, _Up&&... _args) { return Union(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } inline bool operator==(const Union& _rhs) const { return _value == _rhs._value; } inline bool operator<(const Union& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const Union& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Union& _rhs) const { return _rhs < *this; } inline bool operator>=(const Union& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Union& _rhs) const { return !(_rhs < *this); } static const ::std::string& S1(); ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.Union"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream os; os << "Union{"; switch (getTag()) { case ns: os << "ns: " << ::android::internal::ToString(get()); break; case n: os << "n: " << ::android::internal::ToString(get()); break; case m: os << "m: " << ::android::internal::ToString(get()); break; case s: os << "s: " << ::android::internal::ToString(get()); break; case ibinder: os << "ibinder: " << ::android::internal::ToString(get()); break; case ss: os << "ss: " << ::android::internal::ToString(get()); break; case be: os << "be: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant<::std::vector, int32_t, int32_t, ::std::string, ::android::sp<::android::IBinder>, ::std::vector<::std::string>, ::android::aidl::tests::ByteEnum> _value; }; // class Union } // namespace tests } // namespace aidl } // namespace android namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(Union::Tag val) { switch(val) { case Union::Tag::ns: return "ns"; case Union::Tag::n: return "n"; case Union::Tag::m: return "m"; case Union::Tag::s: return "s"; case Union::Tag::ibinder: return "ibinder"; case Union::Tag::ss: return "ss"; case Union::Tag::be: return "be"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::tests::Union::Tag, 7> enum_values<::android::aidl::tests::Union::Tag> = { ::android::aidl::tests::Union::Tag::ns, ::android::aidl::tests::Union::Tag::n, ::android::aidl::tests::Union::Tag::m, ::android::aidl::tests::Union::Tag::s, ::android::aidl::tests::Union::Tag::ibinder, ::android::aidl::tests::Union::Tag::ss, ::android::aidl::tests::Union::Tag::be, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000214 15172120304 033246 xustar000000000 0000000 112 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/UnionWithFd.h 28 mtime=1776853188.6120000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/UnionWithFd0100644 0000000 0000000 00000012144 15172120304 033051 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/UnionWithFd.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/UnionWithFd.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace android { namespace aidl { namespace tests { class UnionWithFd : public ::android::Parcelable { public: enum class Tag : int32_t { num = 0, pfd = 1, }; // Expose tag symbols for legacy code static const inline Tag num = Tag::num; static const inline Tag pfd = Tag::pfd; template static constexpr bool _not_self = !std::is_same_v>, UnionWithFd>; UnionWithFd() : _value(std::in_place_index(num)>, int32_t(0)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr UnionWithFd(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit UnionWithFd(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static UnionWithFd make(_Tp&&... _args) { return UnionWithFd(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static UnionWithFd make(std::initializer_list<_Tp> _il, _Up&&... _args) { return UnionWithFd(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } inline bool operator==(const UnionWithFd& _rhs) const { return _value == _rhs._value; } inline bool operator<(const UnionWithFd& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const UnionWithFd& _rhs) const { return !(*this == _rhs); } inline bool operator>(const UnionWithFd& _rhs) const { return _rhs < *this; } inline bool operator>=(const UnionWithFd& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const UnionWithFd& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.UnionWithFd"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream os; os << "UnionWithFd{"; switch (getTag()) { case num: os << "num: " << ::android::internal::ToString(get()); break; case pfd: os << "pfd: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant _value; }; // class UnionWithFd } // namespace tests } // namespace aidl } // namespace android namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(UnionWithFd::Tag val) { switch(val) { case UnionWithFd::Tag::num: return "num"; case UnionWithFd::Tag::pfd: return "pfd"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::tests::UnionWithFd::Tag, 2> enum_values<::android::aidl::tests::UnionWithFd::Tag> = { ::android::aidl::tests::UnionWithFd::Tag::num, ::android::aidl::tests::UnionWithFd::Tag::pfd, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000034 15172120304 033246 xustar000000000 0000000 28 mtime=1776853188.6120000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/0040755 0000000 0000000 00000000000 15172120304 032745 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000241 15172120304 033246 xustar000000000 0000000 133 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/BnExtendableParcelable.h 28 mtime=1776853188.6120000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/B0100644 0000000 0000000 00000001264 15172120304 033051 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/extension/ExtendableParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000222 15172120304 033245 xustar000000000 0000000 118 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/BnMyExt.h 28 mtime=1776853188.6120000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/B0100644 0000000 0000000 00000001226 15172120304 033047 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/extension/MyExt.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000223 15172120304 033246 xustar000000000 0000000 119 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/BnMyExt2.h 28 mtime=1776853188.6120000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/B0100644 0000000 0000000 00000001230 15172120304 033042 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/extension/MyExt2.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt2.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000226 15172120304 033251 xustar000000000 0000000 122 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/BnMyExtLike.h 28 mtime=1776853188.6120000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/B0100644 0000000 0000000 00000001236 15172120304 033050 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/extension/MyExtLike.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExtLike.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000241 15172120304 033246 xustar000000000 0000000 133 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/BpExtendableParcelable.h 28 mtime=1776853188.6120000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/B0100644 0000000 0000000 00000001264 15172120304 033051 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/extension/ExtendableParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000222 15172120304 033245 xustar000000000 0000000 118 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/BpMyExt.h 28 mtime=1776853188.6120000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/B0100644 0000000 0000000 00000001226 15172120304 033047 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/extension/MyExt.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000223 15172120304 033246 xustar000000000 0000000 119 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/BpMyExt2.h 28 mtime=1776853188.6120000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/B0100644 0000000 0000000 00000001230 15172120304 033042 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/extension/MyExt2.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt2.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000226 15172120304 033251 xustar000000000 0000000 122 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/BpMyExtLike.h 28 mtime=1776853188.6120000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/B0100644 0000000 0000000 00000001236 15172120304 033050 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/extension/MyExtLike.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExtLike.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000237 15172120304 033253 xustar000000000 0000000 131 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/ExtendableParcelable.h 28 mtime=1776853188.6120000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/E0100644 0000000 0000000 00000005603 15172120304 033055 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/extension/ExtendableParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl */ #pragma once #include #include #include #include #include #include #include #include namespace android { namespace aidl { namespace tests { namespace extension { class ExtendableParcelable : public ::android::Parcelable { public: int32_t a = 0; ::std::string b; ::android::os::ParcelableHolder ext { ::android::Parcelable::Stability::STABILITY_LOCAL }; int64_t c = 0L; ::android::os::ParcelableHolder ext2 { ::android::Parcelable::Stability::STABILITY_LOCAL }; inline bool operator==(const ExtendableParcelable& _rhs) const { return std::tie(a, b, ext, c, ext2) == std::tie(_rhs.a, _rhs.b, _rhs.ext, _rhs.c, _rhs.ext2); } inline bool operator<(const ExtendableParcelable& _rhs) const { return std::tie(a, b, ext, c, ext2) < std::tie(_rhs.a, _rhs.b, _rhs.ext, _rhs.c, _rhs.ext2); } inline bool operator!=(const ExtendableParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const ExtendableParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const ExtendableParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const ExtendableParcelable& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.extension.ExtendableParcelable"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "ExtendableParcelable{"; _aidl_os << "a: " << ::android::internal::ToString(a); _aidl_os << ", b: " << ::android::internal::ToString(b); _aidl_os << ", ext: " << ::android::internal::ToString(ext); _aidl_os << ", c: " << ::android::internal::ToString(c); _aidl_os << ", ext2: " << ::android::internal::ToString(ext2); _aidl_os << "}"; return _aidl_os.str(); } }; // class ExtendableParcelable } // namespace extension } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000220 15172120304 033243 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/MyExt.h 28 mtime=1776853188.6120000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/M0100644 0000000 0000000 00000004306 15172120304 033064 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/extension/MyExt.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl */ #pragma once #include #include #include #include #include #include #include namespace android { namespace aidl { namespace tests { namespace extension { class MyExt : public ::android::Parcelable { public: int32_t a = 0; ::std::string b; inline bool operator==(const MyExt& _rhs) const { return std::tie(a, b) == std::tie(_rhs.a, _rhs.b); } inline bool operator<(const MyExt& _rhs) const { return std::tie(a, b) < std::tie(_rhs.a, _rhs.b); } inline bool operator!=(const MyExt& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyExt& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyExt& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyExt& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.extension.MyExt"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "MyExt{"; _aidl_os << "a: " << ::android::internal::ToString(a); _aidl_os << ", b: " << ::android::internal::ToString(b); _aidl_os << "}"; return _aidl_os.str(); } }; // class MyExt } // namespace extension } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000221 15172120304 033244 xustar000000000 0000000 117 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/MyExt2.h 28 mtime=1776853188.6120000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/M0100644 0000000 0000000 00000004754 15172120304 033073 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/extension/MyExt2.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt2.aidl */ #pragma once #include #include #include #include #include #include #include #include namespace android::aidl::tests::extension { class MyExt; } // namespace android::aidl::tests::extension namespace android { namespace aidl { namespace tests { namespace extension { class MyExt2 : public ::android::Parcelable { public: int32_t a = 0; ::android::aidl::tests::extension::MyExt b; ::std::string c; inline bool operator==(const MyExt2& _rhs) const { return std::tie(a, b, c) == std::tie(_rhs.a, _rhs.b, _rhs.c); } inline bool operator<(const MyExt2& _rhs) const { return std::tie(a, b, c) < std::tie(_rhs.a, _rhs.b, _rhs.c); } inline bool operator!=(const MyExt2& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyExt2& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyExt2& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyExt2& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.extension.MyExt2"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "MyExt2{"; _aidl_os << "a: " << ::android::internal::ToString(a); _aidl_os << ", b: " << ::android::internal::ToString(b); _aidl_os << ", c: " << ::android::internal::ToString(c); _aidl_os << "}"; return _aidl_os.str(); } }; // class MyExt2 } // namespace extension } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000224 15172120304 033247 xustar000000000 0000000 120 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/MyExtLike.h 28 mtime=1776853188.6120000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/extension/M0100644 0000000 0000000 00000004352 15172120304 033065 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/extension/MyExtLike.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExtLike.aidl */ #pragma once #include #include #include #include #include #include namespace android { namespace aidl { namespace tests { namespace extension { class MyExtLike : public ::android::Parcelable { public: int32_t a = 0; ::android::String16 b; inline bool operator==(const MyExtLike& _rhs) const { return std::tie(a, b) == std::tie(_rhs.a, _rhs.b); } inline bool operator<(const MyExtLike& _rhs) const { return std::tie(a, b) < std::tie(_rhs.a, _rhs.b); } inline bool operator!=(const MyExtLike& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyExtLike& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyExtLike& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyExtLike& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.extension.MyExtLike"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "MyExtLike{"; _aidl_os << "a: " << ::android::internal::ToString(a); _aidl_os << ", b: " << ::android::internal::ToString(b); _aidl_os << "}"; return _aidl_os.str(); } }; // class MyExtLike } // namespace extension } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000034 15172120304 033246 xustar000000000 0000000 28 mtime=1776853188.6120000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/0040755 0000000 0000000 00000000000 15172120304 032213 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000226 15172120304 033251 xustar000000000 0000000 122 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/BnDeeplyNested.h 28 mtime=1776853188.6120000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/BnDe0100644 0000000 0000000 00000001236 15172120304 032745 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/nested/DeeplyNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/DeeplyNested.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000227 15172120304 033252 xustar000000000 0000000 123 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/BnNestedService.h 28 mtime=1776853188.6130000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/BnNe0100644 0000000 0000000 00000005064 15172120304 032762 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/nested/INestedService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/INestedService.aidl */ #pragma once #include #include #include #include #include namespace android { namespace aidl { namespace tests { namespace nested { class BnNestedService : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_flipStatus = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_flipStatusWithCallback = ::android::IBinder::FIRST_CALL_TRANSACTION + 1; explicit BnNestedService(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnNestedService class INestedServiceDelegator : public BnNestedService { public: explicit INestedServiceDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status flipStatus(const ::android::aidl::tests::nested::ParcelableWithNested& p, ::android::aidl::tests::nested::INestedService::Result* _aidl_return) override { return _aidl_delegate->flipStatus(p, _aidl_return); } ::android::binder::Status flipStatusWithCallback(::android::aidl::tests::nested::ParcelableWithNested::Status status, const ::android::sp<::android::aidl::tests::nested::INestedService::ICallback>& cb) override { ::android::sp<::android::aidl::tests::nested::INestedService::ICallbackDelegator> _cb; if (cb) { _cb = ::android::sp<::android::aidl::tests::nested::INestedService::ICallbackDelegator>::cast(delegate(cb)); } return _aidl_delegate->flipStatusWithCallback(status, _cb); } private: ::android::sp _aidl_delegate; }; // class INestedServiceDelegator } // namespace nested } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000236 15172120304 033252 xustar000000000 0000000 130 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/BnParcelableWithNested.h 28 mtime=1776853188.6130000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/BnPa0100644 0000000 0000000 00000001256 15172120304 032757 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/nested/ParcelableWithNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000226 15172120304 033251 xustar000000000 0000000 122 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/BpDeeplyNested.h 28 mtime=1776853188.6130000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/BpDe0100644 0000000 0000000 00000001236 15172120304 032747 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/nested/DeeplyNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/DeeplyNested.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000227 15172120304 033252 xustar000000000 0000000 123 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/BpNestedService.h 28 mtime=1776853188.6130000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/BpNe0100644 0000000 0000000 00000003027 15172120304 032761 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/nested/INestedService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/INestedService.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace tests { namespace nested { class BpNestedService : public ::android::BpInterface { public: explicit BpNestedService(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpNestedService() = default; ::android::binder::Status flipStatus(const ::android::aidl::tests::nested::ParcelableWithNested& p, ::android::aidl::tests::nested::INestedService::Result* _aidl_return) override; ::android::binder::Status flipStatusWithCallback(::android::aidl::tests::nested::ParcelableWithNested::Status status, const ::android::sp<::android::aidl::tests::nested::INestedService::ICallback>& cb) override; }; // class BpNestedService } // namespace nested } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000236 15172120304 033252 xustar000000000 0000000 130 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/BpParcelableWithNested.h 28 mtime=1776853188.6130000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/BpPa0100644 0000000 0000000 00000001256 15172120304 032761 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/nested/ParcelableWithNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000224 15172120304 033247 xustar000000000 0000000 120 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/DeeplyNested.h 28 mtime=1776853188.6130000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/Deep0100644 0000000 0000000 00000017463 15172120304 033023 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/nested/DeeplyNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/DeeplyNested.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include namespace android { namespace aidl { namespace tests { namespace nested { class DeeplyNested : public ::android::Parcelable { public: class B : public ::android::Parcelable { public: class C : public ::android::Parcelable { public: class D : public ::android::Parcelable { public: enum class E : int8_t { OK = 0, }; inline bool operator==(const D&) const { return std::tie() == std::tie(); } inline bool operator<(const D&) const { return std::tie() < std::tie(); } inline bool operator!=(const D& _rhs) const { return !(*this == _rhs); } inline bool operator>(const D& _rhs) const { return _rhs < *this; } inline bool operator>=(const D& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const D& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.nested.DeeplyNested.B.C.D"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "D{"; _aidl_os << "}"; return _aidl_os.str(); } }; // class D inline bool operator==(const C&) const { return std::tie() == std::tie(); } inline bool operator<(const C&) const { return std::tie() < std::tie(); } inline bool operator!=(const C& _rhs) const { return !(*this == _rhs); } inline bool operator>(const C& _rhs) const { return _rhs < *this; } inline bool operator>=(const C& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const C& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.nested.DeeplyNested.B.C"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "C{"; _aidl_os << "}"; return _aidl_os.str(); } }; // class C inline bool operator==(const B&) const { return std::tie() == std::tie(); } inline bool operator<(const B&) const { return std::tie() < std::tie(); } inline bool operator!=(const B& _rhs) const { return !(*this == _rhs); } inline bool operator>(const B& _rhs) const { return _rhs < *this; } inline bool operator>=(const B& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const B& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.nested.DeeplyNested.B"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "B{"; _aidl_os << "}"; return _aidl_os.str(); } }; // class B class A : public ::android::Parcelable { public: ::android::aidl::tests::nested::DeeplyNested::B::C::D::E e = ::android::aidl::tests::nested::DeeplyNested::B::C::D::E::OK; inline bool operator==(const A& _rhs) const { return std::tie(e) == std::tie(_rhs.e); } inline bool operator<(const A& _rhs) const { return std::tie(e) < std::tie(_rhs.e); } inline bool operator!=(const A& _rhs) const { return !(*this == _rhs); } inline bool operator>(const A& _rhs) const { return _rhs < *this; } inline bool operator>=(const A& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const A& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.nested.DeeplyNested.A"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "A{"; _aidl_os << "e: " << ::android::internal::ToString(e); _aidl_os << "}"; return _aidl_os.str(); } }; // class A inline bool operator==(const DeeplyNested&) const { return std::tie() == std::tie(); } inline bool operator<(const DeeplyNested&) const { return std::tie() < std::tie(); } inline bool operator!=(const DeeplyNested& _rhs) const { return !(*this == _rhs); } inline bool operator>(const DeeplyNested& _rhs) const { return _rhs < *this; } inline bool operator>=(const DeeplyNested& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const DeeplyNested& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.nested.DeeplyNested"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "DeeplyNested{"; _aidl_os << "}"; return _aidl_os.str(); } }; // class DeeplyNested } // namespace nested } // namespace tests } // namespace aidl } // namespace android namespace android { namespace aidl { namespace tests { namespace nested { [[nodiscard]] static inline std::string toString(DeeplyNested::B::C::D::E val) { switch(val) { case DeeplyNested::B::C::D::E::OK: return "OK"; default: return std::to_string(static_cast(val)); } } } // namespace nested } // namespace tests } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::tests::nested::DeeplyNested::B::C::D::E, 1> enum_values<::android::aidl::tests::nested::DeeplyNested::B::C::D::E> = { ::android::aidl::tests::nested::DeeplyNested::B::C::D::E::OK, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000226 15172120304 033251 xustar000000000 0000000 122 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/INestedService.h 28 mtime=1776853188.6130000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/INes0100644 0000000 0000000 00000013537 15172120304 033002 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/nested/INestedService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/INestedService.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include namespace android::aidl::tests::nested { class ParcelableWithNested; } // namespace android::aidl::tests::nested namespace android { namespace aidl { namespace tests { namespace nested { class INestedServiceDelegator; class INestedService : public ::android::IInterface { public: typedef INestedServiceDelegator DefaultDelegator; DECLARE_META_INTERFACE(NestedService) class Result : public ::android::Parcelable { public: ::android::aidl::tests::nested::ParcelableWithNested::Status status = ::android::aidl::tests::nested::ParcelableWithNested::Status::OK; inline bool operator==(const Result& _rhs) const { return std::tie(status) == std::tie(_rhs.status); } inline bool operator<(const Result& _rhs) const { return std::tie(status) < std::tie(_rhs.status); } inline bool operator!=(const Result& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Result& _rhs) const { return _rhs < *this; } inline bool operator>=(const Result& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Result& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.nested.INestedService.Result"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "Result{"; _aidl_os << "status: " << ::android::internal::ToString(status); _aidl_os << "}"; return _aidl_os.str(); } }; // class Result class ICallbackDelegator; class ICallback : public ::android::IInterface { public: typedef ICallbackDelegator DefaultDelegator; DECLARE_META_INTERFACE(Callback) virtual ::android::binder::Status done(::android::aidl::tests::nested::ParcelableWithNested::Status status) = 0; }; // class ICallback class ICallbackDefault : public ICallback { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status done(::android::aidl::tests::nested::ParcelableWithNested::Status /*status*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } }; // class ICallbackDefault class BpCallback : public ::android::BpInterface { public: explicit BpCallback(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpCallback() = default; ::android::binder::Status done(::android::aidl::tests::nested::ParcelableWithNested::Status status) override; }; // class BpCallback class BnCallback : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_done = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; explicit BnCallback(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; }; // class BnCallback class ICallbackDelegator : public BnCallback { public: explicit ICallbackDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status done(::android::aidl::tests::nested::ParcelableWithNested::Status status) override { return _aidl_delegate->done(status); } private: ::android::sp _aidl_delegate; }; // class ICallbackDelegator virtual ::android::binder::Status flipStatus(const ::android::aidl::tests::nested::ParcelableWithNested& p, ::android::aidl::tests::nested::INestedService::Result* _aidl_return) = 0; virtual ::android::binder::Status flipStatusWithCallback(::android::aidl::tests::nested::ParcelableWithNested::Status status, const ::android::sp<::android::aidl::tests::nested::INestedService::ICallback>& cb) = 0; }; // class INestedService class INestedServiceDefault : public INestedService { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status flipStatus(const ::android::aidl::tests::nested::ParcelableWithNested& /*p*/, ::android::aidl::tests::nested::INestedService::Result* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status flipStatusWithCallback(::android::aidl::tests::nested::ParcelableWithNested::Status /*status*/, const ::android::sp<::android::aidl::tests::nested::INestedService::ICallback>& /*cb*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } }; // class INestedServiceDefault } // namespace nested } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000234 15172120304 033250 xustar000000000 0000000 128 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/ParcelableWithNested.h 28 mtime=1776853188.6130000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/nested/Parc0100644 0000000 0000000 00000007037 15172120304 033027 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/nested/ParcelableWithNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include namespace android { namespace aidl { namespace tests { namespace nested { class ParcelableWithNested : public ::android::Parcelable { public: enum class Status : int8_t { OK = 0, NOT_OK = 1, }; ::android::aidl::tests::nested::ParcelableWithNested::Status status = ::android::aidl::tests::nested::ParcelableWithNested::Status::OK; inline bool operator==(const ParcelableWithNested& _rhs) const { return std::tie(status) == std::tie(_rhs.status); } inline bool operator<(const ParcelableWithNested& _rhs) const { return std::tie(status) < std::tie(_rhs.status); } inline bool operator!=(const ParcelableWithNested& _rhs) const { return !(*this == _rhs); } inline bool operator>(const ParcelableWithNested& _rhs) const { return _rhs < *this; } inline bool operator>=(const ParcelableWithNested& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const ParcelableWithNested& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.nested.ParcelableWithNested"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "ParcelableWithNested{"; _aidl_os << "status: " << ::android::internal::ToString(status); _aidl_os << "}"; return _aidl_os.str(); } }; // class ParcelableWithNested } // namespace nested } // namespace tests } // namespace aidl } // namespace android namespace android { namespace aidl { namespace tests { namespace nested { [[nodiscard]] static inline std::string toString(ParcelableWithNested::Status val) { switch(val) { case ParcelableWithNested::Status::OK: return "OK"; case ParcelableWithNested::Status::NOT_OK: return "NOT_OK"; default: return std::to_string(static_cast(val)); } } } // namespace nested } // namespace tests } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::tests::nested::ParcelableWithNested::Status, 2> enum_values<::android::aidl::tests::nested::ParcelableWithNested::Status> = { ::android::aidl::tests::nested::ParcelableWithNested::Status::OK, ::android::aidl::tests::nested::ParcelableWithNested::Status::NOT_OK, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000034 15172120304 033246 xustar000000000 0000000 28 mtime=1776853188.6130000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/unions/0040755 0000000 0000000 00000000000 15172120304 032244 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000223 15172120304 033246 xustar000000000 0000000 119 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/unions/BnEnumUnion.h 28 mtime=1776853188.6130000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/unions/BnEn0100644 0000000 0000000 00000001230 15172120304 033002 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/unions/EnumUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000226 15172120304 033251 xustar000000000 0000000 122 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/unions/BnUnionInUnion.h 28 mtime=1776853188.6130000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/unions/BnUn0100644 0000000 0000000 00000001236 15172120304 033030 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/unions/UnionInUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/UnionInUnion.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000223 15172120304 033246 xustar000000000 0000000 119 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/unions/BpEnumUnion.h 28 mtime=1776853188.6140000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/unions/BpEn0100644 0000000 0000000 00000001230 15172120304 033004 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/unions/EnumUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000226 15172120304 033251 xustar000000000 0000000 122 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/unions/BpUnionInUnion.h 28 mtime=1776853188.6140000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/unions/BpUn0100644 0000000 0000000 00000001236 15172120304 033032 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/unions/UnionInUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/UnionInUnion.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000221 15172120304 033244 xustar000000000 0000000 117 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/unions/EnumUnion.h 28 mtime=1776853188.6140000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/unions/Enum0100644 0000000 0000000 00000014161 15172120304 033073 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/unions/EnumUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace android { namespace aidl { namespace tests { namespace unions { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" class EnumUnion : public ::android::Parcelable { public: enum class Tag : int32_t { intEnum = 0, longEnum = 1, deprecatedField __attribute__((deprecated("do not use this"))) = 2, }; // Expose tag symbols for legacy code static const inline Tag intEnum = Tag::intEnum; static const inline Tag longEnum = Tag::longEnum; static const inline Tag __attribute__((deprecated("do not use this"))) deprecatedField = Tag::deprecatedField; template static constexpr bool _not_self = !std::is_same_v>, EnumUnion>; EnumUnion() : _value(std::in_place_index(intEnum)>, ::android::aidl::tests::IntEnum(::android::aidl::tests::IntEnum::FOO)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr EnumUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit EnumUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static EnumUnion make(_Tp&&... _args) { return EnumUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static EnumUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return EnumUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } inline bool operator==(const EnumUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const EnumUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const EnumUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const EnumUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const EnumUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const EnumUnion& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.unions.EnumUnion"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream os; os << "EnumUnion{"; switch (getTag()) { case intEnum: os << "intEnum: " << ::android::internal::ToString(get()); break; case longEnum: os << "longEnum: " << ::android::internal::ToString(get()); break; case deprecatedField: os << "deprecatedField: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant<::android::aidl::tests::IntEnum, ::android::aidl::tests::LongEnum, int32_t> _value; }; // class EnumUnion #pragma clang diagnostic pop } // namespace unions } // namespace tests } // namespace aidl } // namespace android namespace android { namespace aidl { namespace tests { namespace unions { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" [[nodiscard]] static inline std::string toString(EnumUnion::Tag val) { switch(val) { case EnumUnion::Tag::intEnum: return "intEnum"; case EnumUnion::Tag::longEnum: return "longEnum"; case EnumUnion::Tag::deprecatedField: return "deprecatedField"; default: return std::to_string(static_cast(val)); } } #pragma clang diagnostic pop } // namespace unions } // namespace tests } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" #pragma clang diagnostic ignored "-Wdeprecated-declarations" template <> constexpr inline std::array<::android::aidl::tests::unions::EnumUnion::Tag, 3> enum_values<::android::aidl::tests::unions::EnumUnion::Tag> = { ::android::aidl::tests::unions::EnumUnion::Tag::intEnum, ::android::aidl::tests::unions::EnumUnion::Tag::longEnum, ::android::aidl::tests::unions::EnumUnion::Tag::deprecatedField, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_include_android_aidl_t0100644 0000000 0000000 00000000224 15172120304 033247 xustar000000000 0000000 120 path=tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/unions/UnionInUnion.h 28 mtime=1776853188.6140000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/include/android/aidl/tests/unions/Unio0100644 0000000 0000000 00000012546 15172120304 033106 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging/android/aidl/tests/unions/UnionInUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/UnionInUnion.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace android { namespace aidl { namespace tests { namespace unions { class UnionInUnion : public ::android::Parcelable { public: enum class Tag : int32_t { first = 0, second = 1, }; // Expose tag symbols for legacy code static const inline Tag first = Tag::first; static const inline Tag second = Tag::second; template static constexpr bool _not_self = !std::is_same_v>, UnionInUnion>; UnionInUnion() : _value(std::in_place_index(first)>, ::android::aidl::tests::unions::EnumUnion()) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr UnionInUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit UnionInUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static UnionInUnion make(_Tp&&... _args) { return UnionInUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static UnionInUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return UnionInUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } inline bool operator==(const UnionInUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const UnionInUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const UnionInUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const UnionInUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const UnionInUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const UnionInUnion& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.tests.unions.UnionInUnion"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream os; os << "UnionInUnion{"; switch (getTag()) { case first: os << "first: " << ::android::internal::ToString(get()); break; case second: os << "second: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant<::android::aidl::tests::unions::EnumUnion, int32_t> _value; }; // class UnionInUnion } // namespace unions } // namespace tests } // namespace aidl } // namespace android namespace android { namespace aidl { namespace tests { namespace unions { [[nodiscard]] static inline std::string toString(UnionInUnion::Tag val) { switch(val) { case UnionInUnion::Tag::first: return "first"; case UnionInUnion::Tag::second: return "second"; default: return std::to_string(static_cast(val)); } } } // namespace unions } // namespace tests } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::tests::unions::UnionInUnion::Tag, 2> enum_values<::android::aidl::tests::unions::UnionInUnion::Tag> = { ::android::aidl::tests::unions::UnionInUnion::Tag::first, ::android::aidl::tests::unions::UnionInUnion::Tag::second, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-cpp-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 030612 xustar000000000 0000000 28 mtime=1776853188.6140000 tests/golden_output/frozen/aidl-test-interface-cpp-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 025524 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_0100644 0000000 0000000 00000000034 15172120304 026174 xustar000000000 0000000 28 mtime=1776853188.6140000 tests/golden_output/frozen/aidl-test-interface-java-source/0040755 0000000 0000000 00000000000 15172120304 023201 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_0100644 0000000 0000000 00000000034 15172120304 027025 xustar000000000 0000000 28 mtime=1776853188.6140000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/0040755 0000000 0000000 00000000000 15172120304 023752 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 030525 xustar000000000 0000000 28 mtime=1776853188.6140000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 025372 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 031516 xustar000000000 0000000 28 mtime=1776853188.6140000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 026303 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_0100644 0000000 0000000 00000000034 15172120304 032740 xustar000000000 0000000 28 mtime=1776853188.6140000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/0040755 0000000 0000000 00000000000 15172120304 027445 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_Ar0100644 0000000 0000000 00000000216 15172120304 033225 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/ArrayOfInterfaces.java 28 mtime=1776853188.6140000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/ArrayOfInterfaces.0100644 0000000 0000000 00000066041 15172120304 033021 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/ArrayOfInterfaces.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ArrayOfInterfaces.aidl */ package android.aidl.tests; public class ArrayOfInterfaces implements android.os.Parcelable { public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public ArrayOfInterfaces createFromParcel(android.os.Parcel _aidl_source) { ArrayOfInterfaces _aidl_out = new ArrayOfInterfaces(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public ArrayOfInterfaces[] newArray(int _aidl_size) { return new ArrayOfInterfaces[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } public interface IEmptyInterface extends android.os.IInterface { /** Default implementation for IEmptyInterface. */ public static class Default implements android.aidl.tests.ArrayOfInterfaces.IEmptyInterface { @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.ArrayOfInterfaces.IEmptyInterface { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.ArrayOfInterfaces.IEmptyInterface interface, * generating a proxy if needed. */ public static android.aidl.tests.ArrayOfInterfaces.IEmptyInterface asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.ArrayOfInterfaces.IEmptyInterface))) { return ((android.aidl.tests.ArrayOfInterfaces.IEmptyInterface)iin); } return new android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { default: { return super.onTransact(code, data, reply, flags); } } } private static class Proxy implements android.aidl.tests.ArrayOfInterfaces.IEmptyInterface { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } } /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.ArrayOfInterfaces.IEmptyInterface"; } public interface IMyInterface extends android.os.IInterface { /** Default implementation for IMyInterface. */ public static class Default implements android.aidl.tests.ArrayOfInterfaces.IMyInterface { @Override public android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] methodWithInterfaces(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface iface, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface nullable_iface, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] iface_array_in, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] iface_array_out, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] iface_array_inout, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] nullable_iface_array_in, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] nullable_iface_array_out, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] nullable_iface_array_inout) throws android.os.RemoteException { return null; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.ArrayOfInterfaces.IMyInterface { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.ArrayOfInterfaces.IMyInterface interface, * generating a proxy if needed. */ public static android.aidl.tests.ArrayOfInterfaces.IMyInterface asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.ArrayOfInterfaces.IMyInterface))) { return ((android.aidl.tests.ArrayOfInterfaces.IMyInterface)iin); } return new android.aidl.tests.ArrayOfInterfaces.IMyInterface.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_methodWithInterfaces: { return "methodWithInterfaces"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_methodWithInterfaces: { android.aidl.tests.ArrayOfInterfaces.IEmptyInterface _arg0; _arg0 = android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub.asInterface(data.readStrongBinder()); android.aidl.tests.ArrayOfInterfaces.IEmptyInterface _arg1; _arg1 = android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub.asInterface(data.readStrongBinder()); android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] _arg2; _arg2 = data.createInterfaceArray(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[]::new, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub::asInterface); android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] _arg3; int _arg3_length = data.readInt(); if (_arg3_length < 0) { _arg3 = null; } else { _arg3 = new android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[_arg3_length]; } android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] _arg4; _arg4 = data.createInterfaceArray(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[]::new, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub::asInterface); android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] _arg5; _arg5 = data.createInterfaceArray(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[]::new, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub::asInterface); android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] _arg6; int _arg6_length = data.readInt(); if (_arg6_length < 0) { _arg6 = null; } else { _arg6 = new android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[_arg6_length]; } android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] _arg7; _arg7 = data.createInterfaceArray(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[]::new, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub::asInterface); data.enforceNoDataAvail(); android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] _result = this.methodWithInterfaces(_arg0, _arg1, _arg2, _arg3, _arg4, _arg5, _arg6, _arg7); reply.writeNoException(); reply.writeInterfaceArray(_result); reply.writeInterfaceArray(_arg3); reply.writeInterfaceArray(_arg4); reply.writeInterfaceArray(_arg6); reply.writeInterfaceArray(_arg7); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.ArrayOfInterfaces.IMyInterface { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] methodWithInterfaces(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface iface, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface nullable_iface, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] iface_array_in, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] iface_array_out, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] iface_array_inout, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] nullable_iface_array_in, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] nullable_iface_array_out, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] nullable_iface_array_inout) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeStrongInterface(iface); _data.writeStrongInterface(nullable_iface); _data.writeInterfaceArray(iface_array_in); _data.writeInt(iface_array_out.length); _data.writeInterfaceArray(iface_array_inout); _data.writeInterfaceArray(nullable_iface_array_in); _data.writeInt(nullable_iface_array_out.length); _data.writeInterfaceArray(nullable_iface_array_inout); boolean _status = mRemote.transact(Stub.TRANSACTION_methodWithInterfaces, _data, _reply, 0); _reply.readException(); _result = _reply.createInterfaceArray(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[]::new, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub::asInterface); _reply.readInterfaceArray(iface_array_out, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub::asInterface); _reply.readInterfaceArray(iface_array_inout, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub::asInterface); _reply.readInterfaceArray(nullable_iface_array_out, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub::asInterface); _reply.readInterfaceArray(nullable_iface_array_inout, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub::asInterface); } finally { _reply.recycle(); _data.recycle(); } return _result; } } static final int TRANSACTION_methodWithInterfaces = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.ArrayOfInterfaces.IMyInterface"; public android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] methodWithInterfaces(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface iface, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface nullable_iface, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] iface_array_in, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] iface_array_out, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] iface_array_inout, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] nullable_iface_array_in, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] nullable_iface_array_out, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] nullable_iface_array_inout) throws android.os.RemoteException; } public static class MyParcelable implements android.os.Parcelable { public android.aidl.tests.ArrayOfInterfaces.IEmptyInterface iface; public android.aidl.tests.ArrayOfInterfaces.IEmptyInterface nullable_iface; public android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] iface_array; public android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] nullable_iface_array; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public MyParcelable createFromParcel(android.os.Parcel _aidl_source) { MyParcelable _aidl_out = new MyParcelable(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public MyParcelable[] newArray(int _aidl_size) { return new MyParcelable[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeStrongInterface(iface); _aidl_parcel.writeStrongInterface(nullable_iface); _aidl_parcel.writeInterfaceArray(iface_array); _aidl_parcel.writeInterfaceArray(nullable_iface_array); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; iface = android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub.asInterface(_aidl_parcel.readStrongBinder()); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; nullable_iface = android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub.asInterface(_aidl_parcel.readStrongBinder()); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; iface_array = _aidl_parcel.createInterfaceArray(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[]::new, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub::asInterface); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; nullable_iface_array = _aidl_parcel.createInterfaceArray(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[]::new, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub::asInterface); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public String toString() { java.util.StringJoiner _aidl_sj = new java.util.StringJoiner(", ", "{", "}"); _aidl_sj.add("iface: " + (java.util.Objects.toString(iface))); _aidl_sj.add("nullable_iface: " + (java.util.Objects.toString(nullable_iface))); _aidl_sj.add("iface_array: " + (java.util.Arrays.toString(iface_array))); _aidl_sj.add("nullable_iface_array: " + (java.util.Arrays.toString(nullable_iface_array))); return "MyParcelable" + _aidl_sj.toString() ; } @Override public boolean equals(Object other) { if (this == other) return true; if (other == null) return false; if (!(other instanceof MyParcelable)) return false; MyParcelable that = (MyParcelable)other; if (!java.util.Objects.deepEquals(iface, that.iface)) return false; if (!java.util.Objects.deepEquals(nullable_iface, that.nullable_iface)) return false; if (!java.util.Objects.deepEquals(iface_array, that.iface_array)) return false; if (!java.util.Objects.deepEquals(nullable_iface_array, that.nullable_iface_array)) return false; return true; } @Override public int hashCode() { return java.util.Arrays.deepHashCode(java.util.Arrays.asList(iface, nullable_iface, iface_array, nullable_iface_array).toArray()); } @Override public int describeContents() { int _mask = 0; return _mask; } } public static final class MyUnion implements android.os.Parcelable { // tags for union fields public final static int iface = 0; // android.aidl.tests.ArrayOfInterfaces.IEmptyInterface iface; public final static int nullable_iface = 1; // android.aidl.tests.ArrayOfInterfaces.IEmptyInterface nullable_iface; public final static int iface_array = 2; // android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] iface_array; public final static int nullable_iface_array = 3; // android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] nullable_iface_array; private int _tag; private Object _value; public MyUnion() { android.aidl.tests.ArrayOfInterfaces.IEmptyInterface _value = null; this._tag = iface; this._value = _value; } private MyUnion(android.os.Parcel _aidl_parcel) { readFromParcel(_aidl_parcel); } private MyUnion(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public int getTag() { return _tag; } // android.aidl.tests.ArrayOfInterfaces.IEmptyInterface iface; public static MyUnion iface(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface _value) { return new MyUnion(iface, _value); } public android.aidl.tests.ArrayOfInterfaces.IEmptyInterface getIface() { _assertTag(iface); return (android.aidl.tests.ArrayOfInterfaces.IEmptyInterface) _value; } public void setIface(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface _value) { _set(iface, _value); } // android.aidl.tests.ArrayOfInterfaces.IEmptyInterface nullable_iface; public static MyUnion nullable_iface(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface _value) { return new MyUnion(nullable_iface, _value); } public android.aidl.tests.ArrayOfInterfaces.IEmptyInterface getNullable_iface() { _assertTag(nullable_iface); return (android.aidl.tests.ArrayOfInterfaces.IEmptyInterface) _value; } public void setNullable_iface(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface _value) { _set(nullable_iface, _value); } // android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] iface_array; public static MyUnion iface_array(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] _value) { return new MyUnion(iface_array, _value); } public android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] getIface_array() { _assertTag(iface_array); return (android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[]) _value; } public void setIface_array(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] _value) { _set(iface_array, _value); } // android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] nullable_iface_array; public static MyUnion nullable_iface_array(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] _value) { return new MyUnion(nullable_iface_array, _value); } public android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] getNullable_iface_array() { _assertTag(nullable_iface_array); return (android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[]) _value; } public void setNullable_iface_array(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] _value) { _set(nullable_iface_array, _value); } public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public MyUnion createFromParcel(android.os.Parcel _aidl_source) { return new MyUnion(_aidl_source); } @Override public MyUnion[] newArray(int _aidl_size) { return new MyUnion[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { _aidl_parcel.writeInt(_tag); switch (_tag) { case iface: _aidl_parcel.writeStrongInterface(getIface()); break; case nullable_iface: _aidl_parcel.writeStrongInterface(getNullable_iface()); break; case iface_array: _aidl_parcel.writeInterfaceArray(getIface_array()); break; case nullable_iface_array: _aidl_parcel.writeInterfaceArray(getNullable_iface_array()); break; } } public void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_tag; _aidl_tag = _aidl_parcel.readInt(); switch (_aidl_tag) { case iface: { android.aidl.tests.ArrayOfInterfaces.IEmptyInterface _aidl_value; _aidl_value = android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub.asInterface(_aidl_parcel.readStrongBinder()); _set(_aidl_tag, _aidl_value); return; } case nullable_iface: { android.aidl.tests.ArrayOfInterfaces.IEmptyInterface _aidl_value; _aidl_value = android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub.asInterface(_aidl_parcel.readStrongBinder()); _set(_aidl_tag, _aidl_value); return; } case iface_array: { android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] _aidl_value; _aidl_value = _aidl_parcel.createInterfaceArray(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[]::new, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub::asInterface); _set(_aidl_tag, _aidl_value); return; } case nullable_iface_array: { android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[] _aidl_value; _aidl_value = _aidl_parcel.createInterfaceArray(android.aidl.tests.ArrayOfInterfaces.IEmptyInterface[]::new, android.aidl.tests.ArrayOfInterfaces.IEmptyInterface.Stub::asInterface); _set(_aidl_tag, _aidl_value); return; } } throw new IllegalArgumentException("union: unknown tag: " + _aidl_tag); } @Override public int describeContents() { int _mask = 0; switch (getTag()) { } return _mask; } @Override public String toString() { switch (_tag) { case iface: return "MyUnion.iface(" + (java.util.Objects.toString(getIface())) + ")"; case nullable_iface: return "MyUnion.nullable_iface(" + (java.util.Objects.toString(getNullable_iface())) + ")"; case iface_array: return "MyUnion.iface_array(" + (java.util.Arrays.toString(getIface_array())) + ")"; case nullable_iface_array: return "MyUnion.nullable_iface_array(" + (java.util.Arrays.toString(getNullable_iface_array())) + ")"; } throw new IllegalStateException("unknown field: " + _tag); } @Override public boolean equals(Object other) { if (this == other) return true; if (other == null) return false; if (!(other instanceof MyUnion)) return false; MyUnion that = (MyUnion)other; if (_tag != that._tag) return false; if (!java.util.Objects.deepEquals(_value, that._value)) return false; return true; } @Override public int hashCode() { return java.util.Arrays.deepHashCode(java.util.Arrays.asList(_tag, _value).toArray()); } private void _assertTag(int tag) { if (getTag() != tag) { throw new IllegalStateException("bad access: " + _tagString(tag) + ", " + _tagString(getTag()) + " is available."); } } private String _tagString(int _tag) { switch (_tag) { case iface: return "iface"; case nullable_iface: return "nullable_iface"; case iface_array: return "iface_array"; case nullable_iface_array: return "nullable_iface_array"; } throw new IllegalStateException("unknown field: " + _tag); } private void _set(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public static @interface Tag { public static final int iface = 0; public static final int nullable_iface = 1; public static final int iface_array = 2; public static final int nullable_iface_array = 3; } } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_Ar0100644 0000000 0000000 00000000220 15172120304 033220 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/ArrayOfInterfaces.java.d 28 mtime=1776853188.6150000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/ArrayOfInterfaces.0100644 0000000 0000000 00000000301 15172120304 033004 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/ArrayOfInterfaces.java : \ system/tools/aidl/tests/android/aidl/tests/ArrayOfInterfaces.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_Ba0100644 0000000 0000000 00000000034 15172120304 033203 xustar000000000 0000000 28 mtime=1776853188.6150000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/BackendType.java0100644 0000000 0000000 00000001274 15172120304 032502 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/BackendType.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/BackendType.aidl */ package android.aidl.tests; public @interface BackendType { public static final byte CPP = 0; public static final byte JAVA = 1; public static final byte NDK = 2; public static final byte RUST = 3; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_Ba0100644 0000000 0000000 00000000212 15172120304 033201 xustar000000000 0000000 110 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/BackendType.java.d 28 mtime=1776853188.6150000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/BackendType.java.d0100644 0000000 0000000 00000000265 15172120304 032723 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/BackendType.java : \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_By0100644 0000000 0000000 00000000034 15172120304 033233 xustar000000000 0000000 28 mtime=1776853188.6150000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/ByteEnum.java0100644 0000000 0000000 00000001272 15172120304 032037 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/ByteEnum.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl */ package android.aidl.tests; /** Hello, world! */ public @interface ByteEnum { // Comment about FOO. public static final byte FOO = 1; public static final byte BAR = 2; public static final byte BAZ = 3; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_By0100644 0000000 0000000 00000000034 15172120304 033233 xustar000000000 0000000 28 mtime=1776853188.6150000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/ByteEnum.java.d0100644 0000000 0000000 00000000257 15172120304 032263 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/ByteEnum.java : \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_Ci0100644 0000000 0000000 00000000217 15172120304 033217 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/CircularParcelable.java 28 mtime=1776853188.6150000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/CircularParcelable0100644 0000000 0000000 00000004646 15172120304 033116 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/CircularParcelable.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl */ package android.aidl.tests; public class CircularParcelable implements android.os.Parcelable { public android.aidl.tests.ITestService testService; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public CircularParcelable createFromParcel(android.os.Parcel _aidl_source) { CircularParcelable _aidl_out = new CircularParcelable(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public CircularParcelable[] newArray(int _aidl_size) { return new CircularParcelable[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeStrongInterface(testService); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; testService = android.aidl.tests.ITestService.Stub.asInterface(_aidl_parcel.readStrongBinder()); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_Ci0100644 0000000 0000000 00000000221 15172120304 033212 xustar000000000 0000000 117 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/CircularParcelable.java.d 28 mtime=1776853188.6150000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/CircularParcelable0100644 0000000 0000000 00000002235 15172120304 033106 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/CircularParcelable.java : \ system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ITestService.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl \ system/tools/aidl/tests/android/aidl/tests/SimpleParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl \ system/tools/aidl/tests/android/aidl/tests/ICircular.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_Co0100644 0000000 0000000 00000000223 15172120304 033222 xustar000000000 0000000 119 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/ConstantExpressionEnum.java 28 mtime=1776853188.6160000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/ConstantExpression0100644 0000000 0000000 00000002467 15172120304 033247 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/ConstantExpressionEnum.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl */ package android.aidl.tests; public @interface ConstantExpressionEnum { // Should be all true / ones. // dec literals are either int or long public static final int decInt32_1 = 1; public static final int decInt32_2 = 1; public static final int decInt64_1 = 1; public static final int decInt64_2 = 1; public static final int decInt64_3 = 1; public static final int decInt64_4 = 1; // hex literals could be int or long // 0x7fffffff is int, hence can be negated public static final int hexInt32_1 = 1; // 0x80000000 is int32_t max + 1 public static final int hexInt32_2 = 1; // 0xFFFFFFFF is int32_t, not long; if it were long then ~(long)0xFFFFFFFF != 0 public static final int hexInt32_3 = 1; // 0x7FFFFFFFFFFFFFFF is long, hence can be negated public static final int hexInt64_1 = 1; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_Co0100644 0000000 0000000 00000000225 15172120304 033224 xustar000000000 0000000 121 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/ConstantExpressionEnum.java.d 28 mtime=1776853188.6160000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/ConstantExpression0100644 0000000 0000000 00000000313 15172120304 033233 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/ConstantExpressionEnum.java : \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_De0100644 0000000 0000000 00000000213 15172120304 033210 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/DeprecatedEnum.java 28 mtime=1776853188.6160000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/DeprecatedEnum.jav0100644 0000000 0000000 00000001272 15172120304 033033 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/DeprecatedEnum.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedEnum.aidl */ package android.aidl.tests; /** @deprecated test */ @Deprecated public @interface DeprecatedEnum { public static final int A = 0; public static final int B = 1; public static final int C = 2; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_De0100644 0000000 0000000 00000000215 15172120304 033212 xustar000000000 0000000 113 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/DeprecatedEnum.java.d 28 mtime=1776853188.6160000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/DeprecatedEnum.jav0100644 0000000 0000000 00000000273 15172120304 033033 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/DeprecatedEnum.java : \ system/tools/aidl/tests/android/aidl/tests/DeprecatedEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_De0100644 0000000 0000000 00000000221 15172120304 033207 xustar000000000 0000000 117 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/DeprecatedParcelable.java 28 mtime=1776853188.6160000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/DeprecatedParcelab0100644 0000000 0000000 00000004263 15172120304 033064 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/DeprecatedParcelable.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedParcelable.aidl */ package android.aidl.tests; /** @deprecated test */ @Deprecated public class DeprecatedParcelable implements android.os.Parcelable { public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public DeprecatedParcelable createFromParcel(android.os.Parcel _aidl_source) { DeprecatedParcelable _aidl_out = new DeprecatedParcelable(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public DeprecatedParcelable[] newArray(int _aidl_size) { return new DeprecatedParcelable[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_De0100644 0000000 0000000 00000000223 15172120304 033211 xustar000000000 0000000 119 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/DeprecatedParcelable.java.d 28 mtime=1776853188.6160000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/DeprecatedParcelab0100644 0000000 0000000 00000000307 15172120304 033057 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/DeprecatedParcelable.java : \ system/tools/aidl/tests/android/aidl/tests/DeprecatedParcelable.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_Fi0100644 0000000 0000000 00000000034 15172120304 033217 xustar000000000 0000000 28 mtime=1776853188.6160000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/FixedSize.java0100644 0000000 0000000 00000033151 15172120304 032202 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/FixedSize.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/FixedSize.aidl */ package android.aidl.tests; public class FixedSize implements android.os.Parcelable { public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public FixedSize createFromParcel(android.os.Parcel _aidl_source) { FixedSize _aidl_out = new FixedSize(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public FixedSize[] newArray(int _aidl_size) { return new FixedSize[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } public static class FixedParcelable implements android.os.Parcelable { public boolean booleanValue = false; public byte byteValue = 0; public char charValue = '\0'; public int intValue = 0; public long longValue = 0L; public float floatValue = 0.000000f; public double doubleValue = 0.000000; public long enumValue = android.aidl.tests.LongEnum.FOO; public android.aidl.tests.FixedSize.FixedUnion parcelableValue; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public FixedParcelable createFromParcel(android.os.Parcel _aidl_source) { FixedParcelable _aidl_out = new FixedParcelable(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public FixedParcelable[] newArray(int _aidl_size) { return new FixedParcelable[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeBoolean(booleanValue); _aidl_parcel.writeByte(byteValue); _aidl_parcel.writeInt(((int)charValue)); _aidl_parcel.writeInt(intValue); _aidl_parcel.writeLong(longValue); _aidl_parcel.writeFloat(floatValue); _aidl_parcel.writeDouble(doubleValue); _aidl_parcel.writeLong(enumValue); _aidl_parcel.writeTypedObject(parcelableValue, _aidl_flag); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; booleanValue = _aidl_parcel.readBoolean(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; byteValue = _aidl_parcel.readByte(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; charValue = (char)_aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; intValue = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; longValue = _aidl_parcel.readLong(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; floatValue = _aidl_parcel.readFloat(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; doubleValue = _aidl_parcel.readDouble(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; enumValue = _aidl_parcel.readLong(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; parcelableValue = _aidl_parcel.readTypedObject(android.aidl.tests.FixedSize.FixedUnion.CREATOR); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; _mask |= describeContents(parcelableValue); return _mask; } private int describeContents(Object _v) { if (_v == null) return 0; if (_v instanceof android.os.Parcelable) { return ((android.os.Parcelable) _v).describeContents(); } return 0; } } public static final class FixedUnion implements android.os.Parcelable { // tags for union fields public final static int booleanValue = 0; // boolean booleanValue; public final static int byteValue = 1; // byte byteValue; public final static int charValue = 2; // char charValue; public final static int intValue = 3; // int intValue; public final static int longValue = 4; // long longValue; public final static int floatValue = 5; // float floatValue; public final static int doubleValue = 6; // double doubleValue; public final static int enumValue = 7; // android.aidl.tests.LongEnum enumValue; private int _tag; private Object _value; public FixedUnion() { boolean _value = false; this._tag = booleanValue; this._value = _value; } private FixedUnion(android.os.Parcel _aidl_parcel) { readFromParcel(_aidl_parcel); } private FixedUnion(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public int getTag() { return _tag; } // boolean booleanValue; public static FixedUnion booleanValue(boolean _value) { return new FixedUnion(booleanValue, _value); } public boolean getBooleanValue() { _assertTag(booleanValue); return (boolean) _value; } public void setBooleanValue(boolean _value) { _set(booleanValue, _value); } // byte byteValue; public static FixedUnion byteValue(byte _value) { return new FixedUnion(byteValue, _value); } public byte getByteValue() { _assertTag(byteValue); return (byte) _value; } public void setByteValue(byte _value) { _set(byteValue, _value); } // char charValue; public static FixedUnion charValue(char _value) { return new FixedUnion(charValue, _value); } public char getCharValue() { _assertTag(charValue); return (char) _value; } public void setCharValue(char _value) { _set(charValue, _value); } // int intValue; public static FixedUnion intValue(int _value) { return new FixedUnion(intValue, _value); } public int getIntValue() { _assertTag(intValue); return (int) _value; } public void setIntValue(int _value) { _set(intValue, _value); } // long longValue; public static FixedUnion longValue(long _value) { return new FixedUnion(longValue, _value); } public long getLongValue() { _assertTag(longValue); return (long) _value; } public void setLongValue(long _value) { _set(longValue, _value); } // float floatValue; public static FixedUnion floatValue(float _value) { return new FixedUnion(floatValue, _value); } public float getFloatValue() { _assertTag(floatValue); return (float) _value; } public void setFloatValue(float _value) { _set(floatValue, _value); } // double doubleValue; public static FixedUnion doubleValue(double _value) { return new FixedUnion(doubleValue, _value); } public double getDoubleValue() { _assertTag(doubleValue); return (double) _value; } public void setDoubleValue(double _value) { _set(doubleValue, _value); } // android.aidl.tests.LongEnum enumValue; public static FixedUnion enumValue(long _value) { return new FixedUnion(enumValue, _value); } public long getEnumValue() { _assertTag(enumValue); return (long) _value; } public void setEnumValue(long _value) { _set(enumValue, _value); } public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public FixedUnion createFromParcel(android.os.Parcel _aidl_source) { return new FixedUnion(_aidl_source); } @Override public FixedUnion[] newArray(int _aidl_size) { return new FixedUnion[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { _aidl_parcel.writeInt(_tag); switch (_tag) { case booleanValue: _aidl_parcel.writeBoolean(getBooleanValue()); break; case byteValue: _aidl_parcel.writeByte(getByteValue()); break; case charValue: _aidl_parcel.writeInt(((int)getCharValue())); break; case intValue: _aidl_parcel.writeInt(getIntValue()); break; case longValue: _aidl_parcel.writeLong(getLongValue()); break; case floatValue: _aidl_parcel.writeFloat(getFloatValue()); break; case doubleValue: _aidl_parcel.writeDouble(getDoubleValue()); break; case enumValue: _aidl_parcel.writeLong(getEnumValue()); break; } } public void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_tag; _aidl_tag = _aidl_parcel.readInt(); switch (_aidl_tag) { case booleanValue: { boolean _aidl_value; _aidl_value = _aidl_parcel.readBoolean(); _set(_aidl_tag, _aidl_value); return; } case byteValue: { byte _aidl_value; _aidl_value = _aidl_parcel.readByte(); _set(_aidl_tag, _aidl_value); return; } case charValue: { char _aidl_value; _aidl_value = (char)_aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } case intValue: { int _aidl_value; _aidl_value = _aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } case longValue: { long _aidl_value; _aidl_value = _aidl_parcel.readLong(); _set(_aidl_tag, _aidl_value); return; } case floatValue: { float _aidl_value; _aidl_value = _aidl_parcel.readFloat(); _set(_aidl_tag, _aidl_value); return; } case doubleValue: { double _aidl_value; _aidl_value = _aidl_parcel.readDouble(); _set(_aidl_tag, _aidl_value); return; } case enumValue: { long _aidl_value; _aidl_value = _aidl_parcel.readLong(); _set(_aidl_tag, _aidl_value); return; } } throw new IllegalArgumentException("union: unknown tag: " + _aidl_tag); } @Override public int describeContents() { int _mask = 0; switch (getTag()) { } return _mask; } private void _assertTag(int tag) { if (getTag() != tag) { throw new IllegalStateException("bad access: " + _tagString(tag) + ", " + _tagString(getTag()) + " is available."); } } private String _tagString(int _tag) { switch (_tag) { case booleanValue: return "booleanValue"; case byteValue: return "byteValue"; case charValue: return "charValue"; case intValue: return "intValue"; case longValue: return "longValue"; case floatValue: return "floatValue"; case doubleValue: return "doubleValue"; case enumValue: return "enumValue"; } throw new IllegalStateException("unknown field: " + _tag); } private void _set(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public static @interface Tag { public static final byte booleanValue = 0; public static final byte byteValue = 1; public static final byte charValue = 2; public static final byte intValue = 3; public static final byte longValue = 4; public static final byte floatValue = 5; public static final byte doubleValue = 6; public static final byte enumValue = 7; } } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_Fi0100644 0000000 0000000 00000000034 15172120304 033217 xustar000000000 0000000 28 mtime=1776853188.6160000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/FixedSize.java.d0100644 0000000 0000000 00000000356 15172120304 032425 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/FixedSize.java : \ system/tools/aidl/tests/android/aidl/tests/FixedSize.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_Ge0100644 0000000 0000000 00000000230 15172120304 033212 xustar000000000 0000000 124 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/GenericStructuredParcelable.java 28 mtime=1776853188.6160000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/GenericStructuredP0100644 0000000 0000000 00000005467 15172120304 033162 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/GenericStructuredParcelable.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl */ package android.aidl.tests; public class GenericStructuredParcelable implements android.os.Parcelable { public int a = 0; public int b = 0; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public GenericStructuredParcelable createFromParcel(android.os.Parcel _aidl_source) { GenericStructuredParcelable _aidl_out = new GenericStructuredParcelable(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public GenericStructuredParcelable[] newArray(int _aidl_size) { return new GenericStructuredParcelable[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(a); _aidl_parcel.writeInt(b); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; a = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; b = _aidl_parcel.readInt(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public String toString() { java.util.StringJoiner _aidl_sj = new java.util.StringJoiner(", ", "{", "}"); _aidl_sj.add("a: " + (a)); _aidl_sj.add("b: " + (b)); return "GenericStructuredParcelable" + _aidl_sj.toString() ; } @Override public int describeContents() { int _mask = 0; return _mask; } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_Ge0100644 0000000 0000000 00000000232 15172120304 033214 xustar000000000 0000000 126 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/GenericStructuredParcelable.java.d 28 mtime=1776853188.6160000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/GenericStructuredP0100644 0000000 0000000 00000000325 15172120304 033146 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/GenericStructuredParcelable.java : \ system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_IC0100644 0000000 0000000 00000000034 15172120304 033154 xustar000000000 0000000 28 mtime=1776853188.6160000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/ICircular.java0100644 0000000 0000000 00000011147 15172120304 032166 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/ICircular.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ICircular.aidl */ package android.aidl.tests; public interface ICircular extends android.os.IInterface { /** Default implementation for ICircular. */ public static class Default implements android.aidl.tests.ICircular { @Override public android.aidl.tests.ITestService GetTestService() throws android.os.RemoteException { return null; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.ICircular { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.ICircular interface, * generating a proxy if needed. */ public static android.aidl.tests.ICircular asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.ICircular))) { return ((android.aidl.tests.ICircular)iin); } return new android.aidl.tests.ICircular.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_GetTestService: { return "GetTestService"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_GetTestService: { android.aidl.tests.ITestService _result = this.GetTestService(); reply.writeNoException(); reply.writeStrongInterface(_result); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.ICircular { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public android.aidl.tests.ITestService GetTestService() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.ITestService _result; try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_GetTestService, _data, _reply, 0); _reply.readException(); _result = android.aidl.tests.ITestService.Stub.asInterface(_reply.readStrongBinder()); } finally { _reply.recycle(); _data.recycle(); } return _result; } } static final int TRANSACTION_GetTestService = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.ICircular"; public android.aidl.tests.ITestService GetTestService() throws android.os.RemoteException; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_IC0100644 0000000 0000000 00000000034 15172120304 033154 xustar000000000 0000000 28 mtime=1776853188.6170000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/ICircular.java.d0100644 0000000 0000000 00000002224 15172120304 032404 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/ICircular.java : \ system/tools/aidl/tests/android/aidl/tests/ICircular.aidl \ system/tools/aidl/tests/android/aidl/tests/ITestService.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl \ system/tools/aidl/tests/android/aidl/tests/SimpleParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl \ system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_ID0100644 0000000 0000000 00000000034 15172120304 033155 xustar000000000 0000000 28 mtime=1776853188.6170000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/IDeprecated.java0100644 0000000 0000000 00000006217 15172120304 032464 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/IDeprecated.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IDeprecated.aidl */ package android.aidl.tests; /** @deprecated test */ @Deprecated public interface IDeprecated extends android.os.IInterface { /** Default implementation for IDeprecated. */ public static class Default implements android.aidl.tests.IDeprecated { @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.IDeprecated { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.IDeprecated interface, * generating a proxy if needed. */ public static android.aidl.tests.IDeprecated asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.IDeprecated))) { return ((android.aidl.tests.IDeprecated)iin); } return new android.aidl.tests.IDeprecated.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { default: { return super.onTransact(code, data, reply, flags); } } } private static class Proxy implements android.aidl.tests.IDeprecated { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } } /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.IDeprecated"; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_ID0100644 0000000 0000000 00000000212 15172120304 033153 xustar000000000 0000000 110 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/IDeprecated.java.d 28 mtime=1776853188.6170000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/IDeprecated.java.d0100644 0000000 0000000 00000000265 15172120304 032703 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/IDeprecated.java : \ system/tools/aidl/tests/android/aidl/tests/IDeprecated.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_IN0100644 0000000 0000000 00000000213 15172120304 033166 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/INamedCallback.java 28 mtime=1776853188.6170000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/INamedCallback.jav0100644 0000000 0000000 00000010735 15172120304 032724 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/INamedCallback.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl */ package android.aidl.tests; public interface INamedCallback extends android.os.IInterface { /** Default implementation for INamedCallback. */ public static class Default implements android.aidl.tests.INamedCallback { @Override public java.lang.String GetName() throws android.os.RemoteException { return null; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.INamedCallback { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.INamedCallback interface, * generating a proxy if needed. */ public static android.aidl.tests.INamedCallback asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.INamedCallback))) { return ((android.aidl.tests.INamedCallback)iin); } return new android.aidl.tests.INamedCallback.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_GetName: { return "GetName"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_GetName: { java.lang.String _result = this.GetName(); reply.writeNoException(); reply.writeString(_result); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.INamedCallback { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public java.lang.String GetName() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.lang.String _result; try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_GetName, _data, _reply, 0); _reply.readException(); _result = _reply.readString(); } finally { _reply.recycle(); _data.recycle(); } return _result; } } static final int TRANSACTION_GetName = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.INamedCallback"; public java.lang.String GetName() throws android.os.RemoteException; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_IN0100644 0000000 0000000 00000000215 15172120304 033170 xustar000000000 0000000 113 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/INamedCallback.java.d 28 mtime=1776853188.6170000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/INamedCallback.jav0100644 0000000 0000000 00000000273 15172120304 032720 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/INamedCallback.java : \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_IN0100644 0000000 0000000 00000000034 15172120304 033167 xustar000000000 0000000 28 mtime=1776853188.6170000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/INewName.java0100644 0000000 0000000 00000010630 15172120304 031750 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/INewName.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INewName.aidl */ package android.aidl.tests; public interface INewName extends android.os.IInterface { /** Default implementation for INewName. */ public static class Default implements android.aidl.tests.INewName { @Override public java.lang.String RealName() throws android.os.RemoteException { return null; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.INewName { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.INewName interface, * generating a proxy if needed. */ public static android.aidl.tests.INewName asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.INewName))) { return ((android.aidl.tests.INewName)iin); } return new android.aidl.tests.INewName.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_RealName: { return "RealName"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_RealName: { java.lang.String _result = this.RealName(); reply.writeNoException(); reply.writeString(_result); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.INewName { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public java.lang.String RealName() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.lang.String _result; try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_RealName, _data, _reply, 0); _reply.readException(); _result = _reply.readString(); } finally { _reply.recycle(); _data.recycle(); } return _result; } } static final int TRANSACTION_RealName = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.IOldName"; public java.lang.String RealName() throws android.os.RemoteException; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_IN0100644 0000000 0000000 00000000034 15172120304 033167 xustar000000000 0000000 28 mtime=1776853188.6170000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/INewName.java.d0100644 0000000 0000000 00000000257 15172120304 032176 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/INewName.java : \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_IO0100644 0000000 0000000 00000000034 15172120304 033170 xustar000000000 0000000 28 mtime=1776853188.6170000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/IOldName.java0100644 0000000 0000000 00000010630 15172120304 031735 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/IOldName.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IOldName.aidl */ package android.aidl.tests; public interface IOldName extends android.os.IInterface { /** Default implementation for IOldName. */ public static class Default implements android.aidl.tests.IOldName { @Override public java.lang.String RealName() throws android.os.RemoteException { return null; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.IOldName { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.IOldName interface, * generating a proxy if needed. */ public static android.aidl.tests.IOldName asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.IOldName))) { return ((android.aidl.tests.IOldName)iin); } return new android.aidl.tests.IOldName.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_RealName: { return "RealName"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_RealName: { java.lang.String _result = this.RealName(); reply.writeNoException(); reply.writeString(_result); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.IOldName { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public java.lang.String RealName() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.lang.String _result; try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_RealName, _data, _reply, 0); _reply.readException(); _result = _reply.readString(); } finally { _reply.recycle(); _data.recycle(); } return _result; } } static final int TRANSACTION_RealName = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.IOldName"; public java.lang.String RealName() throws android.os.RemoteException; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_IO0100644 0000000 0000000 00000000034 15172120304 033170 xustar000000000 0000000 28 mtime=1776853188.6170000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/IOldName.java.d0100644 0000000 0000000 00000000257 15172120304 032163 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/IOldName.java : \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_IT0100644 0000000 0000000 00000000034 15172120304 033175 xustar000000000 0000000 28 mtime=1776853188.6180000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/ITestService.java0100644 0000000 0000000 00000563307 15172120304 032674 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/ITestService.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ITestService.aidl */ package android.aidl.tests; /** interface comment */ /** interface comment 2 */ // interface comment 3 // interface comment 4 public interface ITestService extends android.os.IInterface { /** Default implementation for ITestService. */ public static class Default implements android.aidl.tests.ITestService { // This is to emulate a method that is added after the service is implemented. // So the client cannot assume that a call to this method will be successful // or not. However, inside the test environment, we can't build client and // the server with different version of this AIDL file. So, we let the server // actually implement this and intercept the dispatch to the method // inside onTransact(). // WARNING: Must be first method. // This requires hard coding the transaction number. As long as this method is // the first in this interface, it can keep the // "::android::IBinder::FIRST_CALL_TRANSACTION + 0" value and allow // methods to be added and removed. @Override public int UnimplementedMethod(int arg) throws android.os.RemoteException { return 0; } /** * @deprecated to make sure we have something in system/tools/aidl which does a compile check * of deprecated and make sure this is reflected in goldens */ @Override public void Deprecated() throws android.os.RemoteException { } @Override public void TestOneway() throws android.os.RemoteException { } // Test that primitives work as parameters and return types. @Override public boolean RepeatBoolean(boolean token) throws android.os.RemoteException { return false; } @Override public byte RepeatByte(byte token) throws android.os.RemoteException { return 0; } @Override public char RepeatChar(char token) throws android.os.RemoteException { return '\u0000'; } @Override public int RepeatInt(int token) throws android.os.RemoteException { return 0; } @Override public long RepeatLong(long token) throws android.os.RemoteException { return 0L; } @Override public float RepeatFloat(float token) throws android.os.RemoteException { return 0.0f; } @Override public double RepeatDouble(double token) throws android.os.RemoteException { return 0.0d; } @Override public java.lang.String RepeatString(java.lang.String token) throws android.os.RemoteException { return null; } @Override public byte RepeatByteEnum(byte token) throws android.os.RemoteException { return 0; } @Override public int RepeatIntEnum(int token) throws android.os.RemoteException { return 0; } @Override public long RepeatLongEnum(long token) throws android.os.RemoteException { return 0L; } // Test that arrays work as parameters and return types. @Override public boolean[] ReverseBoolean(boolean[] input, boolean[] repeated) throws android.os.RemoteException { return null; } @Override public byte[] ReverseByte(byte[] input, byte[] repeated) throws android.os.RemoteException { return null; } @Override public char[] ReverseChar(char[] input, char[] repeated) throws android.os.RemoteException { return null; } @Override public int[] ReverseInt(int[] input, int[] repeated) throws android.os.RemoteException { return null; } @Override public long[] ReverseLong(long[] input, long[] repeated) throws android.os.RemoteException { return null; } @Override public float[] ReverseFloat(float[] input, float[] repeated) throws android.os.RemoteException { return null; } @Override public double[] ReverseDouble(double[] input, double[] repeated) throws android.os.RemoteException { return null; } @Override public java.lang.String[] ReverseString(java.lang.String[] input, java.lang.String[] repeated) throws android.os.RemoteException { return null; } @Override public byte[] ReverseByteEnum(byte[] input, byte[] repeated) throws android.os.RemoteException { return null; } @Override public int[] ReverseIntEnum(int[] input, int[] repeated) throws android.os.RemoteException { return null; } @Override public long[] ReverseLongEnum(long[] input, long[] repeated) throws android.os.RemoteException { return null; } // Test that clients can send and receive Binders. @Override public android.aidl.tests.INamedCallback GetOtherTestService(java.lang.String name) throws android.os.RemoteException { return null; } // returns true if the same service is already registered with the same name @Override public boolean SetOtherTestService(java.lang.String name, android.aidl.tests.INamedCallback service) throws android.os.RemoteException { return false; } @Override public boolean VerifyName(android.aidl.tests.INamedCallback service, java.lang.String name) throws android.os.RemoteException { return false; } @Override public android.aidl.tests.INamedCallback[] GetInterfaceArray(java.lang.String[] names) throws android.os.RemoteException { return null; } @Override public boolean VerifyNamesWithInterfaceArray(android.aidl.tests.INamedCallback[] services, java.lang.String[] names) throws android.os.RemoteException { return false; } @Override public android.aidl.tests.INamedCallback[] GetNullableInterfaceArray(java.lang.String[] names) throws android.os.RemoteException { return null; } @Override public boolean VerifyNamesWithNullableInterfaceArray(android.aidl.tests.INamedCallback[] services, java.lang.String[] names) throws android.os.RemoteException { return false; } @Override public java.util.List GetInterfaceList(java.lang.String[] names) throws android.os.RemoteException { return null; } @Override public boolean VerifyNamesWithInterfaceList(java.util.List services, java.lang.String[] names) throws android.os.RemoteException { return false; } // Test that List types work correctly. @Override public java.util.List ReverseStringList(java.util.List input, java.util.List repeated) throws android.os.RemoteException { return null; } @Override public android.os.ParcelFileDescriptor RepeatParcelFileDescriptor(android.os.ParcelFileDescriptor read) throws android.os.RemoteException { return null; } @Override public android.os.ParcelFileDescriptor[] ReverseParcelFileDescriptorArray(android.os.ParcelFileDescriptor[] input, android.os.ParcelFileDescriptor[] repeated) throws android.os.RemoteException { return null; } // Test that service specific exceptions work correctly. @Override public void ThrowServiceException(int code) throws android.os.RemoteException { } // Test nullability @Override public int[] RepeatNullableIntArray(int[] input) throws android.os.RemoteException { return null; } @Override public byte[] RepeatNullableByteEnumArray(byte[] input) throws android.os.RemoteException { return null; } @Override public int[] RepeatNullableIntEnumArray(int[] input) throws android.os.RemoteException { return null; } @Override public long[] RepeatNullableLongEnumArray(long[] input) throws android.os.RemoteException { return null; } @Override public java.lang.String RepeatNullableString(java.lang.String input) throws android.os.RemoteException { return null; } @Override public java.util.List RepeatNullableStringList(java.util.List input) throws android.os.RemoteException { return null; } @Override public android.aidl.tests.ITestService.Empty RepeatNullableParcelable(android.aidl.tests.ITestService.Empty input) throws android.os.RemoteException { return null; } @Override public android.aidl.tests.ITestService.Empty[] RepeatNullableParcelableArray(android.aidl.tests.ITestService.Empty[] input) throws android.os.RemoteException { return null; } @Override public java.util.List RepeatNullableParcelableList(java.util.List input) throws android.os.RemoteException { return null; } @Override public void TakesAnIBinder(android.os.IBinder input) throws android.os.RemoteException { } @Override public void TakesANullableIBinder(android.os.IBinder input) throws android.os.RemoteException { } @Override public void TakesAnIBinderList(java.util.List input) throws android.os.RemoteException { } @Override public void TakesANullableIBinderList(java.util.List input) throws android.os.RemoteException { } // Test utf8 decoding from utf16 wire format @Override public java.lang.String RepeatUtf8CppString(java.lang.String token) throws android.os.RemoteException { return null; } @Override public java.lang.String RepeatNullableUtf8CppString(java.lang.String token) throws android.os.RemoteException { return null; } @Override public java.lang.String[] ReverseUtf8CppString(java.lang.String[] input, java.lang.String[] repeated) throws android.os.RemoteException { return null; } @Override public java.lang.String[] ReverseNullableUtf8CppString(java.lang.String[] input, java.lang.String[] repeated) throws android.os.RemoteException { return null; } @Override public java.util.List ReverseUtf8CppStringList(java.util.List input, java.util.List repeated) throws android.os.RemoteException { return null; } /** comment before annotation */ @Override public android.aidl.tests.INamedCallback GetCallback(boolean return_null) throws android.os.RemoteException { return null; } // Since this paracelable has clearly defined default values, it would be // inefficient to use an IPC to fill it out in practice. @Override public void FillOutStructuredParcelable(android.aidl.tests.StructuredParcelable parcel) throws android.os.RemoteException { } @Override public void RepeatExtendableParcelable(android.aidl.tests.extension.ExtendableParcelable ep, android.aidl.tests.extension.ExtendableParcelable ep2) throws android.os.RemoteException { } @Override public android.aidl.tests.RecursiveList ReverseList(android.aidl.tests.RecursiveList list) throws android.os.RemoteException { return null; } @Override public android.os.IBinder[] ReverseIBinderArray(android.os.IBinder[] input, android.os.IBinder[] repeated) throws android.os.RemoteException { return null; } @Override public android.os.IBinder[] ReverseNullableIBinderArray(android.os.IBinder[] input, android.os.IBinder[] repeated) throws android.os.RemoteException { return null; } @Override public android.aidl.tests.SimpleParcelable RepeatSimpleParcelable(android.aidl.tests.SimpleParcelable input, android.aidl.tests.SimpleParcelable repeat) throws android.os.RemoteException { return null; } @Override public android.aidl.tests.SimpleParcelable[] ReverseSimpleParcelables(android.aidl.tests.SimpleParcelable[] input, android.aidl.tests.SimpleParcelable[] repeated) throws android.os.RemoteException { return null; } @Override public android.aidl.tests.IOldName GetOldNameInterface() throws android.os.RemoteException { return null; } @Override public android.aidl.tests.INewName GetNewNameInterface() throws android.os.RemoteException { return null; } @Override public int[] GetUnionTags(android.aidl.tests.Union[] input) throws android.os.RemoteException { return null; } // Retrieve the ICppJavaTests if the server supports it @Override public android.os.IBinder GetCppJavaTests() throws android.os.RemoteException { return null; } @Override public byte getBackendType() throws android.os.RemoteException { return 0; } @Override public android.aidl.tests.ICircular GetCircular(android.aidl.tests.CircularParcelable cp) throws android.os.RemoteException { return null; } @Override public android.os.IBinder asBinder() { return null; } } /** Delegator implementation for ITestService. */ public static class Delegator extends android.aidl.tests.ITestService.Stub { public Delegator(android.aidl.tests.ITestService impl) { this.mImpl = impl; } // This is to emulate a method that is added after the service is implemented. // So the client cannot assume that a call to this method will be successful // or not. However, inside the test environment, we can't build client and // the server with different version of this AIDL file. So, we let the server // actually implement this and intercept the dispatch to the method // inside onTransact(). // WARNING: Must be first method. // This requires hard coding the transaction number. As long as this method is // the first in this interface, it can keep the // "::android::IBinder::FIRST_CALL_TRANSACTION + 0" value and allow // methods to be added and removed. @Override public int UnimplementedMethod(int arg) throws android.os.RemoteException { return mImpl.UnimplementedMethod(arg); } /** * @deprecated to make sure we have something in system/tools/aidl which does a compile check * of deprecated and make sure this is reflected in goldens */ @Override public void Deprecated() throws android.os.RemoteException { mImpl.Deprecated(); } @Override public void TestOneway() throws android.os.RemoteException { mImpl.TestOneway(); } // Test that primitives work as parameters and return types. @Override public boolean RepeatBoolean(boolean token) throws android.os.RemoteException { return mImpl.RepeatBoolean(token); } @Override public byte RepeatByte(byte token) throws android.os.RemoteException { return mImpl.RepeatByte(token); } @Override public char RepeatChar(char token) throws android.os.RemoteException { return mImpl.RepeatChar(token); } @Override public int RepeatInt(int token) throws android.os.RemoteException { return mImpl.RepeatInt(token); } @Override public long RepeatLong(long token) throws android.os.RemoteException { return mImpl.RepeatLong(token); } @Override public float RepeatFloat(float token) throws android.os.RemoteException { return mImpl.RepeatFloat(token); } @Override public double RepeatDouble(double token) throws android.os.RemoteException { return mImpl.RepeatDouble(token); } @Override public java.lang.String RepeatString(java.lang.String token) throws android.os.RemoteException { return mImpl.RepeatString(token); } @Override public byte RepeatByteEnum(byte token) throws android.os.RemoteException { return mImpl.RepeatByteEnum(token); } @Override public int RepeatIntEnum(int token) throws android.os.RemoteException { return mImpl.RepeatIntEnum(token); } @Override public long RepeatLongEnum(long token) throws android.os.RemoteException { return mImpl.RepeatLongEnum(token); } // Test that arrays work as parameters and return types. @Override public boolean[] ReverseBoolean(boolean[] input, boolean[] repeated) throws android.os.RemoteException { return mImpl.ReverseBoolean(input,repeated); } @Override public byte[] ReverseByte(byte[] input, byte[] repeated) throws android.os.RemoteException { return mImpl.ReverseByte(input,repeated); } @Override public char[] ReverseChar(char[] input, char[] repeated) throws android.os.RemoteException { return mImpl.ReverseChar(input,repeated); } @Override public int[] ReverseInt(int[] input, int[] repeated) throws android.os.RemoteException { return mImpl.ReverseInt(input,repeated); } @Override public long[] ReverseLong(long[] input, long[] repeated) throws android.os.RemoteException { return mImpl.ReverseLong(input,repeated); } @Override public float[] ReverseFloat(float[] input, float[] repeated) throws android.os.RemoteException { return mImpl.ReverseFloat(input,repeated); } @Override public double[] ReverseDouble(double[] input, double[] repeated) throws android.os.RemoteException { return mImpl.ReverseDouble(input,repeated); } @Override public java.lang.String[] ReverseString(java.lang.String[] input, java.lang.String[] repeated) throws android.os.RemoteException { return mImpl.ReverseString(input,repeated); } @Override public byte[] ReverseByteEnum(byte[] input, byte[] repeated) throws android.os.RemoteException { return mImpl.ReverseByteEnum(input,repeated); } @Override public int[] ReverseIntEnum(int[] input, int[] repeated) throws android.os.RemoteException { return mImpl.ReverseIntEnum(input,repeated); } @Override public long[] ReverseLongEnum(long[] input, long[] repeated) throws android.os.RemoteException { return mImpl.ReverseLongEnum(input,repeated); } // Test that clients can send and receive Binders. @Override public android.aidl.tests.INamedCallback GetOtherTestService(java.lang.String name) throws android.os.RemoteException { return mImpl.GetOtherTestService(name); } // returns true if the same service is already registered with the same name @Override public boolean SetOtherTestService(java.lang.String name, android.aidl.tests.INamedCallback service) throws android.os.RemoteException { return mImpl.SetOtherTestService(name,service); } @Override public boolean VerifyName(android.aidl.tests.INamedCallback service, java.lang.String name) throws android.os.RemoteException { return mImpl.VerifyName(service,name); } @Override public android.aidl.tests.INamedCallback[] GetInterfaceArray(java.lang.String[] names) throws android.os.RemoteException { return mImpl.GetInterfaceArray(names); } @Override public boolean VerifyNamesWithInterfaceArray(android.aidl.tests.INamedCallback[] services, java.lang.String[] names) throws android.os.RemoteException { return mImpl.VerifyNamesWithInterfaceArray(services,names); } @Override public android.aidl.tests.INamedCallback[] GetNullableInterfaceArray(java.lang.String[] names) throws android.os.RemoteException { return mImpl.GetNullableInterfaceArray(names); } @Override public boolean VerifyNamesWithNullableInterfaceArray(android.aidl.tests.INamedCallback[] services, java.lang.String[] names) throws android.os.RemoteException { return mImpl.VerifyNamesWithNullableInterfaceArray(services,names); } @Override public java.util.List GetInterfaceList(java.lang.String[] names) throws android.os.RemoteException { return mImpl.GetInterfaceList(names); } @Override public boolean VerifyNamesWithInterfaceList(java.util.List services, java.lang.String[] names) throws android.os.RemoteException { return mImpl.VerifyNamesWithInterfaceList(services,names); } // Test that List types work correctly. @Override public java.util.List ReverseStringList(java.util.List input, java.util.List repeated) throws android.os.RemoteException { return mImpl.ReverseStringList(input,repeated); } @Override public android.os.ParcelFileDescriptor RepeatParcelFileDescriptor(android.os.ParcelFileDescriptor read) throws android.os.RemoteException { return mImpl.RepeatParcelFileDescriptor(read); } @Override public android.os.ParcelFileDescriptor[] ReverseParcelFileDescriptorArray(android.os.ParcelFileDescriptor[] input, android.os.ParcelFileDescriptor[] repeated) throws android.os.RemoteException { return mImpl.ReverseParcelFileDescriptorArray(input,repeated); } // Test that service specific exceptions work correctly. @Override public void ThrowServiceException(int code) throws android.os.RemoteException { mImpl.ThrowServiceException(code); } // Test nullability @Override public int[] RepeatNullableIntArray(int[] input) throws android.os.RemoteException { return mImpl.RepeatNullableIntArray(input); } @Override public byte[] RepeatNullableByteEnumArray(byte[] input) throws android.os.RemoteException { return mImpl.RepeatNullableByteEnumArray(input); } @Override public int[] RepeatNullableIntEnumArray(int[] input) throws android.os.RemoteException { return mImpl.RepeatNullableIntEnumArray(input); } @Override public long[] RepeatNullableLongEnumArray(long[] input) throws android.os.RemoteException { return mImpl.RepeatNullableLongEnumArray(input); } @Override public java.lang.String RepeatNullableString(java.lang.String input) throws android.os.RemoteException { return mImpl.RepeatNullableString(input); } @Override public java.util.List RepeatNullableStringList(java.util.List input) throws android.os.RemoteException { return mImpl.RepeatNullableStringList(input); } @Override public android.aidl.tests.ITestService.Empty RepeatNullableParcelable(android.aidl.tests.ITestService.Empty input) throws android.os.RemoteException { return mImpl.RepeatNullableParcelable(input); } @Override public android.aidl.tests.ITestService.Empty[] RepeatNullableParcelableArray(android.aidl.tests.ITestService.Empty[] input) throws android.os.RemoteException { return mImpl.RepeatNullableParcelableArray(input); } @Override public java.util.List RepeatNullableParcelableList(java.util.List input) throws android.os.RemoteException { return mImpl.RepeatNullableParcelableList(input); } @Override public void TakesAnIBinder(android.os.IBinder input) throws android.os.RemoteException { mImpl.TakesAnIBinder(input); } @Override public void TakesANullableIBinder(android.os.IBinder input) throws android.os.RemoteException { mImpl.TakesANullableIBinder(input); } @Override public void TakesAnIBinderList(java.util.List input) throws android.os.RemoteException { mImpl.TakesAnIBinderList(input); } @Override public void TakesANullableIBinderList(java.util.List input) throws android.os.RemoteException { mImpl.TakesANullableIBinderList(input); } // Test utf8 decoding from utf16 wire format @Override public java.lang.String RepeatUtf8CppString(java.lang.String token) throws android.os.RemoteException { return mImpl.RepeatUtf8CppString(token); } @Override public java.lang.String RepeatNullableUtf8CppString(java.lang.String token) throws android.os.RemoteException { return mImpl.RepeatNullableUtf8CppString(token); } @Override public java.lang.String[] ReverseUtf8CppString(java.lang.String[] input, java.lang.String[] repeated) throws android.os.RemoteException { return mImpl.ReverseUtf8CppString(input,repeated); } @Override public java.lang.String[] ReverseNullableUtf8CppString(java.lang.String[] input, java.lang.String[] repeated) throws android.os.RemoteException { return mImpl.ReverseNullableUtf8CppString(input,repeated); } @Override public java.util.List ReverseUtf8CppStringList(java.util.List input, java.util.List repeated) throws android.os.RemoteException { return mImpl.ReverseUtf8CppStringList(input,repeated); } /** comment before annotation */ @Override public android.aidl.tests.INamedCallback GetCallback(boolean return_null) throws android.os.RemoteException { return mImpl.GetCallback(return_null); } // Since this paracelable has clearly defined default values, it would be // inefficient to use an IPC to fill it out in practice. @Override public void FillOutStructuredParcelable(android.aidl.tests.StructuredParcelable parcel) throws android.os.RemoteException { mImpl.FillOutStructuredParcelable(parcel); } @Override public void RepeatExtendableParcelable(android.aidl.tests.extension.ExtendableParcelable ep, android.aidl.tests.extension.ExtendableParcelable ep2) throws android.os.RemoteException { mImpl.RepeatExtendableParcelable(ep,ep2); } @Override public android.aidl.tests.RecursiveList ReverseList(android.aidl.tests.RecursiveList list) throws android.os.RemoteException { return mImpl.ReverseList(list); } @Override public android.os.IBinder[] ReverseIBinderArray(android.os.IBinder[] input, android.os.IBinder[] repeated) throws android.os.RemoteException { return mImpl.ReverseIBinderArray(input,repeated); } @Override public android.os.IBinder[] ReverseNullableIBinderArray(android.os.IBinder[] input, android.os.IBinder[] repeated) throws android.os.RemoteException { return mImpl.ReverseNullableIBinderArray(input,repeated); } @Override public android.aidl.tests.SimpleParcelable RepeatSimpleParcelable(android.aidl.tests.SimpleParcelable input, android.aidl.tests.SimpleParcelable repeat) throws android.os.RemoteException { return mImpl.RepeatSimpleParcelable(input,repeat); } @Override public android.aidl.tests.SimpleParcelable[] ReverseSimpleParcelables(android.aidl.tests.SimpleParcelable[] input, android.aidl.tests.SimpleParcelable[] repeated) throws android.os.RemoteException { return mImpl.ReverseSimpleParcelables(input,repeated); } @Override public android.aidl.tests.IOldName GetOldNameInterface() throws android.os.RemoteException { return mImpl.GetOldNameInterface(); } @Override public android.aidl.tests.INewName GetNewNameInterface() throws android.os.RemoteException { return mImpl.GetNewNameInterface(); } @Override public int[] GetUnionTags(android.aidl.tests.Union[] input) throws android.os.RemoteException { return mImpl.GetUnionTags(input); } // Retrieve the ICppJavaTests if the server supports it @Override public android.os.IBinder GetCppJavaTests() throws android.os.RemoteException { return mImpl.GetCppJavaTests(); } @Override public byte getBackendType() throws android.os.RemoteException { return mImpl.getBackendType(); } @Override public android.aidl.tests.ICircular GetCircular(android.aidl.tests.CircularParcelable cp) throws android.os.RemoteException { return mImpl.GetCircular(cp); } android.aidl.tests.ITestService mImpl; } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.ITestService { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.ITestService interface, * generating a proxy if needed. */ public static android.aidl.tests.ITestService asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.ITestService))) { return ((android.aidl.tests.ITestService)iin); } return new android.aidl.tests.ITestService.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_UnimplementedMethod: { return "UnimplementedMethod"; } case TRANSACTION_Deprecated: { return "Deprecated"; } case TRANSACTION_TestOneway: { return "TestOneway"; } case TRANSACTION_RepeatBoolean: { return "RepeatBoolean"; } case TRANSACTION_RepeatByte: { return "RepeatByte"; } case TRANSACTION_RepeatChar: { return "RepeatChar"; } case TRANSACTION_RepeatInt: { return "RepeatInt"; } case TRANSACTION_RepeatLong: { return "RepeatLong"; } case TRANSACTION_RepeatFloat: { return "RepeatFloat"; } case TRANSACTION_RepeatDouble: { return "RepeatDouble"; } case TRANSACTION_RepeatString: { return "RepeatString"; } case TRANSACTION_RepeatByteEnum: { return "RepeatByteEnum"; } case TRANSACTION_RepeatIntEnum: { return "RepeatIntEnum"; } case TRANSACTION_RepeatLongEnum: { return "RepeatLongEnum"; } case TRANSACTION_ReverseBoolean: { return "ReverseBoolean"; } case TRANSACTION_ReverseByte: { return "ReverseByte"; } case TRANSACTION_ReverseChar: { return "ReverseChar"; } case TRANSACTION_ReverseInt: { return "ReverseInt"; } case TRANSACTION_ReverseLong: { return "ReverseLong"; } case TRANSACTION_ReverseFloat: { return "ReverseFloat"; } case TRANSACTION_ReverseDouble: { return "ReverseDouble"; } case TRANSACTION_ReverseString: { return "ReverseString"; } case TRANSACTION_ReverseByteEnum: { return "ReverseByteEnum"; } case TRANSACTION_ReverseIntEnum: { return "ReverseIntEnum"; } case TRANSACTION_ReverseLongEnum: { return "ReverseLongEnum"; } case TRANSACTION_GetOtherTestService: { return "GetOtherTestService"; } case TRANSACTION_SetOtherTestService: { return "SetOtherTestService"; } case TRANSACTION_VerifyName: { return "VerifyName"; } case TRANSACTION_GetInterfaceArray: { return "GetInterfaceArray"; } case TRANSACTION_VerifyNamesWithInterfaceArray: { return "VerifyNamesWithInterfaceArray"; } case TRANSACTION_GetNullableInterfaceArray: { return "GetNullableInterfaceArray"; } case TRANSACTION_VerifyNamesWithNullableInterfaceArray: { return "VerifyNamesWithNullableInterfaceArray"; } case TRANSACTION_GetInterfaceList: { return "GetInterfaceList"; } case TRANSACTION_VerifyNamesWithInterfaceList: { return "VerifyNamesWithInterfaceList"; } case TRANSACTION_ReverseStringList: { return "ReverseStringList"; } case TRANSACTION_RepeatParcelFileDescriptor: { return "RepeatParcelFileDescriptor"; } case TRANSACTION_ReverseParcelFileDescriptorArray: { return "ReverseParcelFileDescriptorArray"; } case TRANSACTION_ThrowServiceException: { return "ThrowServiceException"; } case TRANSACTION_RepeatNullableIntArray: { return "RepeatNullableIntArray"; } case TRANSACTION_RepeatNullableByteEnumArray: { return "RepeatNullableByteEnumArray"; } case TRANSACTION_RepeatNullableIntEnumArray: { return "RepeatNullableIntEnumArray"; } case TRANSACTION_RepeatNullableLongEnumArray: { return "RepeatNullableLongEnumArray"; } case TRANSACTION_RepeatNullableString: { return "RepeatNullableString"; } case TRANSACTION_RepeatNullableStringList: { return "RepeatNullableStringList"; } case TRANSACTION_RepeatNullableParcelable: { return "RepeatNullableParcelable"; } case TRANSACTION_RepeatNullableParcelableArray: { return "RepeatNullableParcelableArray"; } case TRANSACTION_RepeatNullableParcelableList: { return "RepeatNullableParcelableList"; } case TRANSACTION_TakesAnIBinder: { return "TakesAnIBinder"; } case TRANSACTION_TakesANullableIBinder: { return "TakesANullableIBinder"; } case TRANSACTION_TakesAnIBinderList: { return "TakesAnIBinderList"; } case TRANSACTION_TakesANullableIBinderList: { return "TakesANullableIBinderList"; } case TRANSACTION_RepeatUtf8CppString: { return "RepeatUtf8CppString"; } case TRANSACTION_RepeatNullableUtf8CppString: { return "RepeatNullableUtf8CppString"; } case TRANSACTION_ReverseUtf8CppString: { return "ReverseUtf8CppString"; } case TRANSACTION_ReverseNullableUtf8CppString: { return "ReverseNullableUtf8CppString"; } case TRANSACTION_ReverseUtf8CppStringList: { return "ReverseUtf8CppStringList"; } case TRANSACTION_GetCallback: { return "GetCallback"; } case TRANSACTION_FillOutStructuredParcelable: { return "FillOutStructuredParcelable"; } case TRANSACTION_RepeatExtendableParcelable: { return "RepeatExtendableParcelable"; } case TRANSACTION_ReverseList: { return "ReverseList"; } case TRANSACTION_ReverseIBinderArray: { return "ReverseIBinderArray"; } case TRANSACTION_ReverseNullableIBinderArray: { return "ReverseNullableIBinderArray"; } case TRANSACTION_RepeatSimpleParcelable: { return "RepeatSimpleParcelable"; } case TRANSACTION_ReverseSimpleParcelables: { return "ReverseSimpleParcelables"; } case TRANSACTION_GetOldNameInterface: { return "GetOldNameInterface"; } case TRANSACTION_GetNewNameInterface: { return "GetNewNameInterface"; } case TRANSACTION_GetUnionTags: { return "GetUnionTags"; } case TRANSACTION_GetCppJavaTests: { return "GetCppJavaTests"; } case TRANSACTION_getBackendType: { return "getBackendType"; } case TRANSACTION_GetCircular: { return "GetCircular"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_UnimplementedMethod: { int _arg0; _arg0 = data.readInt(); data.enforceNoDataAvail(); int _result = this.UnimplementedMethod(_arg0); reply.writeNoException(); reply.writeInt(_result); break; } case TRANSACTION_Deprecated: { this.Deprecated(); reply.writeNoException(); break; } case TRANSACTION_TestOneway: { this.TestOneway(); break; } case TRANSACTION_RepeatBoolean: { boolean _arg0; _arg0 = data.readBoolean(); data.enforceNoDataAvail(); boolean _result = this.RepeatBoolean(_arg0); reply.writeNoException(); reply.writeBoolean(_result); break; } case TRANSACTION_RepeatByte: { byte _arg0; _arg0 = data.readByte(); data.enforceNoDataAvail(); byte _result = this.RepeatByte(_arg0); reply.writeNoException(); reply.writeByte(_result); break; } case TRANSACTION_RepeatChar: { char _arg0; _arg0 = (char)data.readInt(); data.enforceNoDataAvail(); char _result = this.RepeatChar(_arg0); reply.writeNoException(); reply.writeInt(((int)_result)); break; } case TRANSACTION_RepeatInt: { int _arg0; _arg0 = data.readInt(); data.enforceNoDataAvail(); int _result = this.RepeatInt(_arg0); reply.writeNoException(); reply.writeInt(_result); break; } case TRANSACTION_RepeatLong: { long _arg0; _arg0 = data.readLong(); data.enforceNoDataAvail(); long _result = this.RepeatLong(_arg0); reply.writeNoException(); reply.writeLong(_result); break; } case TRANSACTION_RepeatFloat: { float _arg0; _arg0 = data.readFloat(); data.enforceNoDataAvail(); float _result = this.RepeatFloat(_arg0); reply.writeNoException(); reply.writeFloat(_result); break; } case TRANSACTION_RepeatDouble: { double _arg0; _arg0 = data.readDouble(); data.enforceNoDataAvail(); double _result = this.RepeatDouble(_arg0); reply.writeNoException(); reply.writeDouble(_result); break; } case TRANSACTION_RepeatString: { java.lang.String _arg0; _arg0 = data.readString(); data.enforceNoDataAvail(); java.lang.String _result = this.RepeatString(_arg0); reply.writeNoException(); reply.writeString(_result); break; } case TRANSACTION_RepeatByteEnum: { byte _arg0; _arg0 = data.readByte(); data.enforceNoDataAvail(); byte _result = this.RepeatByteEnum(_arg0); reply.writeNoException(); reply.writeByte(_result); break; } case TRANSACTION_RepeatIntEnum: { int _arg0; _arg0 = data.readInt(); data.enforceNoDataAvail(); int _result = this.RepeatIntEnum(_arg0); reply.writeNoException(); reply.writeInt(_result); break; } case TRANSACTION_RepeatLongEnum: { long _arg0; _arg0 = data.readLong(); data.enforceNoDataAvail(); long _result = this.RepeatLongEnum(_arg0); reply.writeNoException(); reply.writeLong(_result); break; } case TRANSACTION_ReverseBoolean: { boolean[] _arg0; _arg0 = data.createBooleanArray(); boolean[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new boolean[_arg1_length]; } data.enforceNoDataAvail(); boolean[] _result = this.ReverseBoolean(_arg0, _arg1); reply.writeNoException(); reply.writeBooleanArray(_result); reply.writeBooleanArray(_arg1); break; } case TRANSACTION_ReverseByte: { byte[] _arg0; _arg0 = data.createByteArray(); byte[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new byte[_arg1_length]; } data.enforceNoDataAvail(); byte[] _result = this.ReverseByte(_arg0, _arg1); reply.writeNoException(); reply.writeByteArray(_result); reply.writeByteArray(_arg1); break; } case TRANSACTION_ReverseChar: { char[] _arg0; _arg0 = data.createCharArray(); char[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new char[_arg1_length]; } data.enforceNoDataAvail(); char[] _result = this.ReverseChar(_arg0, _arg1); reply.writeNoException(); reply.writeCharArray(_result); reply.writeCharArray(_arg1); break; } case TRANSACTION_ReverseInt: { int[] _arg0; _arg0 = data.createIntArray(); int[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new int[_arg1_length]; } data.enforceNoDataAvail(); int[] _result = this.ReverseInt(_arg0, _arg1); reply.writeNoException(); reply.writeIntArray(_result); reply.writeIntArray(_arg1); break; } case TRANSACTION_ReverseLong: { long[] _arg0; _arg0 = data.createLongArray(); long[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new long[_arg1_length]; } data.enforceNoDataAvail(); long[] _result = this.ReverseLong(_arg0, _arg1); reply.writeNoException(); reply.writeLongArray(_result); reply.writeLongArray(_arg1); break; } case TRANSACTION_ReverseFloat: { float[] _arg0; _arg0 = data.createFloatArray(); float[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new float[_arg1_length]; } data.enforceNoDataAvail(); float[] _result = this.ReverseFloat(_arg0, _arg1); reply.writeNoException(); reply.writeFloatArray(_result); reply.writeFloatArray(_arg1); break; } case TRANSACTION_ReverseDouble: { double[] _arg0; _arg0 = data.createDoubleArray(); double[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new double[_arg1_length]; } data.enforceNoDataAvail(); double[] _result = this.ReverseDouble(_arg0, _arg1); reply.writeNoException(); reply.writeDoubleArray(_result); reply.writeDoubleArray(_arg1); break; } case TRANSACTION_ReverseString: { java.lang.String[] _arg0; _arg0 = data.createStringArray(); java.lang.String[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new java.lang.String[_arg1_length]; } data.enforceNoDataAvail(); java.lang.String[] _result = this.ReverseString(_arg0, _arg1); reply.writeNoException(); reply.writeStringArray(_result); reply.writeStringArray(_arg1); break; } case TRANSACTION_ReverseByteEnum: { byte[] _arg0; _arg0 = data.createByteArray(); byte[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new byte[_arg1_length]; } data.enforceNoDataAvail(); byte[] _result = this.ReverseByteEnum(_arg0, _arg1); reply.writeNoException(); reply.writeByteArray(_result); reply.writeByteArray(_arg1); break; } case TRANSACTION_ReverseIntEnum: { int[] _arg0; _arg0 = data.createIntArray(); int[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new int[_arg1_length]; } data.enforceNoDataAvail(); int[] _result = this.ReverseIntEnum(_arg0, _arg1); reply.writeNoException(); reply.writeIntArray(_result); reply.writeIntArray(_arg1); break; } case TRANSACTION_ReverseLongEnum: { long[] _arg0; _arg0 = data.createLongArray(); long[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new long[_arg1_length]; } data.enforceNoDataAvail(); long[] _result = this.ReverseLongEnum(_arg0, _arg1); reply.writeNoException(); reply.writeLongArray(_result); reply.writeLongArray(_arg1); break; } case TRANSACTION_GetOtherTestService: { java.lang.String _arg0; _arg0 = data.readString(); data.enforceNoDataAvail(); android.aidl.tests.INamedCallback _result = this.GetOtherTestService(_arg0); reply.writeNoException(); reply.writeStrongInterface(_result); break; } case TRANSACTION_SetOtherTestService: { java.lang.String _arg0; _arg0 = data.readString(); android.aidl.tests.INamedCallback _arg1; _arg1 = android.aidl.tests.INamedCallback.Stub.asInterface(data.readStrongBinder()); data.enforceNoDataAvail(); boolean _result = this.SetOtherTestService(_arg0, _arg1); reply.writeNoException(); reply.writeBoolean(_result); break; } case TRANSACTION_VerifyName: { android.aidl.tests.INamedCallback _arg0; _arg0 = android.aidl.tests.INamedCallback.Stub.asInterface(data.readStrongBinder()); java.lang.String _arg1; _arg1 = data.readString(); data.enforceNoDataAvail(); boolean _result = this.VerifyName(_arg0, _arg1); reply.writeNoException(); reply.writeBoolean(_result); break; } case TRANSACTION_GetInterfaceArray: { java.lang.String[] _arg0; _arg0 = data.createStringArray(); data.enforceNoDataAvail(); android.aidl.tests.INamedCallback[] _result = this.GetInterfaceArray(_arg0); reply.writeNoException(); reply.writeInterfaceArray(_result); break; } case TRANSACTION_VerifyNamesWithInterfaceArray: { android.aidl.tests.INamedCallback[] _arg0; _arg0 = data.createInterfaceArray(android.aidl.tests.INamedCallback[]::new, android.aidl.tests.INamedCallback.Stub::asInterface); java.lang.String[] _arg1; _arg1 = data.createStringArray(); data.enforceNoDataAvail(); boolean _result = this.VerifyNamesWithInterfaceArray(_arg0, _arg1); reply.writeNoException(); reply.writeBoolean(_result); break; } case TRANSACTION_GetNullableInterfaceArray: { java.lang.String[] _arg0; _arg0 = data.createStringArray(); data.enforceNoDataAvail(); android.aidl.tests.INamedCallback[] _result = this.GetNullableInterfaceArray(_arg0); reply.writeNoException(); reply.writeInterfaceArray(_result); break; } case TRANSACTION_VerifyNamesWithNullableInterfaceArray: { android.aidl.tests.INamedCallback[] _arg0; _arg0 = data.createInterfaceArray(android.aidl.tests.INamedCallback[]::new, android.aidl.tests.INamedCallback.Stub::asInterface); java.lang.String[] _arg1; _arg1 = data.createStringArray(); data.enforceNoDataAvail(); boolean _result = this.VerifyNamesWithNullableInterfaceArray(_arg0, _arg1); reply.writeNoException(); reply.writeBoolean(_result); break; } case TRANSACTION_GetInterfaceList: { java.lang.String[] _arg0; _arg0 = data.createStringArray(); data.enforceNoDataAvail(); java.util.List _result = this.GetInterfaceList(_arg0); reply.writeNoException(); reply.writeInterfaceList(_result); break; } case TRANSACTION_VerifyNamesWithInterfaceList: { java.util.List _arg0; _arg0 = data.createInterfaceArrayList(android.aidl.tests.INamedCallback.Stub::asInterface); java.lang.String[] _arg1; _arg1 = data.createStringArray(); data.enforceNoDataAvail(); boolean _result = this.VerifyNamesWithInterfaceList(_arg0, _arg1); reply.writeNoException(); reply.writeBoolean(_result); break; } case TRANSACTION_ReverseStringList: { java.util.List _arg0; _arg0 = data.createStringArrayList(); java.util.List _arg1; _arg1 = new java.util.ArrayList(); data.enforceNoDataAvail(); java.util.List _result = this.ReverseStringList(_arg0, _arg1); reply.writeNoException(); reply.writeStringList(_result); reply.writeStringList(_arg1); break; } case TRANSACTION_RepeatParcelFileDescriptor: { android.os.ParcelFileDescriptor _arg0; _arg0 = data.readTypedObject(android.os.ParcelFileDescriptor.CREATOR); data.enforceNoDataAvail(); android.os.ParcelFileDescriptor _result = this.RepeatParcelFileDescriptor(_arg0); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_ReverseParcelFileDescriptorArray: { android.os.ParcelFileDescriptor[] _arg0; _arg0 = data.createTypedArray(android.os.ParcelFileDescriptor.CREATOR); android.os.ParcelFileDescriptor[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new android.os.ParcelFileDescriptor[_arg1_length]; } data.enforceNoDataAvail(); android.os.ParcelFileDescriptor[] _result = this.ReverseParcelFileDescriptorArray(_arg0, _arg1); reply.writeNoException(); reply.writeTypedArray(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); reply.writeTypedArray(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_ThrowServiceException: { int _arg0; _arg0 = data.readInt(); data.enforceNoDataAvail(); this.ThrowServiceException(_arg0); reply.writeNoException(); break; } case TRANSACTION_RepeatNullableIntArray: { int[] _arg0; _arg0 = data.createIntArray(); data.enforceNoDataAvail(); int[] _result = this.RepeatNullableIntArray(_arg0); reply.writeNoException(); reply.writeIntArray(_result); break; } case TRANSACTION_RepeatNullableByteEnumArray: { byte[] _arg0; _arg0 = data.createByteArray(); data.enforceNoDataAvail(); byte[] _result = this.RepeatNullableByteEnumArray(_arg0); reply.writeNoException(); reply.writeByteArray(_result); break; } case TRANSACTION_RepeatNullableIntEnumArray: { int[] _arg0; _arg0 = data.createIntArray(); data.enforceNoDataAvail(); int[] _result = this.RepeatNullableIntEnumArray(_arg0); reply.writeNoException(); reply.writeIntArray(_result); break; } case TRANSACTION_RepeatNullableLongEnumArray: { long[] _arg0; _arg0 = data.createLongArray(); data.enforceNoDataAvail(); long[] _result = this.RepeatNullableLongEnumArray(_arg0); reply.writeNoException(); reply.writeLongArray(_result); break; } case TRANSACTION_RepeatNullableString: { java.lang.String _arg0; _arg0 = data.readString(); data.enforceNoDataAvail(); java.lang.String _result = this.RepeatNullableString(_arg0); reply.writeNoException(); reply.writeString(_result); break; } case TRANSACTION_RepeatNullableStringList: { java.util.List _arg0; _arg0 = data.createStringArrayList(); data.enforceNoDataAvail(); java.util.List _result = this.RepeatNullableStringList(_arg0); reply.writeNoException(); reply.writeStringList(_result); break; } case TRANSACTION_RepeatNullableParcelable: { android.aidl.tests.ITestService.Empty _arg0; _arg0 = data.readTypedObject(android.aidl.tests.ITestService.Empty.CREATOR); data.enforceNoDataAvail(); android.aidl.tests.ITestService.Empty _result = this.RepeatNullableParcelable(_arg0); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_RepeatNullableParcelableArray: { android.aidl.tests.ITestService.Empty[] _arg0; _arg0 = data.createTypedArray(android.aidl.tests.ITestService.Empty.CREATOR); data.enforceNoDataAvail(); android.aidl.tests.ITestService.Empty[] _result = this.RepeatNullableParcelableArray(_arg0); reply.writeNoException(); reply.writeTypedArray(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_RepeatNullableParcelableList: { java.util.List _arg0; _arg0 = data.createTypedArrayList(android.aidl.tests.ITestService.Empty.CREATOR); data.enforceNoDataAvail(); java.util.List _result = this.RepeatNullableParcelableList(_arg0); reply.writeNoException(); reply.writeTypedList(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_TakesAnIBinder: { android.os.IBinder _arg0; _arg0 = data.readStrongBinder(); data.enforceNoDataAvail(); this.TakesAnIBinder(_arg0); reply.writeNoException(); break; } case TRANSACTION_TakesANullableIBinder: { android.os.IBinder _arg0; _arg0 = data.readStrongBinder(); data.enforceNoDataAvail(); this.TakesANullableIBinder(_arg0); reply.writeNoException(); break; } case TRANSACTION_TakesAnIBinderList: { java.util.List _arg0; _arg0 = data.createBinderArrayList(); data.enforceNoDataAvail(); this.TakesAnIBinderList(_arg0); reply.writeNoException(); break; } case TRANSACTION_TakesANullableIBinderList: { java.util.List _arg0; _arg0 = data.createBinderArrayList(); data.enforceNoDataAvail(); this.TakesANullableIBinderList(_arg0); reply.writeNoException(); break; } case TRANSACTION_RepeatUtf8CppString: { java.lang.String _arg0; _arg0 = data.readString(); data.enforceNoDataAvail(); java.lang.String _result = this.RepeatUtf8CppString(_arg0); reply.writeNoException(); reply.writeString(_result); break; } case TRANSACTION_RepeatNullableUtf8CppString: { java.lang.String _arg0; _arg0 = data.readString(); data.enforceNoDataAvail(); java.lang.String _result = this.RepeatNullableUtf8CppString(_arg0); reply.writeNoException(); reply.writeString(_result); break; } case TRANSACTION_ReverseUtf8CppString: { java.lang.String[] _arg0; _arg0 = data.createStringArray(); java.lang.String[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new java.lang.String[_arg1_length]; } data.enforceNoDataAvail(); java.lang.String[] _result = this.ReverseUtf8CppString(_arg0, _arg1); reply.writeNoException(); reply.writeStringArray(_result); reply.writeStringArray(_arg1); break; } case TRANSACTION_ReverseNullableUtf8CppString: { java.lang.String[] _arg0; _arg0 = data.createStringArray(); java.lang.String[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new java.lang.String[_arg1_length]; } data.enforceNoDataAvail(); java.lang.String[] _result = this.ReverseNullableUtf8CppString(_arg0, _arg1); reply.writeNoException(); reply.writeStringArray(_result); reply.writeStringArray(_arg1); break; } case TRANSACTION_ReverseUtf8CppStringList: { java.util.List _arg0; _arg0 = data.createStringArrayList(); java.util.List _arg1; _arg1 = new java.util.ArrayList(); data.enforceNoDataAvail(); java.util.List _result = this.ReverseUtf8CppStringList(_arg0, _arg1); reply.writeNoException(); reply.writeStringList(_result); reply.writeStringList(_arg1); break; } case TRANSACTION_GetCallback: { boolean _arg0; _arg0 = data.readBoolean(); data.enforceNoDataAvail(); android.aidl.tests.INamedCallback _result = this.GetCallback(_arg0); reply.writeNoException(); reply.writeStrongInterface(_result); break; } case TRANSACTION_FillOutStructuredParcelable: { android.aidl.tests.StructuredParcelable _arg0; _arg0 = data.readTypedObject(android.aidl.tests.StructuredParcelable.CREATOR); data.enforceNoDataAvail(); this.FillOutStructuredParcelable(_arg0); reply.writeNoException(); reply.writeTypedObject(_arg0, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_RepeatExtendableParcelable: { android.aidl.tests.extension.ExtendableParcelable _arg0; _arg0 = data.readTypedObject(android.aidl.tests.extension.ExtendableParcelable.CREATOR); android.aidl.tests.extension.ExtendableParcelable _arg1; _arg1 = new android.aidl.tests.extension.ExtendableParcelable(); data.enforceNoDataAvail(); this.RepeatExtendableParcelable(_arg0, _arg1); reply.writeNoException(); reply.writeTypedObject(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_ReverseList: { android.aidl.tests.RecursiveList _arg0; _arg0 = data.readTypedObject(android.aidl.tests.RecursiveList.CREATOR); data.enforceNoDataAvail(); android.aidl.tests.RecursiveList _result = this.ReverseList(_arg0); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_ReverseIBinderArray: { android.os.IBinder[] _arg0; _arg0 = data.createBinderArray(); android.os.IBinder[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new android.os.IBinder[_arg1_length]; } data.enforceNoDataAvail(); android.os.IBinder[] _result = this.ReverseIBinderArray(_arg0, _arg1); reply.writeNoException(); reply.writeBinderArray(_result); reply.writeBinderArray(_arg1); break; } case TRANSACTION_ReverseNullableIBinderArray: { android.os.IBinder[] _arg0; _arg0 = data.createBinderArray(); android.os.IBinder[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new android.os.IBinder[_arg1_length]; } data.enforceNoDataAvail(); android.os.IBinder[] _result = this.ReverseNullableIBinderArray(_arg0, _arg1); reply.writeNoException(); reply.writeBinderArray(_result); reply.writeBinderArray(_arg1); break; } case TRANSACTION_RepeatSimpleParcelable: { android.aidl.tests.SimpleParcelable _arg0; _arg0 = data.readTypedObject(android.aidl.tests.SimpleParcelable.CREATOR); android.aidl.tests.SimpleParcelable _arg1; _arg1 = new android.aidl.tests.SimpleParcelable(); data.enforceNoDataAvail(); android.aidl.tests.SimpleParcelable _result = this.RepeatSimpleParcelable(_arg0, _arg1); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); reply.writeTypedObject(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_ReverseSimpleParcelables: { android.aidl.tests.SimpleParcelable[] _arg0; _arg0 = data.createTypedArray(android.aidl.tests.SimpleParcelable.CREATOR); android.aidl.tests.SimpleParcelable[] _arg1; int _arg1_length = data.readInt(); if (_arg1_length < 0) { _arg1 = null; } else { _arg1 = new android.aidl.tests.SimpleParcelable[_arg1_length]; } data.enforceNoDataAvail(); android.aidl.tests.SimpleParcelable[] _result = this.ReverseSimpleParcelables(_arg0, _arg1); reply.writeNoException(); reply.writeTypedArray(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); reply.writeTypedArray(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_GetOldNameInterface: { android.aidl.tests.IOldName _result = this.GetOldNameInterface(); reply.writeNoException(); reply.writeStrongInterface(_result); break; } case TRANSACTION_GetNewNameInterface: { android.aidl.tests.INewName _result = this.GetNewNameInterface(); reply.writeNoException(); reply.writeStrongInterface(_result); break; } case TRANSACTION_GetUnionTags: { android.aidl.tests.Union[] _arg0; _arg0 = data.createTypedArray(android.aidl.tests.Union.CREATOR); data.enforceNoDataAvail(); int[] _result = this.GetUnionTags(_arg0); reply.writeNoException(); reply.writeIntArray(_result); break; } case TRANSACTION_GetCppJavaTests: { android.os.IBinder _result = this.GetCppJavaTests(); reply.writeNoException(); reply.writeStrongBinder(_result); break; } case TRANSACTION_getBackendType: { byte _result = this.getBackendType(); reply.writeNoException(); reply.writeByte(_result); break; } case TRANSACTION_GetCircular: { android.aidl.tests.CircularParcelable _arg0; _arg0 = new android.aidl.tests.CircularParcelable(); data.enforceNoDataAvail(); android.aidl.tests.ICircular _result = this.GetCircular(_arg0); reply.writeNoException(); reply.writeStrongInterface(_result); reply.writeTypedObject(_arg0, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.ITestService { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } // This is to emulate a method that is added after the service is implemented. // So the client cannot assume that a call to this method will be successful // or not. However, inside the test environment, we can't build client and // the server with different version of this AIDL file. So, we let the server // actually implement this and intercept the dispatch to the method // inside onTransact(). // WARNING: Must be first method. // This requires hard coding the transaction number. As long as this method is // the first in this interface, it can keep the // "::android::IBinder::FIRST_CALL_TRANSACTION + 0" value and allow // methods to be added and removed. @Override public int UnimplementedMethod(int arg) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); int _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeInt(arg); boolean _status = mRemote.transact(Stub.TRANSACTION_UnimplementedMethod, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().UnimplementedMethod(arg); } } _reply.readException(); _result = _reply.readInt(); } finally { _reply.recycle(); _data.recycle(); } return _result; } /** * @deprecated to make sure we have something in system/tools/aidl which does a compile check * of deprecated and make sure this is reflected in goldens */ @Override public void Deprecated() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_Deprecated, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { getDefaultImpl().Deprecated(); return; } } _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } @Override public void TestOneway() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_TestOneway, _data, null, android.os.IBinder.FLAG_ONEWAY | android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { getDefaultImpl().TestOneway(); return; } } } finally { _data.recycle(); } } // Test that primitives work as parameters and return types. @Override public boolean RepeatBoolean(boolean token) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); boolean _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeBoolean(token); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatBoolean, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatBoolean(token); } } _reply.readException(); _result = _reply.readBoolean(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public byte RepeatByte(byte token) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); byte _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeByte(token); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatByte, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatByte(token); } } _reply.readException(); _result = _reply.readByte(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public char RepeatChar(char token) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); char _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeInt(((int)token)); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatChar, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatChar(token); } } _reply.readException(); _result = (char)_reply.readInt(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int RepeatInt(int token) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); int _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeInt(token); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatInt, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatInt(token); } } _reply.readException(); _result = _reply.readInt(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public long RepeatLong(long token) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); long _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeLong(token); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatLong, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatLong(token); } } _reply.readException(); _result = _reply.readLong(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public float RepeatFloat(float token) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); float _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeFloat(token); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatFloat, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatFloat(token); } } _reply.readException(); _result = _reply.readFloat(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public double RepeatDouble(double token) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); double _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeDouble(token); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatDouble, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatDouble(token); } } _reply.readException(); _result = _reply.readDouble(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.lang.String RepeatString(java.lang.String token) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); java.lang.String _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeString(token); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatString, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatString(token); } } _reply.readException(); _result = _reply.readString(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public byte RepeatByteEnum(byte token) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); byte _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeByte(token); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatByteEnum, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatByteEnum(token); } } _reply.readException(); _result = _reply.readByte(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int RepeatIntEnum(int token) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); int _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeInt(token); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatIntEnum, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatIntEnum(token); } } _reply.readException(); _result = _reply.readInt(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public long RepeatLongEnum(long token) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); long _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeLong(token); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatLongEnum, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatLongEnum(token); } } _reply.readException(); _result = _reply.readLong(); } finally { _reply.recycle(); _data.recycle(); } return _result; } // Test that arrays work as parameters and return types. @Override public boolean[] ReverseBoolean(boolean[] input, boolean[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); boolean[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeBooleanArray(input); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseBoolean, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseBoolean(input, repeated); } } _reply.readException(); _result = _reply.createBooleanArray(); _reply.readBooleanArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public byte[] ReverseByte(byte[] input, byte[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); byte[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeByteArray(input); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseByte, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseByte(input, repeated); } } _reply.readException(); _result = _reply.createByteArray(); _reply.readByteArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public char[] ReverseChar(char[] input, char[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); char[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeCharArray(input); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseChar, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseChar(input, repeated); } } _reply.readException(); _result = _reply.createCharArray(); _reply.readCharArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int[] ReverseInt(int[] input, int[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); int[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeIntArray(input); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseInt, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseInt(input, repeated); } } _reply.readException(); _result = _reply.createIntArray(); _reply.readIntArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public long[] ReverseLong(long[] input, long[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); long[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeLongArray(input); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseLong, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseLong(input, repeated); } } _reply.readException(); _result = _reply.createLongArray(); _reply.readLongArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public float[] ReverseFloat(float[] input, float[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); float[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeFloatArray(input); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseFloat, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseFloat(input, repeated); } } _reply.readException(); _result = _reply.createFloatArray(); _reply.readFloatArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public double[] ReverseDouble(double[] input, double[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); double[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeDoubleArray(input); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseDouble, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseDouble(input, repeated); } } _reply.readException(); _result = _reply.createDoubleArray(); _reply.readDoubleArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.lang.String[] ReverseString(java.lang.String[] input, java.lang.String[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); java.lang.String[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeStringArray(input); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseString, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseString(input, repeated); } } _reply.readException(); _result = _reply.createStringArray(); _reply.readStringArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public byte[] ReverseByteEnum(byte[] input, byte[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); byte[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeByteArray(input); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseByteEnum, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseByteEnum(input, repeated); } } _reply.readException(); _result = _reply.createByteArray(); _reply.readByteArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int[] ReverseIntEnum(int[] input, int[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); int[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeIntArray(input); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseIntEnum, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseIntEnum(input, repeated); } } _reply.readException(); _result = _reply.createIntArray(); _reply.readIntArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public long[] ReverseLongEnum(long[] input, long[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); long[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeLongArray(input); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseLongEnum, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseLongEnum(input, repeated); } } _reply.readException(); _result = _reply.createLongArray(); _reply.readLongArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } // Test that clients can send and receive Binders. @Override public android.aidl.tests.INamedCallback GetOtherTestService(java.lang.String name) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.INamedCallback _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeString(name); boolean _status = mRemote.transact(Stub.TRANSACTION_GetOtherTestService, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); _reply.setPropagateAllowBlocking(); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().GetOtherTestService(name); } } _reply.readException(); _result = android.aidl.tests.INamedCallback.Stub.asInterface(_reply.readStrongBinder()); } finally { _reply.recycle(); _data.recycle(); } return _result; } // returns true if the same service is already registered with the same name @Override public boolean SetOtherTestService(java.lang.String name, android.aidl.tests.INamedCallback service) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); boolean _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeString(name); _data.writeStrongInterface(service); boolean _status = mRemote.transact(Stub.TRANSACTION_SetOtherTestService, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().SetOtherTestService(name, service); } } _reply.readException(); _result = _reply.readBoolean(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public boolean VerifyName(android.aidl.tests.INamedCallback service, java.lang.String name) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); boolean _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeStrongInterface(service); _data.writeString(name); boolean _status = mRemote.transact(Stub.TRANSACTION_VerifyName, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().VerifyName(service, name); } } _reply.readException(); _result = _reply.readBoolean(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.tests.INamedCallback[] GetInterfaceArray(java.lang.String[] names) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.INamedCallback[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeStringArray(names); boolean _status = mRemote.transact(Stub.TRANSACTION_GetInterfaceArray, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().GetInterfaceArray(names); } } _reply.readException(); _result = _reply.createInterfaceArray(android.aidl.tests.INamedCallback[]::new, android.aidl.tests.INamedCallback.Stub::asInterface); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public boolean VerifyNamesWithInterfaceArray(android.aidl.tests.INamedCallback[] services, java.lang.String[] names) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); boolean _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeInterfaceArray(services); _data.writeStringArray(names); boolean _status = mRemote.transact(Stub.TRANSACTION_VerifyNamesWithInterfaceArray, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().VerifyNamesWithInterfaceArray(services, names); } } _reply.readException(); _result = _reply.readBoolean(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.tests.INamedCallback[] GetNullableInterfaceArray(java.lang.String[] names) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.INamedCallback[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeStringArray(names); boolean _status = mRemote.transact(Stub.TRANSACTION_GetNullableInterfaceArray, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().GetNullableInterfaceArray(names); } } _reply.readException(); _result = _reply.createInterfaceArray(android.aidl.tests.INamedCallback[]::new, android.aidl.tests.INamedCallback.Stub::asInterface); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public boolean VerifyNamesWithNullableInterfaceArray(android.aidl.tests.INamedCallback[] services, java.lang.String[] names) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); boolean _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeInterfaceArray(services); _data.writeStringArray(names); boolean _status = mRemote.transact(Stub.TRANSACTION_VerifyNamesWithNullableInterfaceArray, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().VerifyNamesWithNullableInterfaceArray(services, names); } } _reply.readException(); _result = _reply.readBoolean(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.util.List GetInterfaceList(java.lang.String[] names) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); java.util.List _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeStringArray(names); boolean _status = mRemote.transact(Stub.TRANSACTION_GetInterfaceList, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().GetInterfaceList(names); } } _reply.readException(); _result = _reply.createInterfaceArrayList(android.aidl.tests.INamedCallback.Stub::asInterface); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public boolean VerifyNamesWithInterfaceList(java.util.List services, java.lang.String[] names) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); boolean _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeInterfaceList(services); _data.writeStringArray(names); boolean _status = mRemote.transact(Stub.TRANSACTION_VerifyNamesWithInterfaceList, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().VerifyNamesWithInterfaceList(services, names); } } _reply.readException(); _result = _reply.readBoolean(); } finally { _reply.recycle(); _data.recycle(); } return _result; } // Test that List types work correctly. @Override public java.util.List ReverseStringList(java.util.List input, java.util.List repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); java.util.List _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeStringList(input); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseStringList, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseStringList(input, repeated); } } _reply.readException(); _result = _reply.createStringArrayList(); _reply.readStringList(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.os.ParcelFileDescriptor RepeatParcelFileDescriptor(android.os.ParcelFileDescriptor read) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); android.os.ParcelFileDescriptor _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(read, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatParcelFileDescriptor, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatParcelFileDescriptor(read); } } _reply.readException(); _result = _reply.readTypedObject(android.os.ParcelFileDescriptor.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.os.ParcelFileDescriptor[] ReverseParcelFileDescriptorArray(android.os.ParcelFileDescriptor[] input, android.os.ParcelFileDescriptor[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); android.os.ParcelFileDescriptor[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedArray(input, 0); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseParcelFileDescriptorArray, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseParcelFileDescriptorArray(input, repeated); } } _reply.readException(); _result = _reply.createTypedArray(android.os.ParcelFileDescriptor.CREATOR); _reply.readTypedArray(repeated, android.os.ParcelFileDescriptor.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } // Test that service specific exceptions work correctly. @Override public void ThrowServiceException(int code) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeInt(code); boolean _status = mRemote.transact(Stub.TRANSACTION_ThrowServiceException, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { getDefaultImpl().ThrowServiceException(code); return; } } _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } // Test nullability @Override public int[] RepeatNullableIntArray(int[] input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); int[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeIntArray(input); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatNullableIntArray, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatNullableIntArray(input); } } _reply.readException(); _result = _reply.createIntArray(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public byte[] RepeatNullableByteEnumArray(byte[] input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); byte[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeByteArray(input); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatNullableByteEnumArray, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatNullableByteEnumArray(input); } } _reply.readException(); _result = _reply.createByteArray(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int[] RepeatNullableIntEnumArray(int[] input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); int[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeIntArray(input); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatNullableIntEnumArray, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatNullableIntEnumArray(input); } } _reply.readException(); _result = _reply.createIntArray(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public long[] RepeatNullableLongEnumArray(long[] input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); long[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeLongArray(input); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatNullableLongEnumArray, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatNullableLongEnumArray(input); } } _reply.readException(); _result = _reply.createLongArray(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.lang.String RepeatNullableString(java.lang.String input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); java.lang.String _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeString(input); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatNullableString, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatNullableString(input); } } _reply.readException(); _result = _reply.readString(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.util.List RepeatNullableStringList(java.util.List input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); java.util.List _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeStringList(input); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatNullableStringList, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatNullableStringList(input); } } _reply.readException(); _result = _reply.createStringArrayList(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.tests.ITestService.Empty RepeatNullableParcelable(android.aidl.tests.ITestService.Empty input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.ITestService.Empty _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatNullableParcelable, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatNullableParcelable(input); } } _reply.readException(); _result = _reply.readTypedObject(android.aidl.tests.ITestService.Empty.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.tests.ITestService.Empty[] RepeatNullableParcelableArray(android.aidl.tests.ITestService.Empty[] input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.ITestService.Empty[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedArray(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatNullableParcelableArray, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatNullableParcelableArray(input); } } _reply.readException(); _result = _reply.createTypedArray(android.aidl.tests.ITestService.Empty.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.util.List RepeatNullableParcelableList(java.util.List input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); java.util.List _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedList(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatNullableParcelableList, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatNullableParcelableList(input); } } _reply.readException(); _result = _reply.createTypedArrayList(android.aidl.tests.ITestService.Empty.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public void TakesAnIBinder(android.os.IBinder input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeStrongBinder(input); boolean _status = mRemote.transact(Stub.TRANSACTION_TakesAnIBinder, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { getDefaultImpl().TakesAnIBinder(input); return; } } _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } @Override public void TakesANullableIBinder(android.os.IBinder input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeStrongBinder(input); boolean _status = mRemote.transact(Stub.TRANSACTION_TakesANullableIBinder, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { getDefaultImpl().TakesANullableIBinder(input); return; } } _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } @Override public void TakesAnIBinderList(java.util.List input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeBinderList(input); boolean _status = mRemote.transact(Stub.TRANSACTION_TakesAnIBinderList, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { getDefaultImpl().TakesAnIBinderList(input); return; } } _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } @Override public void TakesANullableIBinderList(java.util.List input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeBinderList(input); boolean _status = mRemote.transact(Stub.TRANSACTION_TakesANullableIBinderList, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { getDefaultImpl().TakesANullableIBinderList(input); return; } } _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } // Test utf8 decoding from utf16 wire format @Override public java.lang.String RepeatUtf8CppString(java.lang.String token) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); java.lang.String _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeString(token); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatUtf8CppString, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatUtf8CppString(token); } } _reply.readException(); _result = _reply.readString(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.lang.String RepeatNullableUtf8CppString(java.lang.String token) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); java.lang.String _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeString(token); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatNullableUtf8CppString, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatNullableUtf8CppString(token); } } _reply.readException(); _result = _reply.readString(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.lang.String[] ReverseUtf8CppString(java.lang.String[] input, java.lang.String[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); java.lang.String[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeStringArray(input); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseUtf8CppString, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseUtf8CppString(input, repeated); } } _reply.readException(); _result = _reply.createStringArray(); _reply.readStringArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.lang.String[] ReverseNullableUtf8CppString(java.lang.String[] input, java.lang.String[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); java.lang.String[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeStringArray(input); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseNullableUtf8CppString, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseNullableUtf8CppString(input, repeated); } } _reply.readException(); _result = _reply.createStringArray(); _reply.readStringArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public java.util.List ReverseUtf8CppStringList(java.util.List input, java.util.List repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); java.util.List _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeStringList(input); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseUtf8CppStringList, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseUtf8CppStringList(input, repeated); } } _reply.readException(); _result = _reply.createStringArrayList(); _reply.readStringList(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } /** comment before annotation */ @Override public android.aidl.tests.INamedCallback GetCallback(boolean return_null) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.INamedCallback _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeBoolean(return_null); boolean _status = mRemote.transact(Stub.TRANSACTION_GetCallback, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().GetCallback(return_null); } } _reply.readException(); _result = android.aidl.tests.INamedCallback.Stub.asInterface(_reply.readStrongBinder()); } finally { _reply.recycle(); _data.recycle(); } return _result; } // Since this paracelable has clearly defined default values, it would be // inefficient to use an IPC to fill it out in practice. @Override public void FillOutStructuredParcelable(android.aidl.tests.StructuredParcelable parcel) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(parcel, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_FillOutStructuredParcelable, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { getDefaultImpl().FillOutStructuredParcelable(parcel); return; } } _reply.readException(); if ((0!=_reply.readInt())) { parcel.readFromParcel(_reply); } } finally { _reply.recycle(); _data.recycle(); } } @Override public void RepeatExtendableParcelable(android.aidl.tests.extension.ExtendableParcelable ep, android.aidl.tests.extension.ExtendableParcelable ep2) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(ep, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatExtendableParcelable, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { getDefaultImpl().RepeatExtendableParcelable(ep, ep2); return; } } _reply.readException(); if ((0!=_reply.readInt())) { ep2.readFromParcel(_reply); } } finally { _reply.recycle(); _data.recycle(); } } @Override public android.aidl.tests.RecursiveList ReverseList(android.aidl.tests.RecursiveList list) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.RecursiveList _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(list, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseList, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseList(list); } } _reply.readException(); _result = _reply.readTypedObject(android.aidl.tests.RecursiveList.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.os.IBinder[] ReverseIBinderArray(android.os.IBinder[] input, android.os.IBinder[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); android.os.IBinder[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeBinderArray(input); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseIBinderArray, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseIBinderArray(input, repeated); } } _reply.readException(); _result = _reply.createBinderArray(); _reply.readBinderArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.os.IBinder[] ReverseNullableIBinderArray(android.os.IBinder[] input, android.os.IBinder[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); android.os.IBinder[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeBinderArray(input); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseNullableIBinderArray, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseNullableIBinderArray(input, repeated); } } _reply.readException(); _result = _reply.createBinderArray(); _reply.readBinderArray(repeated); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.tests.SimpleParcelable RepeatSimpleParcelable(android.aidl.tests.SimpleParcelable input, android.aidl.tests.SimpleParcelable repeat) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.SimpleParcelable _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_RepeatSimpleParcelable, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().RepeatSimpleParcelable(input, repeat); } } _reply.readException(); _result = _reply.readTypedObject(android.aidl.tests.SimpleParcelable.CREATOR); if ((0!=_reply.readInt())) { repeat.readFromParcel(_reply); } } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.tests.SimpleParcelable[] ReverseSimpleParcelables(android.aidl.tests.SimpleParcelable[] input, android.aidl.tests.SimpleParcelable[] repeated) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.SimpleParcelable[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedArray(input, 0); _data.writeInt(repeated.length); boolean _status = mRemote.transact(Stub.TRANSACTION_ReverseSimpleParcelables, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().ReverseSimpleParcelables(input, repeated); } } _reply.readException(); _result = _reply.createTypedArray(android.aidl.tests.SimpleParcelable.CREATOR); _reply.readTypedArray(repeated, android.aidl.tests.SimpleParcelable.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.tests.IOldName GetOldNameInterface() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.IOldName _result; try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_GetOldNameInterface, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().GetOldNameInterface(); } } _reply.readException(); _result = android.aidl.tests.IOldName.Stub.asInterface(_reply.readStrongBinder()); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.tests.INewName GetNewNameInterface() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.INewName _result; try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_GetNewNameInterface, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().GetNewNameInterface(); } } _reply.readException(); _result = android.aidl.tests.INewName.Stub.asInterface(_reply.readStrongBinder()); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int[] GetUnionTags(android.aidl.tests.Union[] input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); int[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedArray(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_GetUnionTags, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().GetUnionTags(input); } } _reply.readException(); _result = _reply.createIntArray(); } finally { _reply.recycle(); _data.recycle(); } return _result; } // Retrieve the ICppJavaTests if the server supports it @Override public android.os.IBinder GetCppJavaTests() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); android.os.IBinder _result; try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_GetCppJavaTests, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().GetCppJavaTests(); } } _reply.readException(); _result = _reply.readStrongBinder(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public byte getBackendType() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); byte _result; try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getBackendType, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().getBackendType(); } } _reply.readException(); _result = _reply.readByte(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.tests.ICircular GetCircular(android.aidl.tests.CircularParcelable cp) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); _data.markSensitive(); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.ICircular _result; try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_GetCircular, _data, _reply, android.os.IBinder.FLAG_CLEAR_BUF); if (!_status) { if (getDefaultImpl() != null) { return getDefaultImpl().GetCircular(cp); } } _reply.readException(); _result = android.aidl.tests.ICircular.Stub.asInterface(_reply.readStrongBinder()); if ((0!=_reply.readInt())) { cp.readFromParcel(_reply); } } finally { _reply.recycle(); _data.recycle(); } return _result; } public static android.aidl.tests.ITestService sDefaultImpl; } static final int TRANSACTION_UnimplementedMethod = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); static final int TRANSACTION_Deprecated = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1); static final int TRANSACTION_TestOneway = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2); static final int TRANSACTION_RepeatBoolean = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3); static final int TRANSACTION_RepeatByte = (android.os.IBinder.FIRST_CALL_TRANSACTION + 4); static final int TRANSACTION_RepeatChar = (android.os.IBinder.FIRST_CALL_TRANSACTION + 5); static final int TRANSACTION_RepeatInt = (android.os.IBinder.FIRST_CALL_TRANSACTION + 6); static final int TRANSACTION_RepeatLong = (android.os.IBinder.FIRST_CALL_TRANSACTION + 7); static final int TRANSACTION_RepeatFloat = (android.os.IBinder.FIRST_CALL_TRANSACTION + 8); static final int TRANSACTION_RepeatDouble = (android.os.IBinder.FIRST_CALL_TRANSACTION + 9); static final int TRANSACTION_RepeatString = (android.os.IBinder.FIRST_CALL_TRANSACTION + 10); static final int TRANSACTION_RepeatByteEnum = (android.os.IBinder.FIRST_CALL_TRANSACTION + 11); static final int TRANSACTION_RepeatIntEnum = (android.os.IBinder.FIRST_CALL_TRANSACTION + 12); static final int TRANSACTION_RepeatLongEnum = (android.os.IBinder.FIRST_CALL_TRANSACTION + 13); static final int TRANSACTION_ReverseBoolean = (android.os.IBinder.FIRST_CALL_TRANSACTION + 14); static final int TRANSACTION_ReverseByte = (android.os.IBinder.FIRST_CALL_TRANSACTION + 15); static final int TRANSACTION_ReverseChar = (android.os.IBinder.FIRST_CALL_TRANSACTION + 16); static final int TRANSACTION_ReverseInt = (android.os.IBinder.FIRST_CALL_TRANSACTION + 17); static final int TRANSACTION_ReverseLong = (android.os.IBinder.FIRST_CALL_TRANSACTION + 18); static final int TRANSACTION_ReverseFloat = (android.os.IBinder.FIRST_CALL_TRANSACTION + 19); static final int TRANSACTION_ReverseDouble = (android.os.IBinder.FIRST_CALL_TRANSACTION + 20); static final int TRANSACTION_ReverseString = (android.os.IBinder.FIRST_CALL_TRANSACTION + 21); static final int TRANSACTION_ReverseByteEnum = (android.os.IBinder.FIRST_CALL_TRANSACTION + 22); static final int TRANSACTION_ReverseIntEnum = (android.os.IBinder.FIRST_CALL_TRANSACTION + 23); static final int TRANSACTION_ReverseLongEnum = (android.os.IBinder.FIRST_CALL_TRANSACTION + 24); static final int TRANSACTION_GetOtherTestService = (android.os.IBinder.FIRST_CALL_TRANSACTION + 25); static final int TRANSACTION_SetOtherTestService = (android.os.IBinder.FIRST_CALL_TRANSACTION + 26); static final int TRANSACTION_VerifyName = (android.os.IBinder.FIRST_CALL_TRANSACTION + 27); static final int TRANSACTION_GetInterfaceArray = (android.os.IBinder.FIRST_CALL_TRANSACTION + 28); static final int TRANSACTION_VerifyNamesWithInterfaceArray = (android.os.IBinder.FIRST_CALL_TRANSACTION + 29); static final int TRANSACTION_GetNullableInterfaceArray = (android.os.IBinder.FIRST_CALL_TRANSACTION + 30); static final int TRANSACTION_VerifyNamesWithNullableInterfaceArray = (android.os.IBinder.FIRST_CALL_TRANSACTION + 31); static final int TRANSACTION_GetInterfaceList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 32); static final int TRANSACTION_VerifyNamesWithInterfaceList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 33); static final int TRANSACTION_ReverseStringList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 34); static final int TRANSACTION_RepeatParcelFileDescriptor = (android.os.IBinder.FIRST_CALL_TRANSACTION + 35); static final int TRANSACTION_ReverseParcelFileDescriptorArray = (android.os.IBinder.FIRST_CALL_TRANSACTION + 36); static final int TRANSACTION_ThrowServiceException = (android.os.IBinder.FIRST_CALL_TRANSACTION + 37); static final int TRANSACTION_RepeatNullableIntArray = (android.os.IBinder.FIRST_CALL_TRANSACTION + 38); static final int TRANSACTION_RepeatNullableByteEnumArray = (android.os.IBinder.FIRST_CALL_TRANSACTION + 39); static final int TRANSACTION_RepeatNullableIntEnumArray = (android.os.IBinder.FIRST_CALL_TRANSACTION + 40); static final int TRANSACTION_RepeatNullableLongEnumArray = (android.os.IBinder.FIRST_CALL_TRANSACTION + 41); static final int TRANSACTION_RepeatNullableString = (android.os.IBinder.FIRST_CALL_TRANSACTION + 42); static final int TRANSACTION_RepeatNullableStringList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 43); static final int TRANSACTION_RepeatNullableParcelable = (android.os.IBinder.FIRST_CALL_TRANSACTION + 44); static final int TRANSACTION_RepeatNullableParcelableArray = (android.os.IBinder.FIRST_CALL_TRANSACTION + 45); static final int TRANSACTION_RepeatNullableParcelableList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 46); static final int TRANSACTION_TakesAnIBinder = (android.os.IBinder.FIRST_CALL_TRANSACTION + 47); static final int TRANSACTION_TakesANullableIBinder = (android.os.IBinder.FIRST_CALL_TRANSACTION + 48); static final int TRANSACTION_TakesAnIBinderList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 49); static final int TRANSACTION_TakesANullableIBinderList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 50); static final int TRANSACTION_RepeatUtf8CppString = (android.os.IBinder.FIRST_CALL_TRANSACTION + 51); static final int TRANSACTION_RepeatNullableUtf8CppString = (android.os.IBinder.FIRST_CALL_TRANSACTION + 52); static final int TRANSACTION_ReverseUtf8CppString = (android.os.IBinder.FIRST_CALL_TRANSACTION + 53); static final int TRANSACTION_ReverseNullableUtf8CppString = (android.os.IBinder.FIRST_CALL_TRANSACTION + 54); static final int TRANSACTION_ReverseUtf8CppStringList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 55); static final int TRANSACTION_GetCallback = (android.os.IBinder.FIRST_CALL_TRANSACTION + 56); static final int TRANSACTION_FillOutStructuredParcelable = (android.os.IBinder.FIRST_CALL_TRANSACTION + 57); static final int TRANSACTION_RepeatExtendableParcelable = (android.os.IBinder.FIRST_CALL_TRANSACTION + 58); static final int TRANSACTION_ReverseList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 59); static final int TRANSACTION_ReverseIBinderArray = (android.os.IBinder.FIRST_CALL_TRANSACTION + 60); static final int TRANSACTION_ReverseNullableIBinderArray = (android.os.IBinder.FIRST_CALL_TRANSACTION + 61); static final int TRANSACTION_RepeatSimpleParcelable = (android.os.IBinder.FIRST_CALL_TRANSACTION + 62); static final int TRANSACTION_ReverseSimpleParcelables = (android.os.IBinder.FIRST_CALL_TRANSACTION + 63); static final int TRANSACTION_GetOldNameInterface = (android.os.IBinder.FIRST_CALL_TRANSACTION + 64); static final int TRANSACTION_GetNewNameInterface = (android.os.IBinder.FIRST_CALL_TRANSACTION + 65); static final int TRANSACTION_GetUnionTags = (android.os.IBinder.FIRST_CALL_TRANSACTION + 66); static final int TRANSACTION_GetCppJavaTests = (android.os.IBinder.FIRST_CALL_TRANSACTION + 67); static final int TRANSACTION_getBackendType = (android.os.IBinder.FIRST_CALL_TRANSACTION + 68); static final int TRANSACTION_GetCircular = (android.os.IBinder.FIRST_CALL_TRANSACTION + 69); /** @hide */ public int getMaxTransactionId() { return 69; } public static boolean setDefaultImpl(android.aidl.tests.ITestService impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. if (Stub.Proxy.sDefaultImpl != null) { throw new IllegalStateException("setDefaultImpl() called twice"); } if (impl != null) { Stub.Proxy.sDefaultImpl = impl; return true; } return false; } public static android.aidl.tests.ITestService getDefaultImpl() { return Stub.Proxy.sDefaultImpl; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.ITestService"; // Test that constants are accessible /** extra doc comment */ // extra line comment /* extra regular comment */ /** const comment */ public static final int CONSTANT = 42; public static final int CONSTANT2 = -42; public static final int CONSTANT3 = 42; public static final int CONSTANT4 = 4; public static final int CONSTANT5 = -4; public static final int CONSTANT6 = 0; public static final int CONSTANT7 = 0; public static final int CONSTANT8 = 0; public static final int CONSTANT9 = 86; public static final int CONSTANT10 = 165; public static final int CONSTANT11 = 250; public static final int CONSTANT12 = -1; public static final byte BYTE_CONSTANT = 17; public static final long LONG_CONSTANT = 1099511627776L; public static final String STRING_CONSTANT = "foo"; public static final String STRING_CONSTANT2 = "bar"; public static final float FLOAT_CONSTANT = 1.000000f; public static final float FLOAT_CONSTANT2 = -1.000000f; public static final float FLOAT_CONSTANT3 = 1.000000f; public static final float FLOAT_CONSTANT4 = 2.200000f; public static final float FLOAT_CONSTANT5 = -2.200000f; public static final float FLOAT_CONSTANT6 = -0.000000f; public static final float FLOAT_CONSTANT7 = 0.000000f; public static final double DOUBLE_CONSTANT = 1.000000; public static final double DOUBLE_CONSTANT2 = -1.000000; public static final double DOUBLE_CONSTANT3 = 1.000000; public static final double DOUBLE_CONSTANT4 = 2.200000; public static final double DOUBLE_CONSTANT5 = -2.200000; public static final double DOUBLE_CONSTANT6 = -0.000000; public static final double DOUBLE_CONSTANT7 = 0.000000; public static final double DOUBLE_CONSTANT8 = 1.100000; public static final double DOUBLE_CONSTANT9 = -1.100000; public static final String STRING_CONSTANT_UTF8 = "baz"; // All these constant expressions should be equal to 1 public static final int A1 = 1; public static final int A2 = 1; public static final int A3 = 1; public static final int A4 = 1; public static final int A5 = 1; public static final int A6 = 1; public static final int A7 = 1; public static final int A8 = 1; public static final int A9 = 1; public static final int A10 = 1; public static final int A11 = 1; public static final int A12 = 1; public static final int A13 = 1; public static final int A14 = 1; public static final int A15 = 1; public static final int A16 = 1; public static final int A17 = 1; public static final int A18 = 1; public static final int A19 = 1; public static final int A20 = 1; public static final int A21 = 1; public static final int A22 = 1; public static final int A23 = 1; public static final int A24 = 1; public static final int A25 = 1; public static final int A26 = 1; public static final int A27 = 1; public static final int A28 = 1; public static final int A29 = 1; public static final int A30 = 1; public static final int A31 = 1; public static final int A32 = 1; public static final int A33 = 1; public static final int A34 = 1; public static final int A35 = 1; public static final int A36 = 1; public static final int A37 = 1; public static final int A38 = 1; public static final int A39 = 1; public static final int A40 = 1; public static final int A41 = 1; public static final int A42 = 1; public static final int A43 = 1; public static final int A44 = 1; // && higher than || public static final int A45 = 1; public static final int A46 = 1; public static final int A47 = 1; public static final int A48 = 1; public static final int A49 = 1; public static final int A50 = 1; public static final int A51 = 1; public static final int A52 = 1; public static final int A53 = 1; // & higher than ^ public static final int A54 = 1; public static final int A55 = 1; public static final int A56 = 1; public static final int A57 = 1; // This is to emulate a method that is added after the service is implemented. // So the client cannot assume that a call to this method will be successful // or not. However, inside the test environment, we can't build client and // the server with different version of this AIDL file. So, we let the server // actually implement this and intercept the dispatch to the method // inside onTransact(). // WARNING: Must be first method. // This requires hard coding the transaction number. As long as this method is // the first in this interface, it can keep the // "::android::IBinder::FIRST_CALL_TRANSACTION + 0" value and allow // methods to be added and removed. public int UnimplementedMethod(int arg) throws android.os.RemoteException; /** * @deprecated to make sure we have something in system/tools/aidl which does a compile check * of deprecated and make sure this is reflected in goldens */ @Deprecated public void Deprecated() throws android.os.RemoteException; public void TestOneway() throws android.os.RemoteException; // Test that primitives work as parameters and return types. public boolean RepeatBoolean(boolean token) throws android.os.RemoteException; public byte RepeatByte(byte token) throws android.os.RemoteException; public char RepeatChar(char token) throws android.os.RemoteException; public int RepeatInt(int token) throws android.os.RemoteException; public long RepeatLong(long token) throws android.os.RemoteException; public float RepeatFloat(float token) throws android.os.RemoteException; public double RepeatDouble(double token) throws android.os.RemoteException; public java.lang.String RepeatString(java.lang.String token) throws android.os.RemoteException; public byte RepeatByteEnum(byte token) throws android.os.RemoteException; public int RepeatIntEnum(int token) throws android.os.RemoteException; public long RepeatLongEnum(long token) throws android.os.RemoteException; // Test that arrays work as parameters and return types. public boolean[] ReverseBoolean(boolean[] input, boolean[] repeated) throws android.os.RemoteException; public byte[] ReverseByte(byte[] input, byte[] repeated) throws android.os.RemoteException; public char[] ReverseChar(char[] input, char[] repeated) throws android.os.RemoteException; public int[] ReverseInt(int[] input, int[] repeated) throws android.os.RemoteException; public long[] ReverseLong(long[] input, long[] repeated) throws android.os.RemoteException; public float[] ReverseFloat(float[] input, float[] repeated) throws android.os.RemoteException; public double[] ReverseDouble(double[] input, double[] repeated) throws android.os.RemoteException; public java.lang.String[] ReverseString(java.lang.String[] input, java.lang.String[] repeated) throws android.os.RemoteException; public byte[] ReverseByteEnum(byte[] input, byte[] repeated) throws android.os.RemoteException; public int[] ReverseIntEnum(int[] input, int[] repeated) throws android.os.RemoteException; public long[] ReverseLongEnum(long[] input, long[] repeated) throws android.os.RemoteException; // Test that clients can send and receive Binders. public android.aidl.tests.INamedCallback GetOtherTestService(java.lang.String name) throws android.os.RemoteException; // returns true if the same service is already registered with the same name public boolean SetOtherTestService(java.lang.String name, android.aidl.tests.INamedCallback service) throws android.os.RemoteException; public boolean VerifyName(android.aidl.tests.INamedCallback service, java.lang.String name) throws android.os.RemoteException; public android.aidl.tests.INamedCallback[] GetInterfaceArray(java.lang.String[] names) throws android.os.RemoteException; public boolean VerifyNamesWithInterfaceArray(android.aidl.tests.INamedCallback[] services, java.lang.String[] names) throws android.os.RemoteException; public android.aidl.tests.INamedCallback[] GetNullableInterfaceArray(java.lang.String[] names) throws android.os.RemoteException; public boolean VerifyNamesWithNullableInterfaceArray(android.aidl.tests.INamedCallback[] services, java.lang.String[] names) throws android.os.RemoteException; public java.util.List GetInterfaceList(java.lang.String[] names) throws android.os.RemoteException; public boolean VerifyNamesWithInterfaceList(java.util.List services, java.lang.String[] names) throws android.os.RemoteException; // Test that List types work correctly. public java.util.List ReverseStringList(java.util.List input, java.util.List repeated) throws android.os.RemoteException; public android.os.ParcelFileDescriptor RepeatParcelFileDescriptor(android.os.ParcelFileDescriptor read) throws android.os.RemoteException; public android.os.ParcelFileDescriptor[] ReverseParcelFileDescriptorArray(android.os.ParcelFileDescriptor[] input, android.os.ParcelFileDescriptor[] repeated) throws android.os.RemoteException; // Test that service specific exceptions work correctly. public void ThrowServiceException(int code) throws android.os.RemoteException; // Test nullability public int[] RepeatNullableIntArray(int[] input) throws android.os.RemoteException; public byte[] RepeatNullableByteEnumArray(byte[] input) throws android.os.RemoteException; public int[] RepeatNullableIntEnumArray(int[] input) throws android.os.RemoteException; public long[] RepeatNullableLongEnumArray(long[] input) throws android.os.RemoteException; public java.lang.String RepeatNullableString(java.lang.String input) throws android.os.RemoteException; public java.util.List RepeatNullableStringList(java.util.List input) throws android.os.RemoteException; public android.aidl.tests.ITestService.Empty RepeatNullableParcelable(android.aidl.tests.ITestService.Empty input) throws android.os.RemoteException; public android.aidl.tests.ITestService.Empty[] RepeatNullableParcelableArray(android.aidl.tests.ITestService.Empty[] input) throws android.os.RemoteException; public java.util.List RepeatNullableParcelableList(java.util.List input) throws android.os.RemoteException; public void TakesAnIBinder(android.os.IBinder input) throws android.os.RemoteException; public void TakesANullableIBinder(android.os.IBinder input) throws android.os.RemoteException; public void TakesAnIBinderList(java.util.List input) throws android.os.RemoteException; public void TakesANullableIBinderList(java.util.List input) throws android.os.RemoteException; // Test utf8 decoding from utf16 wire format public java.lang.String RepeatUtf8CppString(java.lang.String token) throws android.os.RemoteException; public java.lang.String RepeatNullableUtf8CppString(java.lang.String token) throws android.os.RemoteException; public java.lang.String[] ReverseUtf8CppString(java.lang.String[] input, java.lang.String[] repeated) throws android.os.RemoteException; public java.lang.String[] ReverseNullableUtf8CppString(java.lang.String[] input, java.lang.String[] repeated) throws android.os.RemoteException; public java.util.List ReverseUtf8CppStringList(java.util.List input, java.util.List repeated) throws android.os.RemoteException; /** comment before annotation */ public android.aidl.tests.INamedCallback GetCallback(boolean return_null) throws android.os.RemoteException; // Since this paracelable has clearly defined default values, it would be // inefficient to use an IPC to fill it out in practice. public void FillOutStructuredParcelable(android.aidl.tests.StructuredParcelable parcel) throws android.os.RemoteException; public void RepeatExtendableParcelable(android.aidl.tests.extension.ExtendableParcelable ep, android.aidl.tests.extension.ExtendableParcelable ep2) throws android.os.RemoteException; public android.aidl.tests.RecursiveList ReverseList(android.aidl.tests.RecursiveList list) throws android.os.RemoteException; public android.os.IBinder[] ReverseIBinderArray(android.os.IBinder[] input, android.os.IBinder[] repeated) throws android.os.RemoteException; public android.os.IBinder[] ReverseNullableIBinderArray(android.os.IBinder[] input, android.os.IBinder[] repeated) throws android.os.RemoteException; public android.aidl.tests.SimpleParcelable RepeatSimpleParcelable(android.aidl.tests.SimpleParcelable input, android.aidl.tests.SimpleParcelable repeat) throws android.os.RemoteException; public android.aidl.tests.SimpleParcelable[] ReverseSimpleParcelables(android.aidl.tests.SimpleParcelable[] input, android.aidl.tests.SimpleParcelable[] repeated) throws android.os.RemoteException; public android.aidl.tests.IOldName GetOldNameInterface() throws android.os.RemoteException; public android.aidl.tests.INewName GetNewNameInterface() throws android.os.RemoteException; public int[] GetUnionTags(android.aidl.tests.Union[] input) throws android.os.RemoteException; // Retrieve the ICppJavaTests if the server supports it public android.os.IBinder GetCppJavaTests() throws android.os.RemoteException; public byte getBackendType() throws android.os.RemoteException; public android.aidl.tests.ICircular GetCircular(android.aidl.tests.CircularParcelable cp) throws android.os.RemoteException; // Small empty parcelable for nullability check public static class Empty implements android.os.Parcelable { public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public Empty createFromParcel(android.os.Parcel _aidl_source) { Empty _aidl_out = new Empty(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public Empty[] newArray(int _aidl_size) { return new Empty[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public boolean equals(Object other) { if (this == other) return true; if (other == null) return false; if (!(other instanceof Empty)) return false; Empty that = (Empty)other; return true; } @Override public int hashCode() { return java.util.Arrays.deepHashCode(java.util.Arrays.asList().toArray()); } @Override public int describeContents() { int _mask = 0; return _mask; } } public static class CompilerChecks implements android.os.Parcelable { // IBinder public android.os.IBinder binder; public android.os.IBinder nullable_binder; public android.os.IBinder[] binder_array; public android.os.IBinder[] nullable_binder_array; public java.util.List binder_list; public java.util.List nullable_binder_list; // ParcelFileDescriptor public android.os.ParcelFileDescriptor pfd; public android.os.ParcelFileDescriptor nullable_pfd; public android.os.ParcelFileDescriptor[] pfd_array; public android.os.ParcelFileDescriptor[] nullable_pfd_array; public java.util.List pfd_list; public java.util.List nullable_pfd_list; // parcelable public android.aidl.tests.ITestService.Empty parcel; public android.aidl.tests.ITestService.Empty nullable_parcel; public android.aidl.tests.ITestService.Empty[] parcel_array; public android.aidl.tests.ITestService.Empty[] nullable_parcel_array; public java.util.List parcel_list; public java.util.List nullable_parcel_list; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public CompilerChecks createFromParcel(android.os.Parcel _aidl_source) { CompilerChecks _aidl_out = new CompilerChecks(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public CompilerChecks[] newArray(int _aidl_size) { return new CompilerChecks[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeStrongBinder(binder); _aidl_parcel.writeStrongBinder(nullable_binder); _aidl_parcel.writeBinderArray(binder_array); _aidl_parcel.writeBinderArray(nullable_binder_array); _aidl_parcel.writeBinderList(binder_list); _aidl_parcel.writeBinderList(nullable_binder_list); _aidl_parcel.writeTypedObject(pfd, _aidl_flag); _aidl_parcel.writeTypedObject(nullable_pfd, _aidl_flag); _aidl_parcel.writeTypedArray(pfd_array, _aidl_flag); _aidl_parcel.writeTypedArray(nullable_pfd_array, _aidl_flag); _aidl_parcel.writeTypedList(pfd_list, _aidl_flag); _aidl_parcel.writeTypedList(nullable_pfd_list, _aidl_flag); _aidl_parcel.writeTypedObject(parcel, _aidl_flag); _aidl_parcel.writeTypedObject(nullable_parcel, _aidl_flag); _aidl_parcel.writeTypedArray(parcel_array, _aidl_flag); _aidl_parcel.writeTypedArray(nullable_parcel_array, _aidl_flag); _aidl_parcel.writeTypedList(parcel_list, _aidl_flag); _aidl_parcel.writeTypedList(nullable_parcel_list, _aidl_flag); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; binder = _aidl_parcel.readStrongBinder(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; nullable_binder = _aidl_parcel.readStrongBinder(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; binder_array = _aidl_parcel.createBinderArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; nullable_binder_array = _aidl_parcel.createBinderArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; binder_list = _aidl_parcel.createBinderArrayList(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; nullable_binder_list = _aidl_parcel.createBinderArrayList(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; pfd = _aidl_parcel.readTypedObject(android.os.ParcelFileDescriptor.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; nullable_pfd = _aidl_parcel.readTypedObject(android.os.ParcelFileDescriptor.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; pfd_array = _aidl_parcel.createTypedArray(android.os.ParcelFileDescriptor.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; nullable_pfd_array = _aidl_parcel.createTypedArray(android.os.ParcelFileDescriptor.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; pfd_list = _aidl_parcel.createTypedArrayList(android.os.ParcelFileDescriptor.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; nullable_pfd_list = _aidl_parcel.createTypedArrayList(android.os.ParcelFileDescriptor.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; parcel = _aidl_parcel.readTypedObject(android.aidl.tests.ITestService.Empty.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; nullable_parcel = _aidl_parcel.readTypedObject(android.aidl.tests.ITestService.Empty.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; parcel_array = _aidl_parcel.createTypedArray(android.aidl.tests.ITestService.Empty.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; nullable_parcel_array = _aidl_parcel.createTypedArray(android.aidl.tests.ITestService.Empty.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; parcel_list = _aidl_parcel.createTypedArrayList(android.aidl.tests.ITestService.Empty.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; nullable_parcel_list = _aidl_parcel.createTypedArrayList(android.aidl.tests.ITestService.Empty.CREATOR); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; _mask |= describeContents(pfd); _mask |= describeContents(nullable_pfd); _mask |= describeContents(pfd_array); _mask |= describeContents(nullable_pfd_array); _mask |= describeContents(pfd_list); _mask |= describeContents(nullable_pfd_list); _mask |= describeContents(parcel); _mask |= describeContents(nullable_parcel); _mask |= describeContents(parcel_array); _mask |= describeContents(nullable_parcel_array); _mask |= describeContents(parcel_list); _mask |= describeContents(nullable_parcel_list); return _mask; } private int describeContents(Object _v) { if (_v == null) return 0; if (_v instanceof Object[]) { int _mask = 0; for (Object o : (Object[]) _v) { _mask |= describeContents(o); } return _mask; } if (_v instanceof java.util.Collection) { int _mask = 0; for (Object o : (java.util.Collection) _v) { _mask |= describeContents(o); } return _mask; } if (_v instanceof android.os.Parcelable) { return ((android.os.Parcelable) _v).describeContents(); } return 0; } // interface without I- public interface Foo extends android.os.IInterface { /** Default implementation for Foo. */ public static class Default implements android.aidl.tests.ITestService.CompilerChecks.Foo { @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.ITestService.CompilerChecks.Foo { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.ITestService.CompilerChecks.Foo interface, * generating a proxy if needed. */ public static android.aidl.tests.ITestService.CompilerChecks.Foo asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.ITestService.CompilerChecks.Foo))) { return ((android.aidl.tests.ITestService.CompilerChecks.Foo)iin); } return new android.aidl.tests.ITestService.CompilerChecks.Foo.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { default: { return super.onTransact(code, data, reply, flags); } } } private static class Proxy implements android.aidl.tests.ITestService.CompilerChecks.Foo { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } } /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.ITestService.CompilerChecks.Foo"; } public static class HasDeprecated implements android.os.Parcelable { /** @deprecated field */ @Deprecated public int deprecated = 0; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public HasDeprecated createFromParcel(android.os.Parcel _aidl_source) { HasDeprecated _aidl_out = new HasDeprecated(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public HasDeprecated[] newArray(int _aidl_size) { return new HasDeprecated[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(deprecated); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; deprecated = _aidl_parcel.readInt(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } } public static final class UsingHasDeprecated implements android.os.Parcelable { // tags for union fields public final static int n = 0; // int n; public final static int m = 1; // android.aidl.tests.ITestService.CompilerChecks.HasDeprecated m; private int _tag; private Object _value; public UsingHasDeprecated() { int _value = 0; this._tag = n; this._value = _value; } private UsingHasDeprecated(android.os.Parcel _aidl_parcel) { readFromParcel(_aidl_parcel); } private UsingHasDeprecated(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public int getTag() { return _tag; } // int n; public static UsingHasDeprecated n(int _value) { return new UsingHasDeprecated(n, _value); } public int getN() { _assertTag(n); return (int) _value; } public void setN(int _value) { _set(n, _value); } // android.aidl.tests.ITestService.CompilerChecks.HasDeprecated m; public static UsingHasDeprecated m(android.aidl.tests.ITestService.CompilerChecks.HasDeprecated _value) { return new UsingHasDeprecated(m, _value); } public android.aidl.tests.ITestService.CompilerChecks.HasDeprecated getM() { _assertTag(m); return (android.aidl.tests.ITestService.CompilerChecks.HasDeprecated) _value; } public void setM(android.aidl.tests.ITestService.CompilerChecks.HasDeprecated _value) { _set(m, _value); } public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public UsingHasDeprecated createFromParcel(android.os.Parcel _aidl_source) { return new UsingHasDeprecated(_aidl_source); } @Override public UsingHasDeprecated[] newArray(int _aidl_size) { return new UsingHasDeprecated[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { _aidl_parcel.writeInt(_tag); switch (_tag) { case n: _aidl_parcel.writeInt(getN()); break; case m: _aidl_parcel.writeTypedObject(getM(), _aidl_flag); break; } } public void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_tag; _aidl_tag = _aidl_parcel.readInt(); switch (_aidl_tag) { case n: { int _aidl_value; _aidl_value = _aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } case m: { android.aidl.tests.ITestService.CompilerChecks.HasDeprecated _aidl_value; _aidl_value = _aidl_parcel.readTypedObject(android.aidl.tests.ITestService.CompilerChecks.HasDeprecated.CREATOR); _set(_aidl_tag, _aidl_value); return; } } throw new IllegalArgumentException("union: unknown tag: " + _aidl_tag); } @Override public int describeContents() { int _mask = 0; switch (getTag()) { case m: _mask |= describeContents(getM()); break; } return _mask; } private int describeContents(Object _v) { if (_v == null) return 0; if (_v instanceof android.os.Parcelable) { return ((android.os.Parcelable) _v).describeContents(); } return 0; } private void _assertTag(int tag) { if (getTag() != tag) { throw new IllegalStateException("bad access: " + _tagString(tag) + ", " + _tagString(getTag()) + " is available."); } } private String _tagString(int _tag) { switch (_tag) { case n: return "n"; case m: return "m"; } throw new IllegalStateException("unknown field: " + _tag); } private void _set(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public static @interface Tag { public static final int n = 0; public static final int m = 1; } } public interface NoPrefixInterface extends android.os.IInterface { /** Default implementation for NoPrefixInterface. */ public static class Default implements android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface { @Override public void foo() throws android.os.RemoteException { } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface interface, * generating a proxy if needed. */ public static android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface))) { return ((android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface)iin); } return new android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_foo: { return "foo"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_foo: { this.foo(); reply.writeNoException(); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public void foo() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_foo, _data, _reply, 0); _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } } static final int TRANSACTION_foo = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface"; public void foo() throws android.os.RemoteException; public static class Nested implements android.os.Parcelable { public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public Nested createFromParcel(android.os.Parcel _aidl_source) { Nested _aidl_out = new Nested(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public Nested[] newArray(int _aidl_size) { return new Nested[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } } public interface NestedNoPrefixInterface extends android.os.IInterface { /** Default implementation for NestedNoPrefixInterface. */ public static class Default implements android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.NestedNoPrefixInterface { @Override public void foo() throws android.os.RemoteException { } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.NestedNoPrefixInterface { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.NestedNoPrefixInterface interface, * generating a proxy if needed. */ public static android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.NestedNoPrefixInterface asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.NestedNoPrefixInterface))) { return ((android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.NestedNoPrefixInterface)iin); } return new android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.NestedNoPrefixInterface.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_foo: { return "foo"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_foo: { this.foo(); reply.writeNoException(); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.NestedNoPrefixInterface { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public void foo() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_foo, _data, _reply, 0); _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } } static final int TRANSACTION_foo = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.NestedNoPrefixInterface"; public void foo() throws android.os.RemoteException; } } } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_IT0100644 0000000 0000000 00000000213 15172120304 033174 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/ITestService.java.d 28 mtime=1776853188.6220000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/ITestService.java.0100644 0000000 0000000 00000002227 15172120304 032737 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/ITestService.java : \ system/tools/aidl/tests/android/aidl/tests/ITestService.aidl \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ICircular.aidl \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl \ system/tools/aidl/tests/android/aidl/tests/SimpleParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_In0100644 0000000 0000000 00000000034 15172120304 033227 xustar000000000 0000000 28 mtime=1776853188.6220000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/IntEnum.java0100644 0000000 0000000 00000003501 15172120304 031663 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/IntEnum.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl */ package android.aidl.tests; public @interface IntEnum { public static final int FOO = 1000; public static final int BAR = 2000; public static final int BAZ = 2001; /** @deprecated do not use this */ @Deprecated public static final int QUX = 2002; interface $ { static String toString(int _aidl_v) { if (_aidl_v == FOO) return "FOO"; if (_aidl_v == BAR) return "BAR"; if (_aidl_v == BAZ) return "BAZ"; if (_aidl_v == QUX) return "QUX"; return Integer.toString(_aidl_v); } static String arrayToString(Object _aidl_v) { if (_aidl_v == null) return "null"; Class _aidl_cls = _aidl_v.getClass(); if (!_aidl_cls.isArray()) throw new IllegalArgumentException("not an array: " + _aidl_v); Class comp = _aidl_cls.getComponentType(); java.util.StringJoiner _aidl_sj = new java.util.StringJoiner(", ", "[", "]"); if (comp.isArray()) { for (int _aidl_i = 0; _aidl_i < java.lang.reflect.Array.getLength(_aidl_v); _aidl_i++) { _aidl_sj.add(arrayToString(java.lang.reflect.Array.get(_aidl_v, _aidl_i))); } } else { if (_aidl_cls != int[].class) throw new IllegalArgumentException("wrong type: " + _aidl_cls); for (int e : (int[]) _aidl_v) { _aidl_sj.add(toString(e)); } } return _aidl_sj.toString(); } } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_In0100644 0000000 0000000 00000000034 15172120304 033227 xustar000000000 0000000 28 mtime=1776853188.6230000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/IntEnum.java.d0100644 0000000 0000000 00000000255 15172120304 032110 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/IntEnum.java : \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_Li0100644 0000000 0000000 00000000215 15172120304 033226 xustar000000000 0000000 113 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/ListOfInterfaces.java 28 mtime=1776853188.6230000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/ListOfInterfaces.j0100644 0000000 0000000 00000065133 15172120304 033031 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/ListOfInterfaces.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ListOfInterfaces.aidl */ package android.aidl.tests; public class ListOfInterfaces implements android.os.Parcelable { public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public ListOfInterfaces createFromParcel(android.os.Parcel _aidl_source) { ListOfInterfaces _aidl_out = new ListOfInterfaces(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public ListOfInterfaces[] newArray(int _aidl_size) { return new ListOfInterfaces[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } public interface IEmptyInterface extends android.os.IInterface { /** Default implementation for IEmptyInterface. */ public static class Default implements android.aidl.tests.ListOfInterfaces.IEmptyInterface { @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.ListOfInterfaces.IEmptyInterface { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.ListOfInterfaces.IEmptyInterface interface, * generating a proxy if needed. */ public static android.aidl.tests.ListOfInterfaces.IEmptyInterface asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.ListOfInterfaces.IEmptyInterface))) { return ((android.aidl.tests.ListOfInterfaces.IEmptyInterface)iin); } return new android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { default: { return super.onTransact(code, data, reply, flags); } } } private static class Proxy implements android.aidl.tests.ListOfInterfaces.IEmptyInterface { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } } /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.ListOfInterfaces.IEmptyInterface"; } public interface IMyInterface extends android.os.IInterface { /** Default implementation for IMyInterface. */ public static class Default implements android.aidl.tests.ListOfInterfaces.IMyInterface { @Override public java.util.List methodWithInterfaces(android.aidl.tests.ListOfInterfaces.IEmptyInterface iface, android.aidl.tests.ListOfInterfaces.IEmptyInterface nullable_iface, java.util.List iface_list_in, java.util.List iface_list_out, java.util.List iface_list_inout, java.util.List nullable_iface_list_in, java.util.List nullable_iface_list_out, java.util.List nullable_iface_list_inout) throws android.os.RemoteException { return null; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.ListOfInterfaces.IMyInterface { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.ListOfInterfaces.IMyInterface interface, * generating a proxy if needed. */ public static android.aidl.tests.ListOfInterfaces.IMyInterface asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.ListOfInterfaces.IMyInterface))) { return ((android.aidl.tests.ListOfInterfaces.IMyInterface)iin); } return new android.aidl.tests.ListOfInterfaces.IMyInterface.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_methodWithInterfaces: { return "methodWithInterfaces"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_methodWithInterfaces: { android.aidl.tests.ListOfInterfaces.IEmptyInterface _arg0; _arg0 = android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub.asInterface(data.readStrongBinder()); android.aidl.tests.ListOfInterfaces.IEmptyInterface _arg1; _arg1 = android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub.asInterface(data.readStrongBinder()); java.util.List _arg2; _arg2 = data.createInterfaceArrayList(android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub::asInterface); java.util.List _arg3; _arg3 = new java.util.ArrayList(); java.util.List _arg4; _arg4 = data.createInterfaceArrayList(android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub::asInterface); java.util.List _arg5; _arg5 = data.createInterfaceArrayList(android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub::asInterface); java.util.List _arg6; _arg6 = new java.util.ArrayList(); java.util.List _arg7; _arg7 = data.createInterfaceArrayList(android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub::asInterface); data.enforceNoDataAvail(); java.util.List _result = this.methodWithInterfaces(_arg0, _arg1, _arg2, _arg3, _arg4, _arg5, _arg6, _arg7); reply.writeNoException(); reply.writeInterfaceList(_result); reply.writeInterfaceList(_arg3); reply.writeInterfaceList(_arg4); reply.writeInterfaceList(_arg6); reply.writeInterfaceList(_arg7); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.ListOfInterfaces.IMyInterface { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public java.util.List methodWithInterfaces(android.aidl.tests.ListOfInterfaces.IEmptyInterface iface, android.aidl.tests.ListOfInterfaces.IEmptyInterface nullable_iface, java.util.List iface_list_in, java.util.List iface_list_out, java.util.List iface_list_inout, java.util.List nullable_iface_list_in, java.util.List nullable_iface_list_out, java.util.List nullable_iface_list_inout) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.util.List _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeStrongInterface(iface); _data.writeStrongInterface(nullable_iface); _data.writeInterfaceList(iface_list_in); _data.writeInterfaceList(iface_list_inout); _data.writeInterfaceList(nullable_iface_list_in); _data.writeInterfaceList(nullable_iface_list_inout); boolean _status = mRemote.transact(Stub.TRANSACTION_methodWithInterfaces, _data, _reply, 0); _reply.readException(); _result = _reply.createInterfaceArrayList(android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub::asInterface); _reply.readInterfaceList(iface_list_out, android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub::asInterface); _reply.readInterfaceList(iface_list_inout, android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub::asInterface); _reply.readInterfaceList(nullable_iface_list_out, android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub::asInterface); _reply.readInterfaceList(nullable_iface_list_inout, android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub::asInterface); } finally { _reply.recycle(); _data.recycle(); } return _result; } } static final int TRANSACTION_methodWithInterfaces = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.ListOfInterfaces.IMyInterface"; public java.util.List methodWithInterfaces(android.aidl.tests.ListOfInterfaces.IEmptyInterface iface, android.aidl.tests.ListOfInterfaces.IEmptyInterface nullable_iface, java.util.List iface_list_in, java.util.List iface_list_out, java.util.List iface_list_inout, java.util.List nullable_iface_list_in, java.util.List nullable_iface_list_out, java.util.List nullable_iface_list_inout) throws android.os.RemoteException; } public static class MyParcelable implements android.os.Parcelable { public android.aidl.tests.ListOfInterfaces.IEmptyInterface iface; public android.aidl.tests.ListOfInterfaces.IEmptyInterface nullable_iface; public java.util.List iface_list; public java.util.List nullable_iface_list; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public MyParcelable createFromParcel(android.os.Parcel _aidl_source) { MyParcelable _aidl_out = new MyParcelable(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public MyParcelable[] newArray(int _aidl_size) { return new MyParcelable[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeStrongInterface(iface); _aidl_parcel.writeStrongInterface(nullable_iface); _aidl_parcel.writeInterfaceList(iface_list); _aidl_parcel.writeInterfaceList(nullable_iface_list); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; iface = android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub.asInterface(_aidl_parcel.readStrongBinder()); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; nullable_iface = android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub.asInterface(_aidl_parcel.readStrongBinder()); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; iface_list = _aidl_parcel.createInterfaceArrayList(android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub::asInterface); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; nullable_iface_list = _aidl_parcel.createInterfaceArrayList(android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub::asInterface); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public String toString() { java.util.StringJoiner _aidl_sj = new java.util.StringJoiner(", ", "{", "}"); _aidl_sj.add("iface: " + (java.util.Objects.toString(iface))); _aidl_sj.add("nullable_iface: " + (java.util.Objects.toString(nullable_iface))); _aidl_sj.add("iface_list: " + (java.util.Objects.toString(iface_list))); _aidl_sj.add("nullable_iface_list: " + (java.util.Objects.toString(nullable_iface_list))); return "MyParcelable" + _aidl_sj.toString() ; } @Override public boolean equals(Object other) { if (this == other) return true; if (other == null) return false; if (!(other instanceof MyParcelable)) return false; MyParcelable that = (MyParcelable)other; if (!java.util.Objects.deepEquals(iface, that.iface)) return false; if (!java.util.Objects.deepEquals(nullable_iface, that.nullable_iface)) return false; if (!java.util.Objects.deepEquals(iface_list, that.iface_list)) return false; if (!java.util.Objects.deepEquals(nullable_iface_list, that.nullable_iface_list)) return false; return true; } @Override public int hashCode() { return java.util.Arrays.deepHashCode(java.util.Arrays.asList(iface, nullable_iface, iface_list, nullable_iface_list).toArray()); } @Override public int describeContents() { int _mask = 0; return _mask; } } public static final class MyUnion implements android.os.Parcelable { // tags for union fields public final static int iface = 0; // android.aidl.tests.ListOfInterfaces.IEmptyInterface iface; public final static int nullable_iface = 1; // android.aidl.tests.ListOfInterfaces.IEmptyInterface nullable_iface; public final static int iface_list = 2; // List iface_list; public final static int nullable_iface_list = 3; // List nullable_iface_list; private int _tag; private Object _value; public MyUnion() { android.aidl.tests.ListOfInterfaces.IEmptyInterface _value = null; this._tag = iface; this._value = _value; } private MyUnion(android.os.Parcel _aidl_parcel) { readFromParcel(_aidl_parcel); } private MyUnion(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public int getTag() { return _tag; } // android.aidl.tests.ListOfInterfaces.IEmptyInterface iface; public static MyUnion iface(android.aidl.tests.ListOfInterfaces.IEmptyInterface _value) { return new MyUnion(iface, _value); } public android.aidl.tests.ListOfInterfaces.IEmptyInterface getIface() { _assertTag(iface); return (android.aidl.tests.ListOfInterfaces.IEmptyInterface) _value; } public void setIface(android.aidl.tests.ListOfInterfaces.IEmptyInterface _value) { _set(iface, _value); } // android.aidl.tests.ListOfInterfaces.IEmptyInterface nullable_iface; public static MyUnion nullable_iface(android.aidl.tests.ListOfInterfaces.IEmptyInterface _value) { return new MyUnion(nullable_iface, _value); } public android.aidl.tests.ListOfInterfaces.IEmptyInterface getNullable_iface() { _assertTag(nullable_iface); return (android.aidl.tests.ListOfInterfaces.IEmptyInterface) _value; } public void setNullable_iface(android.aidl.tests.ListOfInterfaces.IEmptyInterface _value) { _set(nullable_iface, _value); } // List iface_list; public static MyUnion iface_list(java.util.List _value) { return new MyUnion(iface_list, _value); } @SuppressWarnings("unchecked") public java.util.List getIface_list() { _assertTag(iface_list); return (java.util.List) _value; } public void setIface_list(java.util.List _value) { _set(iface_list, _value); } // List nullable_iface_list; public static MyUnion nullable_iface_list(java.util.List _value) { return new MyUnion(nullable_iface_list, _value); } @SuppressWarnings("unchecked") public java.util.List getNullable_iface_list() { _assertTag(nullable_iface_list); return (java.util.List) _value; } public void setNullable_iface_list(java.util.List _value) { _set(nullable_iface_list, _value); } public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public MyUnion createFromParcel(android.os.Parcel _aidl_source) { return new MyUnion(_aidl_source); } @Override public MyUnion[] newArray(int _aidl_size) { return new MyUnion[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { _aidl_parcel.writeInt(_tag); switch (_tag) { case iface: _aidl_parcel.writeStrongInterface(getIface()); break; case nullable_iface: _aidl_parcel.writeStrongInterface(getNullable_iface()); break; case iface_list: _aidl_parcel.writeInterfaceList(getIface_list()); break; case nullable_iface_list: _aidl_parcel.writeInterfaceList(getNullable_iface_list()); break; } } public void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_tag; _aidl_tag = _aidl_parcel.readInt(); switch (_aidl_tag) { case iface: { android.aidl.tests.ListOfInterfaces.IEmptyInterface _aidl_value; _aidl_value = android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub.asInterface(_aidl_parcel.readStrongBinder()); _set(_aidl_tag, _aidl_value); return; } case nullable_iface: { android.aidl.tests.ListOfInterfaces.IEmptyInterface _aidl_value; _aidl_value = android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub.asInterface(_aidl_parcel.readStrongBinder()); _set(_aidl_tag, _aidl_value); return; } case iface_list: { java.util.List _aidl_value; _aidl_value = _aidl_parcel.createInterfaceArrayList(android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub::asInterface); _set(_aidl_tag, _aidl_value); return; } case nullable_iface_list: { java.util.List _aidl_value; _aidl_value = _aidl_parcel.createInterfaceArrayList(android.aidl.tests.ListOfInterfaces.IEmptyInterface.Stub::asInterface); _set(_aidl_tag, _aidl_value); return; } } throw new IllegalArgumentException("union: unknown tag: " + _aidl_tag); } @Override public int describeContents() { int _mask = 0; switch (getTag()) { } return _mask; } @Override public String toString() { switch (_tag) { case iface: return "MyUnion.iface(" + (java.util.Objects.toString(getIface())) + ")"; case nullable_iface: return "MyUnion.nullable_iface(" + (java.util.Objects.toString(getNullable_iface())) + ")"; case iface_list: return "MyUnion.iface_list(" + (java.util.Objects.toString(getIface_list())) + ")"; case nullable_iface_list: return "MyUnion.nullable_iface_list(" + (java.util.Objects.toString(getNullable_iface_list())) + ")"; } throw new IllegalStateException("unknown field: " + _tag); } @Override public boolean equals(Object other) { if (this == other) return true; if (other == null) return false; if (!(other instanceof MyUnion)) return false; MyUnion that = (MyUnion)other; if (_tag != that._tag) return false; if (!java.util.Objects.deepEquals(_value, that._value)) return false; return true; } @Override public int hashCode() { return java.util.Arrays.deepHashCode(java.util.Arrays.asList(_tag, _value).toArray()); } private void _assertTag(int tag) { if (getTag() != tag) { throw new IllegalStateException("bad access: " + _tagString(tag) + ", " + _tagString(getTag()) + " is available."); } } private String _tagString(int _tag) { switch (_tag) { case iface: return "iface"; case nullable_iface: return "nullable_iface"; case iface_list: return "iface_list"; case nullable_iface_list: return "nullable_iface_list"; } throw new IllegalStateException("unknown field: " + _tag); } private void _set(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public static @interface Tag { public static final int iface = 0; public static final int nullable_iface = 1; public static final int iface_list = 2; public static final int nullable_iface_list = 3; } } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_Li0100644 0000000 0000000 00000000217 15172120304 033230 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/ListOfInterfaces.java.d 28 mtime=1776853188.6230000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/ListOfInterfaces.j0100644 0000000 0000000 00000000277 15172120304 033027 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/ListOfInterfaces.java : \ system/tools/aidl/tests/android/aidl/tests/ListOfInterfaces.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_Lo0100644 0000000 0000000 00000000034 15172120304 033233 xustar000000000 0000000 28 mtime=1776853188.6230000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/LongEnum.java0100644 0000000 0000000 00000001261 15172120304 032031 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/LongEnum.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl */ package android.aidl.tests; public @interface LongEnum { public static final long FOO = 100000000000L; public static final long BAR = 200000000000L; public static final long BAZ = 200000000001L; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_Lo0100644 0000000 0000000 00000000034 15172120304 033233 xustar000000000 0000000 28 mtime=1776853188.6230000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/LongEnum.java.d0100644 0000000 0000000 00000000257 15172120304 032257 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/LongEnum.java : \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_Ot0100644 0000000 0000000 00000000227 15172120304 033247 xustar000000000 0000000 123 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/OtherParcelableForToString.java 28 mtime=1776853188.6240000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/OtherParcelableFor0100644 0000000 0000000 00000005227 15172120304 033076 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/OtherParcelableForToString.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl */ package android.aidl.tests; public class OtherParcelableForToString implements android.os.Parcelable { public java.lang.String field; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public OtherParcelableForToString createFromParcel(android.os.Parcel _aidl_source) { OtherParcelableForToString _aidl_out = new OtherParcelableForToString(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public OtherParcelableForToString[] newArray(int _aidl_size) { return new OtherParcelableForToString[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeString(field); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; field = _aidl_parcel.readString(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public String toString() { java.util.StringJoiner _aidl_sj = new java.util.StringJoiner(", ", "{", "}"); _aidl_sj.add("field: " + (java.util.Objects.toString(field))); return "OtherParcelableForToString" + _aidl_sj.toString() ; } @Override public int describeContents() { int _mask = 0; return _mask; } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_Ot0100644 0000000 0000000 00000000231 15172120304 033242 xustar000000000 0000000 125 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/OtherParcelableForToString.java.d 28 mtime=1776853188.6240000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/OtherParcelableFor0100644 0000000 0000000 00000000323 15172120304 033066 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/OtherParcelableForToString.java : \ system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_Pa0100644 0000000 0000000 00000000222 15172120304 033220 xustar000000000 0000000 118 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/ParcelableForToString.java 28 mtime=1776853188.6250000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/ParcelableForToStr0100644 0000000 0000000 00000023563 15172120304 033073 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/ParcelableForToString.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ParcelableForToString.aidl */ package android.aidl.tests; public class ParcelableForToString implements android.os.Parcelable { public int intValue = 0; public int[] intArray; public long longValue = 0L; public long[] longArray; public double doubleValue = 0.000000; public double[] doubleArray; public float floatValue = 0.000000f; public float[] floatArray; public byte byteValue = 0; public byte[] byteArray; public boolean booleanValue = false; public boolean[] booleanArray; public java.lang.String stringValue; public java.lang.String[] stringArray; public java.util.List stringList; public android.aidl.tests.OtherParcelableForToString parcelableValue; public android.aidl.tests.OtherParcelableForToString[] parcelableArray; public int enumValue = android.aidl.tests.IntEnum.FOO; public int[] enumArray; public java.lang.String[] nullArray; public java.util.List nullList; public android.aidl.tests.GenericStructuredParcelable parcelableGeneric; public android.aidl.tests.Union unionValue; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public ParcelableForToString createFromParcel(android.os.Parcel _aidl_source) { ParcelableForToString _aidl_out = new ParcelableForToString(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public ParcelableForToString[] newArray(int _aidl_size) { return new ParcelableForToString[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(intValue); _aidl_parcel.writeIntArray(intArray); _aidl_parcel.writeLong(longValue); _aidl_parcel.writeLongArray(longArray); _aidl_parcel.writeDouble(doubleValue); _aidl_parcel.writeDoubleArray(doubleArray); _aidl_parcel.writeFloat(floatValue); _aidl_parcel.writeFloatArray(floatArray); _aidl_parcel.writeByte(byteValue); _aidl_parcel.writeByteArray(byteArray); _aidl_parcel.writeBoolean(booleanValue); _aidl_parcel.writeBooleanArray(booleanArray); _aidl_parcel.writeString(stringValue); _aidl_parcel.writeStringArray(stringArray); _aidl_parcel.writeStringList(stringList); _aidl_parcel.writeTypedObject(parcelableValue, _aidl_flag); _aidl_parcel.writeTypedArray(parcelableArray, _aidl_flag); _aidl_parcel.writeInt(enumValue); _aidl_parcel.writeIntArray(enumArray); _aidl_parcel.writeStringArray(nullArray); _aidl_parcel.writeStringList(nullList); _aidl_parcel.writeTypedObject(parcelableGeneric, _aidl_flag); _aidl_parcel.writeTypedObject(unionValue, _aidl_flag); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; intValue = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; intArray = _aidl_parcel.createIntArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; longValue = _aidl_parcel.readLong(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; longArray = _aidl_parcel.createLongArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; doubleValue = _aidl_parcel.readDouble(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; doubleArray = _aidl_parcel.createDoubleArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; floatValue = _aidl_parcel.readFloat(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; floatArray = _aidl_parcel.createFloatArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; byteValue = _aidl_parcel.readByte(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; byteArray = _aidl_parcel.createByteArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; booleanValue = _aidl_parcel.readBoolean(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; booleanArray = _aidl_parcel.createBooleanArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; stringValue = _aidl_parcel.readString(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; stringArray = _aidl_parcel.createStringArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; stringList = _aidl_parcel.createStringArrayList(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; parcelableValue = _aidl_parcel.readTypedObject(android.aidl.tests.OtherParcelableForToString.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; parcelableArray = _aidl_parcel.createTypedArray(android.aidl.tests.OtherParcelableForToString.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; enumValue = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; enumArray = _aidl_parcel.createIntArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; nullArray = _aidl_parcel.createStringArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; nullList = _aidl_parcel.createStringArrayList(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; parcelableGeneric = _aidl_parcel.readTypedObject(android.aidl.tests.GenericStructuredParcelable.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; unionValue = _aidl_parcel.readTypedObject(android.aidl.tests.Union.CREATOR); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public String toString() { java.util.StringJoiner _aidl_sj = new java.util.StringJoiner(", ", "{", "}"); _aidl_sj.add("intValue: " + (intValue)); _aidl_sj.add("intArray: " + (java.util.Arrays.toString(intArray))); _aidl_sj.add("longValue: " + (longValue)); _aidl_sj.add("longArray: " + (java.util.Arrays.toString(longArray))); _aidl_sj.add("doubleValue: " + (doubleValue)); _aidl_sj.add("doubleArray: " + (java.util.Arrays.toString(doubleArray))); _aidl_sj.add("floatValue: " + (floatValue)); _aidl_sj.add("floatArray: " + (java.util.Arrays.toString(floatArray))); _aidl_sj.add("byteValue: " + (byteValue)); _aidl_sj.add("byteArray: " + (java.util.Arrays.toString(byteArray))); _aidl_sj.add("booleanValue: " + (booleanValue)); _aidl_sj.add("booleanArray: " + (java.util.Arrays.toString(booleanArray))); _aidl_sj.add("stringValue: " + (java.util.Objects.toString(stringValue))); _aidl_sj.add("stringArray: " + (java.util.Arrays.toString(stringArray))); _aidl_sj.add("stringList: " + (java.util.Objects.toString(stringList))); _aidl_sj.add("parcelableValue: " + (java.util.Objects.toString(parcelableValue))); _aidl_sj.add("parcelableArray: " + (java.util.Arrays.toString(parcelableArray))); _aidl_sj.add("enumValue: " + (android.aidl.tests.IntEnum.$.toString(enumValue))); _aidl_sj.add("enumArray: " + (android.aidl.tests.IntEnum.$.arrayToString(enumArray))); _aidl_sj.add("nullArray: " + (java.util.Arrays.toString(nullArray))); _aidl_sj.add("nullList: " + (java.util.Objects.toString(nullList))); _aidl_sj.add("parcelableGeneric: " + (java.util.Objects.toString(parcelableGeneric))); _aidl_sj.add("unionValue: " + (java.util.Objects.toString(unionValue))); return "ParcelableForToString" + _aidl_sj.toString() ; } @Override public int describeContents() { int _mask = 0; _mask |= describeContents(parcelableValue); _mask |= describeContents(parcelableArray); _mask |= describeContents(parcelableGeneric); _mask |= describeContents(unionValue); return _mask; } private int describeContents(Object _v) { if (_v == null) return 0; if (_v instanceof Object[]) { int _mask = 0; for (Object o : (Object[]) _v) { _mask |= describeContents(o); } return _mask; } if (_v instanceof android.os.Parcelable) { return ((android.os.Parcelable) _v).describeContents(); } return 0; } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_Pa0100644 0000000 0000000 00000000224 15172120304 033222 xustar000000000 0000000 120 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/ParcelableForToString.java.d 28 mtime=1776853188.6250000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/ParcelableForToStr0100644 0000000 0000000 00000001354 15172120304 033065 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/ParcelableForToString.java : \ system/tools/aidl/tests/android/aidl/tests/ParcelableForToString.aidl \ system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_Re0100644 0000000 0000000 00000000212 15172120304 033225 xustar000000000 0000000 110 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/RecursiveList.java 28 mtime=1776853188.6250000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/RecursiveList.java0100644 0000000 0000000 00000005413 15172120304 033113 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/RecursiveList.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl */ package android.aidl.tests; public class RecursiveList implements android.os.Parcelable { public int value = 0; public android.aidl.tests.RecursiveList next; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public RecursiveList createFromParcel(android.os.Parcel _aidl_source) { RecursiveList _aidl_out = new RecursiveList(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public RecursiveList[] newArray(int _aidl_size) { return new RecursiveList[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(value); _aidl_parcel.writeTypedObject(next, _aidl_flag); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; value = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; next = _aidl_parcel.readTypedObject(android.aidl.tests.RecursiveList.CREATOR); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; _mask |= describeContents(next); return _mask; } private int describeContents(Object _v) { if (_v == null) return 0; if (_v instanceof android.os.Parcelable) { return ((android.os.Parcelable) _v).describeContents(); } return 0; } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_Re0100644 0000000 0000000 00000000214 15172120304 033227 xustar000000000 0000000 112 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/RecursiveList.java.d 28 mtime=1776853188.6250000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/RecursiveList.java0100644 0000000 0000000 00000000271 15172120304 033110 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/RecursiveList.java : \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_St0100644 0000000 0000000 00000000221 15172120304 033245 xustar000000000 0000000 117 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/StructuredParcelable.java 28 mtime=1776853188.6250000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/StructuredParcelab0100644 0000000 0000000 00000066365 15172120304 033203 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/StructuredParcelable.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl */ package android.aidl.tests; public class StructuredParcelable implements android.os.Parcelable { public int[] shouldContainThreeFs; public int f = 0; public java.lang.String shouldBeJerry; public byte shouldBeByteBar; public int shouldBeIntBar; public long shouldBeLongBar; public byte[] shouldContainTwoByteFoos; public int[] shouldContainTwoIntFoos; public long[] shouldContainTwoLongFoos; public java.lang.String stringDefaultsToFoo = "foo"; public byte byteDefaultsToFour = 4; public int intDefaultsToFive = 5; public long longDefaultsToNegativeSeven = -7L; public boolean booleanDefaultsToTrue = true; public char charDefaultsToC = 'C'; public float floatDefaultsToPi = 3.140000f; public double doubleWithDefault = -314000000000000000.000000; public int[] arrayDefaultsTo123 = {1, 2, 3}; public int[] arrayDefaultsToEmpty = {}; public boolean boolDefault = false; public byte byteDefault = 0; public int intDefault = 0; public long longDefault = 0L; public float floatDefault = 0.000000f; public double doubleDefault = 0.000000; // parse checks only public double checkDoubleFromFloat = 3.140000; public java.lang.String[] checkStringArray1 = {"a", "b"}; public java.lang.String[] checkStringArray2 = {"a", "b"}; // Add test to verify corner cases public int int32_min = -2147483648; public int int32_max = 2147483647; public long int64_max = 9223372036854775807L; public int hexInt32_neg_1 = -1; public android.os.IBinder ibinder; public android.aidl.tests.StructuredParcelable.Empty empty; // Constant expressions that evaluate to 1 public byte[] int8_1 = {1, 1, 1, 1, 1}; public int[] int32_1 = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}; public long[] int64_1 = {1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L}; public int hexInt32_pos_1 = 1; public int hexInt64_pos_1 = 1; public int const_exprs_1; public int const_exprs_2; public int const_exprs_3; public int const_exprs_4; public int const_exprs_5; public int const_exprs_6; public int const_exprs_7; public int const_exprs_8; public int const_exprs_9; public int const_exprs_10; // String expressions public java.lang.String addString1 = "hello world!"; public java.lang.String addString2 = "The quick brown fox jumps over the lazy dog."; public int shouldSetBit0AndBit2 = 0; public android.aidl.tests.Union u; public android.aidl.tests.Union shouldBeConstS1; public int defaultWithFoo = android.aidl.tests.IntEnum.FOO; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public StructuredParcelable createFromParcel(android.os.Parcel _aidl_source) { StructuredParcelable _aidl_out = new StructuredParcelable(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public StructuredParcelable[] newArray(int _aidl_size) { return new StructuredParcelable[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeIntArray(shouldContainThreeFs); _aidl_parcel.writeInt(f); _aidl_parcel.writeString(shouldBeJerry); _aidl_parcel.writeByte(shouldBeByteBar); _aidl_parcel.writeInt(shouldBeIntBar); _aidl_parcel.writeLong(shouldBeLongBar); _aidl_parcel.writeByteArray(shouldContainTwoByteFoos); _aidl_parcel.writeIntArray(shouldContainTwoIntFoos); _aidl_parcel.writeLongArray(shouldContainTwoLongFoos); _aidl_parcel.writeString(stringDefaultsToFoo); _aidl_parcel.writeByte(byteDefaultsToFour); _aidl_parcel.writeInt(intDefaultsToFive); _aidl_parcel.writeLong(longDefaultsToNegativeSeven); _aidl_parcel.writeBoolean(booleanDefaultsToTrue); _aidl_parcel.writeInt(((int)charDefaultsToC)); _aidl_parcel.writeFloat(floatDefaultsToPi); _aidl_parcel.writeDouble(doubleWithDefault); _aidl_parcel.writeIntArray(arrayDefaultsTo123); _aidl_parcel.writeIntArray(arrayDefaultsToEmpty); _aidl_parcel.writeBoolean(boolDefault); _aidl_parcel.writeByte(byteDefault); _aidl_parcel.writeInt(intDefault); _aidl_parcel.writeLong(longDefault); _aidl_parcel.writeFloat(floatDefault); _aidl_parcel.writeDouble(doubleDefault); _aidl_parcel.writeDouble(checkDoubleFromFloat); _aidl_parcel.writeStringArray(checkStringArray1); _aidl_parcel.writeStringArray(checkStringArray2); _aidl_parcel.writeInt(int32_min); _aidl_parcel.writeInt(int32_max); _aidl_parcel.writeLong(int64_max); _aidl_parcel.writeInt(hexInt32_neg_1); _aidl_parcel.writeStrongBinder(ibinder); _aidl_parcel.writeTypedObject(empty, _aidl_flag); _aidl_parcel.writeByteArray(int8_1); _aidl_parcel.writeIntArray(int32_1); _aidl_parcel.writeLongArray(int64_1); _aidl_parcel.writeInt(hexInt32_pos_1); _aidl_parcel.writeInt(hexInt64_pos_1); _aidl_parcel.writeInt(const_exprs_1); _aidl_parcel.writeInt(const_exprs_2); _aidl_parcel.writeInt(const_exprs_3); _aidl_parcel.writeInt(const_exprs_4); _aidl_parcel.writeInt(const_exprs_5); _aidl_parcel.writeInt(const_exprs_6); _aidl_parcel.writeInt(const_exprs_7); _aidl_parcel.writeInt(const_exprs_8); _aidl_parcel.writeInt(const_exprs_9); _aidl_parcel.writeInt(const_exprs_10); _aidl_parcel.writeString(addString1); _aidl_parcel.writeString(addString2); _aidl_parcel.writeInt(shouldSetBit0AndBit2); _aidl_parcel.writeTypedObject(u, _aidl_flag); _aidl_parcel.writeTypedObject(shouldBeConstS1, _aidl_flag); _aidl_parcel.writeInt(defaultWithFoo); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; shouldContainThreeFs = _aidl_parcel.createIntArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; f = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; shouldBeJerry = _aidl_parcel.readString(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; shouldBeByteBar = _aidl_parcel.readByte(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; shouldBeIntBar = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; shouldBeLongBar = _aidl_parcel.readLong(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; shouldContainTwoByteFoos = _aidl_parcel.createByteArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; shouldContainTwoIntFoos = _aidl_parcel.createIntArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; shouldContainTwoLongFoos = _aidl_parcel.createLongArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; stringDefaultsToFoo = _aidl_parcel.readString(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; byteDefaultsToFour = _aidl_parcel.readByte(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; intDefaultsToFive = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; longDefaultsToNegativeSeven = _aidl_parcel.readLong(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; booleanDefaultsToTrue = _aidl_parcel.readBoolean(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; charDefaultsToC = (char)_aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; floatDefaultsToPi = _aidl_parcel.readFloat(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; doubleWithDefault = _aidl_parcel.readDouble(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; arrayDefaultsTo123 = _aidl_parcel.createIntArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; arrayDefaultsToEmpty = _aidl_parcel.createIntArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; boolDefault = _aidl_parcel.readBoolean(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; byteDefault = _aidl_parcel.readByte(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; intDefault = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; longDefault = _aidl_parcel.readLong(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; floatDefault = _aidl_parcel.readFloat(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; doubleDefault = _aidl_parcel.readDouble(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; checkDoubleFromFloat = _aidl_parcel.readDouble(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; checkStringArray1 = _aidl_parcel.createStringArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; checkStringArray2 = _aidl_parcel.createStringArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; int32_min = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; int32_max = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; int64_max = _aidl_parcel.readLong(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; hexInt32_neg_1 = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; ibinder = _aidl_parcel.readStrongBinder(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; empty = _aidl_parcel.readTypedObject(android.aidl.tests.StructuredParcelable.Empty.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; int8_1 = _aidl_parcel.createByteArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; int32_1 = _aidl_parcel.createIntArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; int64_1 = _aidl_parcel.createLongArray(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; hexInt32_pos_1 = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; hexInt64_pos_1 = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; const_exprs_1 = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; const_exprs_2 = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; const_exprs_3 = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; const_exprs_4 = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; const_exprs_5 = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; const_exprs_6 = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; const_exprs_7 = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; const_exprs_8 = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; const_exprs_9 = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; const_exprs_10 = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; addString1 = _aidl_parcel.readString(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; addString2 = _aidl_parcel.readString(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; shouldSetBit0AndBit2 = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; u = _aidl_parcel.readTypedObject(android.aidl.tests.Union.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; shouldBeConstS1 = _aidl_parcel.readTypedObject(android.aidl.tests.Union.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; defaultWithFoo = _aidl_parcel.readInt(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } public static final int BIT0 = 1; public static final int BIT1 = 2; public static final int BIT2 = 4; @Override public String toString() { java.util.StringJoiner _aidl_sj = new java.util.StringJoiner(", ", "{", "}"); _aidl_sj.add("shouldContainThreeFs: " + (java.util.Arrays.toString(shouldContainThreeFs))); _aidl_sj.add("f: " + (f)); _aidl_sj.add("shouldBeJerry: " + (java.util.Objects.toString(shouldBeJerry))); _aidl_sj.add("shouldBeByteBar: " + (shouldBeByteBar)); _aidl_sj.add("shouldBeIntBar: " + (android.aidl.tests.IntEnum.$.toString(shouldBeIntBar))); _aidl_sj.add("shouldBeLongBar: " + (shouldBeLongBar)); _aidl_sj.add("shouldContainTwoByteFoos: " + (java.util.Arrays.toString(shouldContainTwoByteFoos))); _aidl_sj.add("shouldContainTwoIntFoos: " + (android.aidl.tests.IntEnum.$.arrayToString(shouldContainTwoIntFoos))); _aidl_sj.add("shouldContainTwoLongFoos: " + (java.util.Arrays.toString(shouldContainTwoLongFoos))); _aidl_sj.add("stringDefaultsToFoo: " + (java.util.Objects.toString(stringDefaultsToFoo))); _aidl_sj.add("byteDefaultsToFour: " + (byteDefaultsToFour)); _aidl_sj.add("intDefaultsToFive: " + (intDefaultsToFive)); _aidl_sj.add("longDefaultsToNegativeSeven: " + (longDefaultsToNegativeSeven)); _aidl_sj.add("booleanDefaultsToTrue: " + (booleanDefaultsToTrue)); _aidl_sj.add("charDefaultsToC: " + (charDefaultsToC)); _aidl_sj.add("floatDefaultsToPi: " + (floatDefaultsToPi)); _aidl_sj.add("doubleWithDefault: " + (doubleWithDefault)); _aidl_sj.add("arrayDefaultsTo123: " + (java.util.Arrays.toString(arrayDefaultsTo123))); _aidl_sj.add("arrayDefaultsToEmpty: " + (java.util.Arrays.toString(arrayDefaultsToEmpty))); _aidl_sj.add("boolDefault: " + (boolDefault)); _aidl_sj.add("byteDefault: " + (byteDefault)); _aidl_sj.add("intDefault: " + (intDefault)); _aidl_sj.add("longDefault: " + (longDefault)); _aidl_sj.add("floatDefault: " + (floatDefault)); _aidl_sj.add("doubleDefault: " + (doubleDefault)); _aidl_sj.add("checkDoubleFromFloat: " + (checkDoubleFromFloat)); _aidl_sj.add("checkStringArray1: " + (java.util.Arrays.toString(checkStringArray1))); _aidl_sj.add("checkStringArray2: " + (java.util.Arrays.toString(checkStringArray2))); _aidl_sj.add("int32_min: " + (int32_min)); _aidl_sj.add("int32_max: " + (int32_max)); _aidl_sj.add("int64_max: " + (int64_max)); _aidl_sj.add("hexInt32_neg_1: " + (hexInt32_neg_1)); _aidl_sj.add("ibinder: " + (java.util.Objects.toString(ibinder))); _aidl_sj.add("empty: " + (java.util.Objects.toString(empty))); _aidl_sj.add("int8_1: " + (java.util.Arrays.toString(int8_1))); _aidl_sj.add("int32_1: " + (java.util.Arrays.toString(int32_1))); _aidl_sj.add("int64_1: " + (java.util.Arrays.toString(int64_1))); _aidl_sj.add("hexInt32_pos_1: " + (hexInt32_pos_1)); _aidl_sj.add("hexInt64_pos_1: " + (hexInt64_pos_1)); _aidl_sj.add("const_exprs_1: " + (const_exprs_1)); _aidl_sj.add("const_exprs_2: " + (const_exprs_2)); _aidl_sj.add("const_exprs_3: " + (const_exprs_3)); _aidl_sj.add("const_exprs_4: " + (const_exprs_4)); _aidl_sj.add("const_exprs_5: " + (const_exprs_5)); _aidl_sj.add("const_exprs_6: " + (const_exprs_6)); _aidl_sj.add("const_exprs_7: " + (const_exprs_7)); _aidl_sj.add("const_exprs_8: " + (const_exprs_8)); _aidl_sj.add("const_exprs_9: " + (const_exprs_9)); _aidl_sj.add("const_exprs_10: " + (const_exprs_10)); _aidl_sj.add("addString1: " + (java.util.Objects.toString(addString1))); _aidl_sj.add("addString2: " + (java.util.Objects.toString(addString2))); _aidl_sj.add("shouldSetBit0AndBit2: " + (shouldSetBit0AndBit2)); _aidl_sj.add("u: " + (java.util.Objects.toString(u))); _aidl_sj.add("shouldBeConstS1: " + (java.util.Objects.toString(shouldBeConstS1))); _aidl_sj.add("defaultWithFoo: " + (android.aidl.tests.IntEnum.$.toString(defaultWithFoo))); return "StructuredParcelable" + _aidl_sj.toString() ; } @Override public boolean equals(Object other) { if (this == other) return true; if (other == null) return false; if (!(other instanceof StructuredParcelable)) return false; StructuredParcelable that = (StructuredParcelable)other; if (!java.util.Objects.deepEquals(shouldContainThreeFs, that.shouldContainThreeFs)) return false; if (!java.util.Objects.deepEquals(f, that.f)) return false; if (!java.util.Objects.deepEquals(shouldBeJerry, that.shouldBeJerry)) return false; if (!java.util.Objects.deepEquals(shouldBeByteBar, that.shouldBeByteBar)) return false; if (!java.util.Objects.deepEquals(shouldBeIntBar, that.shouldBeIntBar)) return false; if (!java.util.Objects.deepEquals(shouldBeLongBar, that.shouldBeLongBar)) return false; if (!java.util.Objects.deepEquals(shouldContainTwoByteFoos, that.shouldContainTwoByteFoos)) return false; if (!java.util.Objects.deepEquals(shouldContainTwoIntFoos, that.shouldContainTwoIntFoos)) return false; if (!java.util.Objects.deepEquals(shouldContainTwoLongFoos, that.shouldContainTwoLongFoos)) return false; if (!java.util.Objects.deepEquals(stringDefaultsToFoo, that.stringDefaultsToFoo)) return false; if (!java.util.Objects.deepEquals(byteDefaultsToFour, that.byteDefaultsToFour)) return false; if (!java.util.Objects.deepEquals(intDefaultsToFive, that.intDefaultsToFive)) return false; if (!java.util.Objects.deepEquals(longDefaultsToNegativeSeven, that.longDefaultsToNegativeSeven)) return false; if (!java.util.Objects.deepEquals(booleanDefaultsToTrue, that.booleanDefaultsToTrue)) return false; if (!java.util.Objects.deepEquals(charDefaultsToC, that.charDefaultsToC)) return false; if (!java.util.Objects.deepEquals(floatDefaultsToPi, that.floatDefaultsToPi)) return false; if (!java.util.Objects.deepEquals(doubleWithDefault, that.doubleWithDefault)) return false; if (!java.util.Objects.deepEquals(arrayDefaultsTo123, that.arrayDefaultsTo123)) return false; if (!java.util.Objects.deepEquals(arrayDefaultsToEmpty, that.arrayDefaultsToEmpty)) return false; if (!java.util.Objects.deepEquals(boolDefault, that.boolDefault)) return false; if (!java.util.Objects.deepEquals(byteDefault, that.byteDefault)) return false; if (!java.util.Objects.deepEquals(intDefault, that.intDefault)) return false; if (!java.util.Objects.deepEquals(longDefault, that.longDefault)) return false; if (!java.util.Objects.deepEquals(floatDefault, that.floatDefault)) return false; if (!java.util.Objects.deepEquals(doubleDefault, that.doubleDefault)) return false; if (!java.util.Objects.deepEquals(checkDoubleFromFloat, that.checkDoubleFromFloat)) return false; if (!java.util.Objects.deepEquals(checkStringArray1, that.checkStringArray1)) return false; if (!java.util.Objects.deepEquals(checkStringArray2, that.checkStringArray2)) return false; if (!java.util.Objects.deepEquals(int32_min, that.int32_min)) return false; if (!java.util.Objects.deepEquals(int32_max, that.int32_max)) return false; if (!java.util.Objects.deepEquals(int64_max, that.int64_max)) return false; if (!java.util.Objects.deepEquals(hexInt32_neg_1, that.hexInt32_neg_1)) return false; if (!java.util.Objects.deepEquals(ibinder, that.ibinder)) return false; if (!java.util.Objects.deepEquals(empty, that.empty)) return false; if (!java.util.Objects.deepEquals(int8_1, that.int8_1)) return false; if (!java.util.Objects.deepEquals(int32_1, that.int32_1)) return false; if (!java.util.Objects.deepEquals(int64_1, that.int64_1)) return false; if (!java.util.Objects.deepEquals(hexInt32_pos_1, that.hexInt32_pos_1)) return false; if (!java.util.Objects.deepEquals(hexInt64_pos_1, that.hexInt64_pos_1)) return false; if (!java.util.Objects.deepEquals(const_exprs_1, that.const_exprs_1)) return false; if (!java.util.Objects.deepEquals(const_exprs_2, that.const_exprs_2)) return false; if (!java.util.Objects.deepEquals(const_exprs_3, that.const_exprs_3)) return false; if (!java.util.Objects.deepEquals(const_exprs_4, that.const_exprs_4)) return false; if (!java.util.Objects.deepEquals(const_exprs_5, that.const_exprs_5)) return false; if (!java.util.Objects.deepEquals(const_exprs_6, that.const_exprs_6)) return false; if (!java.util.Objects.deepEquals(const_exprs_7, that.const_exprs_7)) return false; if (!java.util.Objects.deepEquals(const_exprs_8, that.const_exprs_8)) return false; if (!java.util.Objects.deepEquals(const_exprs_9, that.const_exprs_9)) return false; if (!java.util.Objects.deepEquals(const_exprs_10, that.const_exprs_10)) return false; if (!java.util.Objects.deepEquals(addString1, that.addString1)) return false; if (!java.util.Objects.deepEquals(addString2, that.addString2)) return false; if (!java.util.Objects.deepEquals(shouldSetBit0AndBit2, that.shouldSetBit0AndBit2)) return false; if (!java.util.Objects.deepEquals(u, that.u)) return false; if (!java.util.Objects.deepEquals(shouldBeConstS1, that.shouldBeConstS1)) return false; if (!java.util.Objects.deepEquals(defaultWithFoo, that.defaultWithFoo)) return false; return true; } @Override public int hashCode() { return java.util.Arrays.deepHashCode(java.util.Arrays.asList(shouldContainThreeFs, f, shouldBeJerry, shouldBeByteBar, shouldBeIntBar, shouldBeLongBar, shouldContainTwoByteFoos, shouldContainTwoIntFoos, shouldContainTwoLongFoos, stringDefaultsToFoo, byteDefaultsToFour, intDefaultsToFive, longDefaultsToNegativeSeven, booleanDefaultsToTrue, charDefaultsToC, floatDefaultsToPi, doubleWithDefault, arrayDefaultsTo123, arrayDefaultsToEmpty, boolDefault, byteDefault, intDefault, longDefault, floatDefault, doubleDefault, checkDoubleFromFloat, checkStringArray1, checkStringArray2, int32_min, int32_max, int64_max, hexInt32_neg_1, ibinder, empty, int8_1, int32_1, int64_1, hexInt32_pos_1, hexInt64_pos_1, const_exprs_1, const_exprs_2, const_exprs_3, const_exprs_4, const_exprs_5, const_exprs_6, const_exprs_7, const_exprs_8, const_exprs_9, const_exprs_10, addString1, addString2, shouldSetBit0AndBit2, u, shouldBeConstS1, defaultWithFoo).toArray()); } @Override public int describeContents() { int _mask = 0; _mask |= describeContents(empty); _mask |= describeContents(u); _mask |= describeContents(shouldBeConstS1); return _mask; } private int describeContents(Object _v) { if (_v == null) return 0; if (_v instanceof android.os.Parcelable) { return ((android.os.Parcelable) _v).describeContents(); } return 0; } // Make sure we can send an empty parcelable public static class Empty implements android.os.Parcelable { public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public Empty createFromParcel(android.os.Parcel _aidl_source) { Empty _aidl_out = new Empty(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public Empty[] newArray(int _aidl_size) { return new Empty[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public String toString() { java.util.StringJoiner _aidl_sj = new java.util.StringJoiner(", ", "{", "}"); return "Empty" + _aidl_sj.toString() ; } @Override public boolean equals(Object other) { if (this == other) return true; if (other == null) return false; if (!(other instanceof Empty)) return false; Empty that = (Empty)other; return true; } @Override public int hashCode() { return java.util.Arrays.deepHashCode(java.util.Arrays.asList().toArray()); } @Override public int describeContents() { int _mask = 0; return _mask; } } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_St0100644 0000000 0000000 00000000223 15172120304 033247 xustar000000000 0000000 119 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/StructuredParcelable.java.d 28 mtime=1776853188.6260000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/StructuredParcelab0100644 0000000 0000000 00000001002 15172120304 033154 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/StructuredParcelable.java : \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_Un0100644 0000000 0000000 00000000034 15172120304 033243 xustar000000000 0000000 28 mtime=1776853188.6260000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/Union.java0100644 0000000 0000000 00000016771 15172120304 031411 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/Union.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/Union.aidl */ package android.aidl.tests; public final class Union implements android.os.Parcelable { // tags for union fields public final static int ns = 0; // int[] ns; public final static int n = 1; // int n; public final static int m = 2; // int m; public final static int s = 3; // String s; public final static int ibinder = 4; // IBinder ibinder; public final static int ss = 5; // List ss; public final static int be = 6; // android.aidl.tests.ByteEnum be; private int _tag; private Object _value; public Union() { int[] _value = {}; this._tag = ns; this._value = _value; } private Union(android.os.Parcel _aidl_parcel) { readFromParcel(_aidl_parcel); } private Union(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public int getTag() { return _tag; } // int[] ns; public static Union ns(int[] _value) { return new Union(ns, _value); } public int[] getNs() { _assertTag(ns); return (int[]) _value; } public void setNs(int[] _value) { _set(ns, _value); } // int n; public static Union n(int _value) { return new Union(n, _value); } public int getN() { _assertTag(n); return (int) _value; } public void setN(int _value) { _set(n, _value); } // int m; public static Union m(int _value) { return new Union(m, _value); } public int getM() { _assertTag(m); return (int) _value; } public void setM(int _value) { _set(m, _value); } // String s; public static Union s(java.lang.String _value) { return new Union(s, _value); } public java.lang.String getS() { _assertTag(s); return (java.lang.String) _value; } public void setS(java.lang.String _value) { _set(s, _value); } // IBinder ibinder; public static Union ibinder(android.os.IBinder _value) { return new Union(ibinder, _value); } public android.os.IBinder getIbinder() { _assertTag(ibinder); return (android.os.IBinder) _value; } public void setIbinder(android.os.IBinder _value) { _set(ibinder, _value); } // List ss; public static Union ss(java.util.List _value) { return new Union(ss, _value); } @SuppressWarnings("unchecked") public java.util.List getSs() { _assertTag(ss); return (java.util.List) _value; } public void setSs(java.util.List _value) { _set(ss, _value); } // android.aidl.tests.ByteEnum be; public static Union be(byte _value) { return new Union(be, _value); } public byte getBe() { _assertTag(be); return (byte) _value; } public void setBe(byte _value) { _set(be, _value); } public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public Union createFromParcel(android.os.Parcel _aidl_source) { return new Union(_aidl_source); } @Override public Union[] newArray(int _aidl_size) { return new Union[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { _aidl_parcel.writeInt(_tag); switch (_tag) { case ns: _aidl_parcel.writeIntArray(getNs()); break; case n: _aidl_parcel.writeInt(getN()); break; case m: _aidl_parcel.writeInt(getM()); break; case s: _aidl_parcel.writeString(getS()); break; case ibinder: _aidl_parcel.writeStrongBinder(getIbinder()); break; case ss: _aidl_parcel.writeStringList(getSs()); break; case be: _aidl_parcel.writeByte(getBe()); break; } } public void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_tag; _aidl_tag = _aidl_parcel.readInt(); switch (_aidl_tag) { case ns: { int[] _aidl_value; _aidl_value = _aidl_parcel.createIntArray(); _set(_aidl_tag, _aidl_value); return; } case n: { int _aidl_value; _aidl_value = _aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } case m: { int _aidl_value; _aidl_value = _aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } case s: { java.lang.String _aidl_value; _aidl_value = _aidl_parcel.readString(); _set(_aidl_tag, _aidl_value); return; } case ibinder: { android.os.IBinder _aidl_value; _aidl_value = _aidl_parcel.readStrongBinder(); _set(_aidl_tag, _aidl_value); return; } case ss: { java.util.List _aidl_value; _aidl_value = _aidl_parcel.createStringArrayList(); _set(_aidl_tag, _aidl_value); return; } case be: { byte _aidl_value; _aidl_value = _aidl_parcel.readByte(); _set(_aidl_tag, _aidl_value); return; } } throw new IllegalArgumentException("union: unknown tag: " + _aidl_tag); } public static final String S1 = "a string constant in union"; @Override public int describeContents() { int _mask = 0; switch (getTag()) { } return _mask; } @Override public String toString() { switch (_tag) { case ns: return "Union.ns(" + (java.util.Arrays.toString(getNs())) + ")"; case n: return "Union.n(" + (getN()) + ")"; case m: return "Union.m(" + (getM()) + ")"; case s: return "Union.s(" + (java.util.Objects.toString(getS())) + ")"; case ibinder: return "Union.ibinder(" + (java.util.Objects.toString(getIbinder())) + ")"; case ss: return "Union.ss(" + (java.util.Objects.toString(getSs())) + ")"; case be: return "Union.be(" + (getBe()) + ")"; } throw new IllegalStateException("unknown field: " + _tag); } @Override public boolean equals(Object other) { if (this == other) return true; if (other == null) return false; if (!(other instanceof Union)) return false; Union that = (Union)other; if (_tag != that._tag) return false; if (!java.util.Objects.deepEquals(_value, that._value)) return false; return true; } @Override public int hashCode() { return java.util.Arrays.deepHashCode(java.util.Arrays.asList(_tag, _value).toArray()); } private void _assertTag(int tag) { if (getTag() != tag) { throw new IllegalStateException("bad access: " + _tagString(tag) + ", " + _tagString(getTag()) + " is available."); } } private String _tagString(int _tag) { switch (_tag) { case ns: return "ns"; case n: return "n"; case m: return "m"; case s: return "s"; case ibinder: return "ibinder"; case ss: return "ss"; case be: return "be"; } throw new IllegalStateException("unknown field: " + _tag); } private void _set(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public static @interface Tag { public static final int ns = 0; public static final int n = 1; public static final int m = 2; public static final int s = 3; public static final int ibinder = 4; public static final int ss = 5; public static final int be = 6; } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_Un0100644 0000000 0000000 00000000034 15172120304 033243 xustar000000000 0000000 28 mtime=1776853188.6270000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/Union.java.d0100644 0000000 0000000 00000000346 15172120304 031622 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/Union.java : \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_Un0100644 0000000 0000000 00000000034 15172120304 033243 xustar000000000 0000000 28 mtime=1776853188.6270000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/UnionWithFd.java0100644 0000000 0000000 00000007641 15172120304 032513 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/UnionWithFd.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/UnionWithFd.aidl */ package android.aidl.tests; public final class UnionWithFd implements android.os.Parcelable { // tags for union fields public final static int num = 0; // int num; public final static int pfd = 1; // ParcelFileDescriptor pfd; private int _tag; private Object _value; public UnionWithFd() { int _value = 0; this._tag = num; this._value = _value; } private UnionWithFd(android.os.Parcel _aidl_parcel) { readFromParcel(_aidl_parcel); } private UnionWithFd(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public int getTag() { return _tag; } // int num; public static UnionWithFd num(int _value) { return new UnionWithFd(num, _value); } public int getNum() { _assertTag(num); return (int) _value; } public void setNum(int _value) { _set(num, _value); } // ParcelFileDescriptor pfd; public static UnionWithFd pfd(android.os.ParcelFileDescriptor _value) { return new UnionWithFd(pfd, _value); } public android.os.ParcelFileDescriptor getPfd() { _assertTag(pfd); return (android.os.ParcelFileDescriptor) _value; } public void setPfd(android.os.ParcelFileDescriptor _value) { _set(pfd, _value); } public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public UnionWithFd createFromParcel(android.os.Parcel _aidl_source) { return new UnionWithFd(_aidl_source); } @Override public UnionWithFd[] newArray(int _aidl_size) { return new UnionWithFd[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { _aidl_parcel.writeInt(_tag); switch (_tag) { case num: _aidl_parcel.writeInt(getNum()); break; case pfd: _aidl_parcel.writeTypedObject(getPfd(), _aidl_flag); break; } } public void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_tag; _aidl_tag = _aidl_parcel.readInt(); switch (_aidl_tag) { case num: { int _aidl_value; _aidl_value = _aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } case pfd: { android.os.ParcelFileDescriptor _aidl_value; _aidl_value = _aidl_parcel.readTypedObject(android.os.ParcelFileDescriptor.CREATOR); _set(_aidl_tag, _aidl_value); return; } } throw new IllegalArgumentException("union: unknown tag: " + _aidl_tag); } @Override public int describeContents() { int _mask = 0; switch (getTag()) { case pfd: _mask |= describeContents(getPfd()); break; } return _mask; } private int describeContents(Object _v) { if (_v == null) return 0; if (_v instanceof android.os.Parcelable) { return ((android.os.Parcelable) _v).describeContents(); } return 0; } private void _assertTag(int tag) { if (getTag() != tag) { throw new IllegalStateException("bad access: " + _tagString(tag) + ", " + _tagString(getTag()) + " is available."); } } private String _tagString(int _tag) { switch (_tag) { case num: return "num"; case pfd: return "pfd"; } throw new IllegalStateException("unknown field: " + _tag); } private void _set(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public static @interface Tag { public static final int num = 0; public static final int pfd = 1; } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_Un0100644 0000000 0000000 00000000212 15172120304 033241 xustar000000000 0000000 110 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/UnionWithFd.java.d 28 mtime=1776853188.6270000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/UnionWithFd.java.d0100644 0000000 0000000 00000000265 15172120304 032730 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/UnionWithFd.java : \ system/tools/aidl/tests/android/aidl/tests/UnionWithFd.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_ex0100644 0000000 0000000 00000000034 15172120304 033275 xustar000000000 0000000 28 mtime=1776853188.6270000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/extension/0040755 0000000 0000000 00000000000 15172120304 031461 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_ex0100644 0000000 0000000 00000000233 15172120304 033276 xustar000000000 0000000 127 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/extension/ExtendableParcelable.java 28 mtime=1776853188.6270000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/extension/Extendab0100644 0000000 0000000 00000007255 15172120304 033144 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/extension/ExtendableParcelable.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl */ package android.aidl.tests.extension; public class ExtendableParcelable implements android.os.Parcelable { public int a = 0; public java.lang.String b; public final android.os.ParcelableHolder ext = new android.os.ParcelableHolder(android.os.Parcelable.PARCELABLE_STABILITY_LOCAL); public long c = 0L; public final android.os.ParcelableHolder ext2 = new android.os.ParcelableHolder(android.os.Parcelable.PARCELABLE_STABILITY_LOCAL); public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public ExtendableParcelable createFromParcel(android.os.Parcel _aidl_source) { ExtendableParcelable _aidl_out = new ExtendableParcelable(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public ExtendableParcelable[] newArray(int _aidl_size) { return new ExtendableParcelable[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(a); _aidl_parcel.writeString(b); _aidl_parcel.writeTypedObject(ext, 0); _aidl_parcel.writeLong(c); _aidl_parcel.writeTypedObject(ext2, 0); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; a = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; b = _aidl_parcel.readString(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; if ((0!=_aidl_parcel.readInt())) { ext.readFromParcel(_aidl_parcel); } if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; c = _aidl_parcel.readLong(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; if ((0!=_aidl_parcel.readInt())) { ext2.readFromParcel(_aidl_parcel); } } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; _mask |= describeContents(ext); _mask |= describeContents(ext2); return _mask; } private int describeContents(Object _v) { if (_v == null) return 0; if (_v instanceof android.os.Parcelable) { return ((android.os.Parcelable) _v).describeContents(); } return 0; } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_ex0100644 0000000 0000000 00000000235 15172120304 033300 xustar000000000 0000000 129 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/extension/ExtendableParcelable.java.d 28 mtime=1776853188.6270000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/extension/Extendab0100644 0000000 0000000 00000000333 15172120304 033132 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/extension/ExtendableParcelable.java : \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_ex0100644 0000000 0000000 00000000214 15172120304 033275 xustar000000000 0000000 112 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/extension/MyExt.java 28 mtime=1776853188.6270000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/extension/MyExt.ja0100644 0000000 0000000 00000004602 15172120304 033042 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/extension/MyExt.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl */ package android.aidl.tests.extension; public class MyExt implements android.os.Parcelable { public int a = 0; public java.lang.String b; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public MyExt createFromParcel(android.os.Parcel _aidl_source) { MyExt _aidl_out = new MyExt(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public MyExt[] newArray(int _aidl_size) { return new MyExt[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(a); _aidl_parcel.writeString(b); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; a = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; b = _aidl_parcel.readString(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_ex0100644 0000000 0000000 00000000216 15172120304 033277 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/extension/MyExt.java.d 28 mtime=1776853188.6270000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/extension/MyExt.ja0100644 0000000 0000000 00000000275 15172120304 033044 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/extension/MyExt.java : \ system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_ex0100644 0000000 0000000 00000000215 15172120304 033276 xustar000000000 0000000 113 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/extension/MyExt2.java 28 mtime=1776853188.6280000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/extension/MyExt2.j0100644 0000000 0000000 00000005614 15172120304 032767 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/extension/MyExt2.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt2.aidl */ package android.aidl.tests.extension; public class MyExt2 implements android.os.Parcelable { public int a = 0; public android.aidl.tests.extension.MyExt b; public java.lang.String c; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public MyExt2 createFromParcel(android.os.Parcel _aidl_source) { MyExt2 _aidl_out = new MyExt2(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public MyExt2[] newArray(int _aidl_size) { return new MyExt2[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(a); _aidl_parcel.writeTypedObject(b, _aidl_flag); _aidl_parcel.writeString(c); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; a = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; b = _aidl_parcel.readTypedObject(android.aidl.tests.extension.MyExt.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; c = _aidl_parcel.readString(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; _mask |= describeContents(b); return _mask; } private int describeContents(Object _v) { if (_v == null) return 0; if (_v instanceof android.os.Parcelable) { return ((android.os.Parcelable) _v).describeContents(); } return 0; } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_ex0100644 0000000 0000000 00000000217 15172120304 033300 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/extension/MyExt2.java.d 28 mtime=1776853188.6280000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/extension/MyExt2.j0100644 0000000 0000000 00000000403 15172120304 032756 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/extension/MyExt2.java : \ system/tools/aidl/tests/android/aidl/tests/extension/MyExt2.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_ex0100644 0000000 0000000 00000000220 15172120304 033272 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/extension/MyExtLike.java 28 mtime=1776853188.6280000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/extension/MyExtLik0100644 0000000 0000000 00000004652 15172120304 033116 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/extension/MyExtLike.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExtLike.aidl */ package android.aidl.tests.extension; public class MyExtLike implements android.os.Parcelable { public int a = 0; public java.lang.String b; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public MyExtLike createFromParcel(android.os.Parcel _aidl_source) { MyExtLike _aidl_out = new MyExtLike(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public MyExtLike[] newArray(int _aidl_size) { return new MyExtLike[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(a); _aidl_parcel.writeString(b); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; a = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; b = _aidl_parcel.readString(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_ex0100644 0000000 0000000 00000000222 15172120304 033274 xustar000000000 0000000 118 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/extension/MyExtLike.java.d 28 mtime=1776853188.6280000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/extension/MyExtLik0100644 0000000 0000000 00000000305 15172120304 033105 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/extension/MyExtLike.java : \ system/tools/aidl/tests/android/aidl/tests/extension/MyExtLike.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_ne0100644 0000000 0000000 00000000034 15172120304 033263 xustar000000000 0000000 28 mtime=1776853188.6280000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/nested/0040755 0000000 0000000 00000000000 15172120304 030727 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_ne0100644 0000000 0000000 00000000220 15172120304 033260 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/nested/DeeplyNested.java 28 mtime=1776853188.6280000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/nested/DeeplyNeste0100644 0000000 0000000 00000021656 15172120304 033102 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/nested/DeeplyNested.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/DeeplyNested.aidl */ package android.aidl.tests.nested; public class DeeplyNested implements android.os.Parcelable { public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public DeeplyNested createFromParcel(android.os.Parcel _aidl_source) { DeeplyNested _aidl_out = new DeeplyNested(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public DeeplyNested[] newArray(int _aidl_size) { return new DeeplyNested[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } public static class A implements android.os.Parcelable { // Can reference deeply nested type of a sibling type. public byte e = android.aidl.tests.nested.DeeplyNested.B.C.D.E.OK; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public A createFromParcel(android.os.Parcel _aidl_source) { A _aidl_out = new A(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public A[] newArray(int _aidl_size) { return new A[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeByte(e); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; e = _aidl_parcel.readByte(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } } public static class B implements android.os.Parcelable { public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public B createFromParcel(android.os.Parcel _aidl_source) { B _aidl_out = new B(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public B[] newArray(int _aidl_size) { return new B[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } public static class C implements android.os.Parcelable { public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public C createFromParcel(android.os.Parcel _aidl_source) { C _aidl_out = new C(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public C[] newArray(int _aidl_size) { return new C[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } public static class D implements android.os.Parcelable { public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public D createFromParcel(android.os.Parcel _aidl_source) { D _aidl_out = new D(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public D[] newArray(int _aidl_size) { return new D[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } public static @interface E { public static final byte OK = 0; } } } } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_ne0100644 0000000 0000000 00000000222 15172120304 033262 xustar000000000 0000000 118 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/nested/DeeplyNested.java.d 28 mtime=1776853188.6280000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/nested/DeeplyNeste0100644 0000000 0000000 00000000305 15172120304 033066 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/nested/DeeplyNested.java : \ system/tools/aidl/tests/android/aidl/tests/nested/DeeplyNested.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_ne0100644 0000000 0000000 00000000222 15172120304 033262 xustar000000000 0000000 118 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/nested/INestedService.java 28 mtime=1776853188.6280000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/nested/INestedServ0100644 0000000 0000000 00000031702 15172120304 033045 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/nested/INestedService.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/INestedService.aidl */ package android.aidl.tests.nested; public interface INestedService extends android.os.IInterface { /** Default implementation for INestedService. */ public static class Default implements android.aidl.tests.nested.INestedService { @Override public android.aidl.tests.nested.INestedService.Result flipStatus(android.aidl.tests.nested.ParcelableWithNested p) throws android.os.RemoteException { return null; } @Override public void flipStatusWithCallback(byte status, android.aidl.tests.nested.INestedService.ICallback cb) throws android.os.RemoteException { } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.nested.INestedService { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.nested.INestedService interface, * generating a proxy if needed. */ public static android.aidl.tests.nested.INestedService asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.nested.INestedService))) { return ((android.aidl.tests.nested.INestedService)iin); } return new android.aidl.tests.nested.INestedService.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_flipStatus: { return "flipStatus"; } case TRANSACTION_flipStatusWithCallback: { return "flipStatusWithCallback"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_flipStatus: { android.aidl.tests.nested.ParcelableWithNested _arg0; _arg0 = data.readTypedObject(android.aidl.tests.nested.ParcelableWithNested.CREATOR); data.enforceNoDataAvail(); android.aidl.tests.nested.INestedService.Result _result = this.flipStatus(_arg0); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_flipStatusWithCallback: { byte _arg0; _arg0 = data.readByte(); android.aidl.tests.nested.INestedService.ICallback _arg1; _arg1 = android.aidl.tests.nested.INestedService.ICallback.Stub.asInterface(data.readStrongBinder()); data.enforceNoDataAvail(); this.flipStatusWithCallback(_arg0, _arg1); reply.writeNoException(); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.nested.INestedService { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public android.aidl.tests.nested.INestedService.Result flipStatus(android.aidl.tests.nested.ParcelableWithNested p) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.tests.nested.INestedService.Result _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(p, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_flipStatus, _data, _reply, 0); _reply.readException(); _result = _reply.readTypedObject(android.aidl.tests.nested.INestedService.Result.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public void flipStatusWithCallback(byte status, android.aidl.tests.nested.INestedService.ICallback cb) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeByte(status); _data.writeStrongInterface(cb); boolean _status = mRemote.transact(Stub.TRANSACTION_flipStatusWithCallback, _data, _reply, 0); _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } } static final int TRANSACTION_flipStatus = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); static final int TRANSACTION_flipStatusWithCallback = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1); /** @hide */ public int getMaxTransactionId() { return 1; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.nested.INestedService"; public android.aidl.tests.nested.INestedService.Result flipStatus(android.aidl.tests.nested.ParcelableWithNested p) throws android.os.RemoteException; public void flipStatusWithCallback(byte status, android.aidl.tests.nested.INestedService.ICallback cb) throws android.os.RemoteException; public static class Result implements android.os.Parcelable { public byte status = android.aidl.tests.nested.ParcelableWithNested.Status.OK; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public Result createFromParcel(android.os.Parcel _aidl_source) { Result _aidl_out = new Result(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public Result[] newArray(int _aidl_size) { return new Result[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeByte(status); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; status = _aidl_parcel.readByte(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } } public interface ICallback extends android.os.IInterface { /** Default implementation for ICallback. */ public static class Default implements android.aidl.tests.nested.INestedService.ICallback { @Override public void done(byte status) throws android.os.RemoteException { } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.nested.INestedService.ICallback { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.nested.INestedService.ICallback interface, * generating a proxy if needed. */ public static android.aidl.tests.nested.INestedService.ICallback asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.nested.INestedService.ICallback))) { return ((android.aidl.tests.nested.INestedService.ICallback)iin); } return new android.aidl.tests.nested.INestedService.ICallback.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_done: { return "done"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_done: { byte _arg0; _arg0 = data.readByte(); data.enforceNoDataAvail(); this.done(_arg0); reply.writeNoException(); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.nested.INestedService.ICallback { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public void done(byte status) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeByte(status); boolean _status = mRemote.transact(Stub.TRANSACTION_done, _data, _reply, 0); _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } } static final int TRANSACTION_done = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.nested.INestedService.ICallback"; public void done(byte status) throws android.os.RemoteException; } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_ne0100644 0000000 0000000 00000000224 15172120304 033264 xustar000000000 0000000 120 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/nested/INestedService.java.d 28 mtime=1776853188.6290000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/nested/INestedServ0100644 0000000 0000000 00000000431 15172120304 033040 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/nested/INestedService.java : \ system/tools/aidl/tests/android/aidl/tests/nested/INestedService.aidl \ system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_ne0100644 0000000 0000000 00000000230 15172120304 033261 xustar000000000 0000000 124 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/nested/ParcelableWithNested.java 28 mtime=1776853188.6290000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/nested/ParcelableW0100644 0000000 0000000 00000005021 15172120304 033026 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/nested/ParcelableWithNested.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl */ package android.aidl.tests.nested; public class ParcelableWithNested implements android.os.Parcelable { public byte status = android.aidl.tests.nested.ParcelableWithNested.Status.OK; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public ParcelableWithNested createFromParcel(android.os.Parcel _aidl_source) { ParcelableWithNested _aidl_out = new ParcelableWithNested(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public ParcelableWithNested[] newArray(int _aidl_size) { return new ParcelableWithNested[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeByte(status); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; status = _aidl_parcel.readByte(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } public static @interface Status { public static final byte OK = 0; public static final byte NOT_OK = 1; } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_ne0100644 0000000 0000000 00000000232 15172120304 033263 xustar000000000 0000000 126 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/nested/ParcelableWithNested.java.d 28 mtime=1776853188.6290000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/nested/ParcelableW0100644 0000000 0000000 00000000325 15172120304 033030 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/nested/ParcelableWithNested.java : \ system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_un0100644 0000000 0000000 00000000034 15172120304 033303 xustar000000000 0000000 28 mtime=1776853188.6290000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/unions/0040755 0000000 0000000 00000000000 15172120304 030760 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_un0100644 0000000 0000000 00000000215 15172120304 033304 xustar000000000 0000000 113 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/unions/EnumUnion.java 28 mtime=1776853188.6290000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/unions/EnumUnion.j0100644 0000000 0000000 00000012550 15172120304 033050 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/unions/EnumUnion.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl */ package android.aidl.tests.unions; public final class EnumUnion implements android.os.Parcelable { // tags for union fields public final static int intEnum = 0; // android.aidl.tests.IntEnum intEnum; public final static int longEnum = 1; // android.aidl.tests.LongEnum longEnum; public final static int deprecatedField = 2; // int deprecatedField; private int _tag; private Object _value; public EnumUnion() { int _value = android.aidl.tests.IntEnum.FOO; this._tag = intEnum; this._value = _value; } private EnumUnion(android.os.Parcel _aidl_parcel) { readFromParcel(_aidl_parcel); } private EnumUnion(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public int getTag() { return _tag; } // android.aidl.tests.IntEnum intEnum; public static EnumUnion intEnum(int _value) { return new EnumUnion(intEnum, _value); } public int getIntEnum() { _assertTag(intEnum); return (int) _value; } public void setIntEnum(int _value) { _set(intEnum, _value); } // android.aidl.tests.LongEnum longEnum; public static EnumUnion longEnum(long _value) { return new EnumUnion(longEnum, _value); } public long getLongEnum() { _assertTag(longEnum); return (long) _value; } public void setLongEnum(long _value) { _set(longEnum, _value); } // int deprecatedField; /** @deprecated do not use this */ @Deprecated public static EnumUnion deprecatedField(int _value) { return new EnumUnion(deprecatedField, _value); } public int getDeprecatedField() { _assertTag(deprecatedField); return (int) _value; } public void setDeprecatedField(int _value) { _set(deprecatedField, _value); } public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public EnumUnion createFromParcel(android.os.Parcel _aidl_source) { return new EnumUnion(_aidl_source); } @Override public EnumUnion[] newArray(int _aidl_size) { return new EnumUnion[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { _aidl_parcel.writeInt(_tag); switch (_tag) { case intEnum: _aidl_parcel.writeInt(getIntEnum()); break; case longEnum: _aidl_parcel.writeLong(getLongEnum()); break; case deprecatedField: _aidl_parcel.writeInt(getDeprecatedField()); break; } } public void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_tag; _aidl_tag = _aidl_parcel.readInt(); switch (_aidl_tag) { case intEnum: { int _aidl_value; _aidl_value = _aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } case longEnum: { long _aidl_value; _aidl_value = _aidl_parcel.readLong(); _set(_aidl_tag, _aidl_value); return; } case deprecatedField: { int _aidl_value; _aidl_value = _aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } } throw new IllegalArgumentException("union: unknown tag: " + _aidl_tag); } @Override public int describeContents() { int _mask = 0; switch (getTag()) { } return _mask; } @Override public String toString() { switch (_tag) { case intEnum: return "EnumUnion.intEnum(" + (android.aidl.tests.IntEnum.$.toString(getIntEnum())) + ")"; case longEnum: return "EnumUnion.longEnum(" + (getLongEnum()) + ")"; case deprecatedField: return "EnumUnion.deprecatedField(" + (getDeprecatedField()) + ")"; } throw new IllegalStateException("unknown field: " + _tag); } @Override public boolean equals(Object other) { if (this == other) return true; if (other == null) return false; if (!(other instanceof EnumUnion)) return false; EnumUnion that = (EnumUnion)other; if (_tag != that._tag) return false; if (!java.util.Objects.deepEquals(_value, that._value)) return false; return true; } @Override public int hashCode() { return java.util.Arrays.deepHashCode(java.util.Arrays.asList(_tag, _value).toArray()); } private void _assertTag(int tag) { if (getTag() != tag) { throw new IllegalStateException("bad access: " + _tagString(tag) + ", " + _tagString(getTag()) + " is available."); } } private String _tagString(int _tag) { switch (_tag) { case intEnum: return "intEnum"; case longEnum: return "longEnum"; case deprecatedField: return "deprecatedField"; } throw new IllegalStateException("unknown field: " + _tag); } private void _set(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public static @interface Tag { public static final int intEnum = 0; public static final int longEnum = 1; /** @deprecated do not use this */ @Deprecated public static final int deprecatedField = 2; } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_un0100644 0000000 0000000 00000000217 15172120304 033306 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/unions/EnumUnion.java.d 28 mtime=1776853188.6290000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/unions/EnumUnion.j0100644 0000000 0000000 00000000470 15172120304 033046 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/unions/EnumUnion.java : \ system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_un0100644 0000000 0000000 00000000220 15172120304 033300 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/unions/UnionInUnion.java 28 mtime=1776853188.6290000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/unions/UnionInUnio0100644 0000000 0000000 00000011614 15172120304 033115 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/unions/UnionInUnion.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/UnionInUnion.aidl */ package android.aidl.tests.unions; public final class UnionInUnion implements android.os.Parcelable { // tags for union fields public final static int first = 0; // android.aidl.tests.unions.EnumUnion first; public final static int second = 1; // int second; private int _tag; private Object _value; public UnionInUnion() { android.aidl.tests.unions.EnumUnion _value = null; this._tag = first; this._value = _value; } private UnionInUnion(android.os.Parcel _aidl_parcel) { readFromParcel(_aidl_parcel); } private UnionInUnion(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public int getTag() { return _tag; } // android.aidl.tests.unions.EnumUnion first; public static UnionInUnion first(android.aidl.tests.unions.EnumUnion _value) { return new UnionInUnion(first, _value); } public android.aidl.tests.unions.EnumUnion getFirst() { _assertTag(first); return (android.aidl.tests.unions.EnumUnion) _value; } public void setFirst(android.aidl.tests.unions.EnumUnion _value) { _set(first, _value); } // int second; public static UnionInUnion second(int _value) { return new UnionInUnion(second, _value); } public int getSecond() { _assertTag(second); return (int) _value; } public void setSecond(int _value) { _set(second, _value); } public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public UnionInUnion createFromParcel(android.os.Parcel _aidl_source) { return new UnionInUnion(_aidl_source); } @Override public UnionInUnion[] newArray(int _aidl_size) { return new UnionInUnion[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { _aidl_parcel.writeInt(_tag); switch (_tag) { case first: _aidl_parcel.writeTypedObject(getFirst(), _aidl_flag); break; case second: _aidl_parcel.writeInt(getSecond()); break; } } public void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_tag; _aidl_tag = _aidl_parcel.readInt(); switch (_aidl_tag) { case first: { android.aidl.tests.unions.EnumUnion _aidl_value; _aidl_value = _aidl_parcel.readTypedObject(android.aidl.tests.unions.EnumUnion.CREATOR); _set(_aidl_tag, _aidl_value); return; } case second: { int _aidl_value; _aidl_value = _aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } } throw new IllegalArgumentException("union: unknown tag: " + _aidl_tag); } @Override public int describeContents() { int _mask = 0; switch (getTag()) { case first: _mask |= describeContents(getFirst()); break; } return _mask; } private int describeContents(Object _v) { if (_v == null) return 0; if (_v instanceof android.os.Parcelable) { return ((android.os.Parcelable) _v).describeContents(); } return 0; } @Override public String toString() { switch (_tag) { case first: return "UnionInUnion.first(" + (java.util.Objects.toString(getFirst())) + ")"; case second: return "UnionInUnion.second(" + (getSecond()) + ")"; } throw new IllegalStateException("unknown field: " + _tag); } @Override public boolean equals(Object other) { if (this == other) return true; if (other == null) return false; if (!(other instanceof UnionInUnion)) return false; UnionInUnion that = (UnionInUnion)other; if (_tag != that._tag) return false; if (!java.util.Objects.deepEquals(_value, that._value)) return false; return true; } @Override public int hashCode() { return java.util.Arrays.deepHashCode(java.util.Arrays.asList(_tag, _value).toArray()); } private void _assertTag(int tag) { if (getTag() != tag) { throw new IllegalStateException("bad access: " + _tagString(tag) + ", " + _tagString(getTag()) + " is available."); } } private String _tagString(int _tag) { switch (_tag) { case first: return "first"; case second: return "second"; } throw new IllegalStateException("unknown field: " + _tag); } private void _set(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public static @interface Tag { public static final int first = 0; public static final int second = 1; } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_android_aidl_tests_un0100644 0000000 0000000 00000000222 15172120304 033302 xustar000000000 0000000 118 path=tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/unions/UnionInUnion.java.d 28 mtime=1776853188.6300000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/android/aidl/tests/unions/UnionInUnio0100644 0000000 0000000 00000000603 15172120304 033111 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-java-source/gen/android/aidl/tests/unions/UnionInUnion.java : \ system/tools/aidl/tests/android/aidl/tests/unions/UnionInUnion.aidl \ system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-java-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 030751 xustar000000000 0000000 28 mtime=1776853188.6300000 tests/golden_output/frozen/aidl-test-interface-java-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 025663 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_0100644 0000000 0000000 00000000034 15172120304 026027 xustar000000000 0000000 28 mtime=1776853188.6300000 tests/golden_output/frozen/aidl-test-interface-ndk-source/0040755 0000000 0000000 00000000000 15172120304 023034 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_0100644 0000000 0000000 00000000034 15172120304 026660 xustar000000000 0000000 28 mtime=1776853188.6300000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/0040755 0000000 0000000 00000000000 15172120304 023605 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 030360 xustar000000000 0000000 28 mtime=1776853188.6300000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 025225 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 031351 xustar000000000 0000000 28 mtime=1776853188.6300000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 026136 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_0100644 0000000 0000000 00000000034 15172120304 032573 xustar000000000 0000000 28 mtime=1776853188.6300000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/0040755 0000000 0000000 00000000000 15172120304 027300 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Arr0100644 0000000 0000000 00000000214 15172120304 033240 xustar000000000 0000000 112 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/ArrayOfInterfaces.cpp 28 mtime=1776853188.6300000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/ArrayOfInterfaces.c0100644 0000000 0000000 00000064050 15172120304 033015 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ArrayOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ArrayOfInterfaces.aidl */ #include "aidl/android/aidl/tests/ArrayOfInterfaces.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { const char* ArrayOfInterfaces::descriptor = "android.aidl.tests.ArrayOfInterfaces"; binder_status_t ArrayOfInterfaces::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t ArrayOfInterfaces::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { static binder_status_t _aidl_android_aidl_tests_ArrayOfInterfaces_IEmptyInterface_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; (void)_aidl_binder; (void)_aidl_code; return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_tests_ArrayOfInterfaces_IEmptyInterface_clazz = ::ndk::ICInterface::defineClass(ArrayOfInterfaces::IEmptyInterface::descriptor, _aidl_android_aidl_tests_ArrayOfInterfaces_IEmptyInterface_onTransact); ArrayOfInterfaces::BpEmptyInterface::BpEmptyInterface(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} ArrayOfInterfaces::BpEmptyInterface::~BpEmptyInterface() {} // Source for BnEmptyInterface ArrayOfInterfaces::BnEmptyInterface::BnEmptyInterface() {} ArrayOfInterfaces::BnEmptyInterface::~BnEmptyInterface() {} ::ndk::SpAIBinder ArrayOfInterfaces::BnEmptyInterface::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_tests_ArrayOfInterfaces_IEmptyInterface_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for IEmptyInterface const char* ArrayOfInterfaces::IEmptyInterface::descriptor = "android.aidl.tests.ArrayOfInterfaces.IEmptyInterface"; ArrayOfInterfaces::IEmptyInterface::IEmptyInterface() {} ArrayOfInterfaces::IEmptyInterface::~IEmptyInterface() {} std::shared_ptr ArrayOfInterfaces::IEmptyInterface::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_tests_ArrayOfInterfaces_IEmptyInterface_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t ArrayOfInterfaces::IEmptyInterface::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t ArrayOfInterfaces::IEmptyInterface::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = IEmptyInterface::fromBinder(binder); return STATUS_OK; } bool ArrayOfInterfaces::IEmptyInterface::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!IEmptyInterface::default_impl); if (impl) { IEmptyInterface::default_impl = impl; return true; } return false; } const std::shared_ptr& ArrayOfInterfaces::IEmptyInterface::getDefaultImpl() { return IEmptyInterface::default_impl; } std::shared_ptr ArrayOfInterfaces::IEmptyInterface::default_impl = nullptr; ::ndk::SpAIBinder ArrayOfInterfaces::IEmptyInterfaceDefault::asBinder() { return ::ndk::SpAIBinder(); } bool ArrayOfInterfaces::IEmptyInterfaceDefault::isRemote() { return false; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { static binder_status_t _aidl_android_aidl_tests_ArrayOfInterfaces_IMyInterface_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*methodWithInterfaces*/): { std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface> in_iface; std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface> in_nullable_iface; std::vector> in_iface_array_in; std::vector> out_iface_array_out; std::vector> in_iface_array_inout; std::optional>> in_nullable_iface_array_in; std::optional>> out_nullable_iface_array_out; std::optional>> in_nullable_iface_array_inout; std::optional>> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_iface); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_nullable_iface); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_iface_array_in); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_iface_array_out); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_iface_array_inout); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_nullable_iface_array_in); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_nullable_iface_array_out); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_nullable_iface_array_inout); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->methodWithInterfaces(in_iface, in_nullable_iface, in_iface_array_in, &out_iface_array_out, &in_iface_array_inout, in_nullable_iface_array_in, &out_nullable_iface_array_out, &in_nullable_iface_array_inout, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_iface_array_out); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, in_iface_array_inout); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, out_nullable_iface_array_out); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, in_nullable_iface_array_inout); if (_aidl_ret_status != STATUS_OK) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_tests_ArrayOfInterfaces_IMyInterface_clazz = ::ndk::ICInterface::defineClass(ArrayOfInterfaces::IMyInterface::descriptor, _aidl_android_aidl_tests_ArrayOfInterfaces_IMyInterface_onTransact); ArrayOfInterfaces::BpMyInterface::BpMyInterface(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} ArrayOfInterfaces::BpMyInterface::~BpMyInterface() {} ::ndk::ScopedAStatus ArrayOfInterfaces::BpMyInterface::methodWithInterfaces(const std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& in_iface, const std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& in_nullable_iface, const std::vector>& in_iface_array_in, std::vector>* out_iface_array_out, std::vector>* in_iface_array_inout, const std::optional>>& in_nullable_iface_array_in, std::optional>>* out_nullable_iface_array_out, std::optional>>* in_nullable_iface_array_inout, std::optional>>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_iface); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_nullable_iface); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_iface_array_in); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_iface_array_out); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), *in_iface_array_inout); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_nullable_iface_array_in); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_nullable_iface_array_out); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), *in_nullable_iface_array_inout); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*methodWithInterfaces*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IMyInterface::getDefaultImpl()) { _aidl_status = IMyInterface::getDefaultImpl()->methodWithInterfaces(in_iface, in_nullable_iface, in_iface_array_in, out_iface_array_out, in_iface_array_inout, in_nullable_iface_array_in, out_nullable_iface_array_out, in_nullable_iface_array_inout, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_iface_array_out); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), in_iface_array_inout); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), out_nullable_iface_array_out); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), in_nullable_iface_array_inout); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } // Source for BnMyInterface ArrayOfInterfaces::BnMyInterface::BnMyInterface() {} ArrayOfInterfaces::BnMyInterface::~BnMyInterface() {} ::ndk::SpAIBinder ArrayOfInterfaces::BnMyInterface::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_tests_ArrayOfInterfaces_IMyInterface_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for IMyInterface const char* ArrayOfInterfaces::IMyInterface::descriptor = "android.aidl.tests.ArrayOfInterfaces.IMyInterface"; ArrayOfInterfaces::IMyInterface::IMyInterface() {} ArrayOfInterfaces::IMyInterface::~IMyInterface() {} std::shared_ptr ArrayOfInterfaces::IMyInterface::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_tests_ArrayOfInterfaces_IMyInterface_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t ArrayOfInterfaces::IMyInterface::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t ArrayOfInterfaces::IMyInterface::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = IMyInterface::fromBinder(binder); return STATUS_OK; } bool ArrayOfInterfaces::IMyInterface::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!IMyInterface::default_impl); if (impl) { IMyInterface::default_impl = impl; return true; } return false; } const std::shared_ptr& ArrayOfInterfaces::IMyInterface::getDefaultImpl() { return IMyInterface::default_impl; } std::shared_ptr ArrayOfInterfaces::IMyInterface::default_impl = nullptr; ::ndk::ScopedAStatus ArrayOfInterfaces::IMyInterfaceDefault::methodWithInterfaces(const std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& /*in_iface*/, const std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& /*in_nullable_iface*/, const std::vector>& /*in_iface_array_in*/, std::vector>* /*out_iface_array_out*/, std::vector>* /*in_iface_array_inout*/, const std::optional>>& /*in_nullable_iface_array_in*/, std::optional>>* /*out_nullable_iface_array_out*/, std::optional>>* /*in_nullable_iface_array_inout*/, std::optional>>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::SpAIBinder ArrayOfInterfaces::IMyInterfaceDefault::asBinder() { return ::ndk::SpAIBinder(); } bool ArrayOfInterfaces::IMyInterfaceDefault::isRemote() { return false; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { const char* ArrayOfInterfaces::MyParcelable::descriptor = "android.aidl.tests.ArrayOfInterfaces.MyParcelable"; binder_status_t ArrayOfInterfaces::MyParcelable::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &iface); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &nullable_iface); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &iface_array); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &nullable_iface_array); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t ArrayOfInterfaces::MyParcelable::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, iface); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, nullable_iface); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, iface_array); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, nullable_iface_array); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { const char* ArrayOfInterfaces::MyUnion::descriptor = "android.aidl.tests.ArrayOfInterfaces.MyUnion"; binder_status_t ArrayOfInterfaces::MyUnion::readFromParcel(const AParcel* _parcel) { binder_status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_tag)) != STATUS_OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case iface: { std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface> _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case nullable_iface: { std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface> _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readNullableData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case iface_array: { std::vector> _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v>>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case nullable_iface_array: { std::optional>> _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readNullableData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v>>>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } } return STATUS_BAD_VALUE; } binder_status_t ArrayOfInterfaces::MyUnion::writeToParcel(AParcel* _parcel) const { binder_status_t _aidl_ret_status = ::ndk::AParcel_writeData(_parcel, static_cast(getTag())); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; switch (getTag()) { case iface: return ::ndk::AParcel_writeData(_parcel, get()); case nullable_iface: return ::ndk::AParcel_writeNullableData(_parcel, get()); case iface_array: return ::ndk::AParcel_writeData(_parcel, get()); case nullable_iface_array: return ::ndk::AParcel_writeNullableData(_parcel, get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Arr0100644 0000000 0000000 00000000216 15172120304 033242 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/ArrayOfInterfaces.cpp.d 28 mtime=1776853188.6310000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/ArrayOfInterfaces.c0100644 0000000 0000000 00000000277 15172120304 033016 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/ArrayOfInterfaces.cpp : \ system/tools/aidl/tests/android/aidl/tests/ArrayOfInterfaces.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Bac0100644 0000000 0000000 00000000034 15172120304 033201 xustar000000000 0000000 28 mtime=1776853188.6310000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/BackendType.cpp0100644 0000000 0000000 00000001236 15172120304 032174 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/BackendType.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/BackendType.aidl */ // This file is intentionally left blank as placeholder for enum declaration. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Bac0100644 0000000 0000000 00000000034 15172120304 033201 xustar000000000 0000000 28 mtime=1776853188.6310000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/BackendType.cpp.d0100644 0000000 0000000 00000000263 15172120304 032415 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/BackendType.cpp : \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Byt0100644 0000000 0000000 00000000034 15172120304 033252 xustar000000000 0000000 28 mtime=1776853188.6310000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/ByteEnum.cpp0100644 0000000 0000000 00000001230 15172120304 031525 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ByteEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl */ // This file is intentionally left blank as placeholder for enum declaration. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Byt0100644 0000000 0000000 00000000034 15172120304 033252 xustar000000000 0000000 28 mtime=1776853188.6310000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/ByteEnum.cpp.d0100644 0000000 0000000 00000000255 15172120304 031755 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/ByteEnum.cpp : \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Cir0100644 0000000 0000000 00000000215 15172120304 033232 xustar000000000 0000000 113 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/CircularParcelable.cpp 28 mtime=1776853188.6310000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/CircularParcelable.0100644 0000000 0000000 00000006477 15172120304 033033 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/CircularParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl */ #include "aidl/android/aidl/tests/CircularParcelable.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace aidl { namespace android { namespace aidl { namespace tests { const char* CircularParcelable::descriptor = "android.aidl.tests.CircularParcelable"; binder_status_t CircularParcelable::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &testService); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t CircularParcelable::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, testService); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Cir0100644 0000000 0000000 00000000217 15172120304 033234 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/CircularParcelable.cpp.d 28 mtime=1776853188.6310000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/CircularParcelable.0100644 0000000 0000000 00000002233 15172120304 033015 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/CircularParcelable.cpp : \ system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ITestService.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl \ system/tools/aidl/tests/android/aidl/tests/SimpleParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl \ system/tools/aidl/tests/android/aidl/tests/ICircular.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Con0100644 0000000 0000000 00000000221 15172120304 033231 xustar000000000 0000000 117 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/ConstantExpressionEnum.cpp 28 mtime=1776853188.6310000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/ConstantExpressionE0100644 0000000 0000000 00000001264 15172120304 033201 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ConstantExpressionEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl */ // This file is intentionally left blank as placeholder for enum declaration. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Con0100644 0000000 0000000 00000000223 15172120304 033233 xustar000000000 0000000 119 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/ConstantExpressionEnum.cpp.d 28 mtime=1776853188.6310000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/ConstantExpressionE0100644 0000000 0000000 00000000311 15172120304 033171 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/ConstantExpressionEnum.cpp : \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Dep0100644 0000000 0000000 00000000034 15172120304 033224 xustar000000000 0000000 28 mtime=1776853188.6310000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/DeprecatedEnum.cpp0100644 0000000 0000000 00000001244 15172120304 032667 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/DeprecatedEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedEnum.aidl */ // This file is intentionally left blank as placeholder for enum declaration. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Dep0100644 0000000 0000000 00000000213 15172120304 033223 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/DeprecatedEnum.cpp.d 28 mtime=1776853188.6310000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/DeprecatedEnum.cpp.0100644 0000000 0000000 00000000271 15172120304 032744 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/DeprecatedEnum.cpp : \ system/tools/aidl/tests/android/aidl/tests/DeprecatedEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Dep0100644 0000000 0000000 00000000217 15172120304 033227 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/DeprecatedParcelable.cpp 28 mtime=1776853188.6310000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/DeprecatedParcelabl0100644 0000000 0000000 00000004177 15172120304 033077 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/DeprecatedParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedParcelable.aidl */ #include "aidl/android/aidl/tests/DeprecatedParcelable.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { const char* DeprecatedParcelable::descriptor = "android.aidl.tests.DeprecatedParcelable"; binder_status_t DeprecatedParcelable::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t DeprecatedParcelable::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Dep0100644 0000000 0000000 00000000221 15172120304 033222 xustar000000000 0000000 117 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/DeprecatedParcelable.cpp.d 28 mtime=1776853188.6310000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/DeprecatedParcelabl0100644 0000000 0000000 00000000305 15172120304 033064 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/DeprecatedParcelable.cpp : \ system/tools/aidl/tests/android/aidl/tests/DeprecatedParcelable.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Fix0100644 0000000 0000000 00000000034 15172120304 033242 xustar000000000 0000000 28 mtime=1776853188.6310000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/FixedSize.cpp0100644 0000000 0000000 00000030611 15172120304 031674 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/FixedSize.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/FixedSize.aidl */ #include "aidl/android/aidl/tests/FixedSize.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { const char* FixedSize::descriptor = "android.aidl.tests.FixedSize"; binder_status_t FixedSize::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t FixedSize::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { const char* FixedSize::FixedParcelable::descriptor = "android.aidl.tests.FixedSize.FixedParcelable"; binder_status_t FixedSize::FixedParcelable::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &booleanValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &byteValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &charValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &intValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &longValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &floatValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &doubleValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &enumValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &parcelableValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t FixedSize::FixedParcelable::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, booleanValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, byteValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, charValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, intValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, longValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, floatValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, doubleValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, enumValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, parcelableValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { const char* FixedSize::FixedUnion::descriptor = "android.aidl.tests.FixedSize.FixedUnion"; binder_status_t FixedSize::FixedUnion::readFromParcel(const AParcel* _parcel) { binder_status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_tag)) != STATUS_OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case booleanValue: { bool _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case byteValue: { int8_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case charValue: { char16_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case intValue: { int32_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case longValue: { int64_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case floatValue: { float _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case doubleValue: { double _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case enumValue: { ::aidl::android::aidl::tests::LongEnum _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::aidl::android::aidl::tests::LongEnum>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } } return STATUS_BAD_VALUE; } binder_status_t FixedSize::FixedUnion::writeToParcel(AParcel* _parcel) const { binder_status_t _aidl_ret_status = ::ndk::AParcel_writeData(_parcel, static_cast(getTag())); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; switch (getTag()) { case booleanValue: return ::ndk::AParcel_writeData(_parcel, get()); case byteValue: return ::ndk::AParcel_writeData(_parcel, get()); case charValue: return ::ndk::AParcel_writeData(_parcel, get()); case intValue: return ::ndk::AParcel_writeData(_parcel, get()); case longValue: return ::ndk::AParcel_writeData(_parcel, get()); case floatValue: return ::ndk::AParcel_writeData(_parcel, get()); case doubleValue: return ::ndk::AParcel_writeData(_parcel, get()); case enumValue: return ::ndk::AParcel_writeData(_parcel, get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Fix0100644 0000000 0000000 00000000034 15172120304 033242 xustar000000000 0000000 28 mtime=1776853188.6320000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/FixedSize.cpp.d0100644 0000000 0000000 00000000354 15172120304 032117 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/FixedSize.cpp : \ system/tools/aidl/tests/android/aidl/tests/FixedSize.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Gen0100644 0000000 0000000 00000000226 15172120304 033230 xustar000000000 0000000 122 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/GenericStructuredParcelable.cpp 28 mtime=1776853188.6320000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/GenericStructuredPa0100644 0000000 0000000 00000001160 15172120304 033140 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/GenericStructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl */ ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Gen0100644 0000000 0000000 00000000230 15172120304 033223 xustar000000000 0000000 124 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/GenericStructuredParcelable.cpp.d 28 mtime=1776853188.6320000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/GenericStructuredPa0100644 0000000 0000000 00000000323 15172120304 033140 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/GenericStructuredParcelable.cpp : \ system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_ICi0100644 0000000 0000000 00000000034 15172120304 033160 xustar000000000 0000000 28 mtime=1776853188.6320000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/ICircular.cpp0100644 0000000 0000000 00000015513 15172120304 031663 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ICircular.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ICircular.aidl */ #include "aidl/android/aidl/tests/ICircular.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace aidl { namespace android { namespace aidl { namespace tests { static binder_status_t _aidl_android_aidl_tests_ICircular_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*GetTestService*/): { std::shared_ptr<::aidl::android::aidl::tests::ITestService> _aidl_return; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->GetTestService(&_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_tests_ICircular_clazz = ::ndk::ICInterface::defineClass(ICircular::descriptor, _aidl_android_aidl_tests_ICircular_onTransact); BpCircular::BpCircular(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} BpCircular::~BpCircular() {} ::ndk::ScopedAStatus BpCircular::GetTestService(std::shared_ptr<::aidl::android::aidl::tests::ITestService>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*GetTestService*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ICircular::getDefaultImpl()) { _aidl_status = ICircular::getDefaultImpl()->GetTestService(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } // Source for BnCircular BnCircular::BnCircular() {} BnCircular::~BnCircular() {} ::ndk::SpAIBinder BnCircular::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_tests_ICircular_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for ICircular const char* ICircular::descriptor = "android.aidl.tests.ICircular"; ICircular::ICircular() {} ICircular::~ICircular() {} std::shared_ptr ICircular::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_tests_ICircular_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t ICircular::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t ICircular::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = ICircular::fromBinder(binder); return STATUS_OK; } bool ICircular::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!ICircular::default_impl); if (impl) { ICircular::default_impl = impl; return true; } return false; } const std::shared_ptr& ICircular::getDefaultImpl() { return ICircular::default_impl; } std::shared_ptr ICircular::default_impl = nullptr; ::ndk::ScopedAStatus ICircularDefault::GetTestService(std::shared_ptr<::aidl::android::aidl::tests::ITestService>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::SpAIBinder ICircularDefault::asBinder() { return ::ndk::SpAIBinder(); } bool ICircularDefault::isRemote() { return false; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_ICi0100644 0000000 0000000 00000000034 15172120304 033160 xustar000000000 0000000 28 mtime=1776853188.6320000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/ICircular.cpp.d0100644 0000000 0000000 00000002222 15172120304 032076 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/ICircular.cpp : \ system/tools/aidl/tests/android/aidl/tests/ICircular.aidl \ system/tools/aidl/tests/android/aidl/tests/ITestService.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl \ system/tools/aidl/tests/android/aidl/tests/SimpleParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl \ system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_IDe0100644 0000000 0000000 00000000034 15172120304 033155 xustar000000000 0000000 28 mtime=1776853188.6330000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/IDeprecated.cpp0100644 0000000 0000000 00000010224 15172120304 032151 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/IDeprecated.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IDeprecated.aidl */ #include "aidl/android/aidl/tests/IDeprecated.h" #include #include #include namespace aidl { namespace android { namespace aidl { namespace tests { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated" static binder_status_t _aidl_android_aidl_tests_IDeprecated_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; (void)_aidl_binder; (void)_aidl_code; return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_tests_IDeprecated_clazz = ::ndk::ICInterface::defineClass(IDeprecated::descriptor, _aidl_android_aidl_tests_IDeprecated_onTransact); #pragma clang diagnostic pop BpDeprecated::BpDeprecated(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} BpDeprecated::~BpDeprecated() {} // Source for BnDeprecated BnDeprecated::BnDeprecated() {} BnDeprecated::~BnDeprecated() {} ::ndk::SpAIBinder BnDeprecated::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_tests_IDeprecated_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for IDeprecated const char* IDeprecated::descriptor = "android.aidl.tests.IDeprecated"; IDeprecated::IDeprecated() {} IDeprecated::~IDeprecated() {} std::shared_ptr IDeprecated::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_tests_IDeprecated_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t IDeprecated::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t IDeprecated::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = IDeprecated::fromBinder(binder); return STATUS_OK; } bool IDeprecated::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!IDeprecated::default_impl); if (impl) { IDeprecated::default_impl = impl; return true; } return false; } const std::shared_ptr& IDeprecated::getDefaultImpl() { return IDeprecated::default_impl; } std::shared_ptr IDeprecated::default_impl = nullptr; ::ndk::SpAIBinder IDeprecatedDefault::asBinder() { return ::ndk::SpAIBinder(); } bool IDeprecatedDefault::isRemote() { return false; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_IDe0100644 0000000 0000000 00000000034 15172120304 033155 xustar000000000 0000000 28 mtime=1776853188.6330000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/IDeprecated.cpp.d0100644 0000000 0000000 00000000263 15172120304 032375 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/IDeprecated.cpp : \ system/tools/aidl/tests/android/aidl/tests/IDeprecated.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_INa0100644 0000000 0000000 00000000034 15172120304 033163 xustar000000000 0000000 28 mtime=1776853188.6330000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/INamedCallback.cpp0100644 0000000 0000000 00000014506 15172120304 032561 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/INamedCallback.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl */ #include "aidl/android/aidl/tests/INamedCallback.h" #include #include #include namespace aidl { namespace android { namespace aidl { namespace tests { static binder_status_t _aidl_android_aidl_tests_INamedCallback_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*GetName*/): { std::string _aidl_return; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->GetName(&_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_tests_INamedCallback_clazz = ::ndk::ICInterface::defineClass(INamedCallback::descriptor, _aidl_android_aidl_tests_INamedCallback_onTransact); BpNamedCallback::BpNamedCallback(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} BpNamedCallback::~BpNamedCallback() {} ::ndk::ScopedAStatus BpNamedCallback::GetName(std::string* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*GetName*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && INamedCallback::getDefaultImpl()) { _aidl_status = INamedCallback::getDefaultImpl()->GetName(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } // Source for BnNamedCallback BnNamedCallback::BnNamedCallback() {} BnNamedCallback::~BnNamedCallback() {} ::ndk::SpAIBinder BnNamedCallback::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_tests_INamedCallback_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for INamedCallback const char* INamedCallback::descriptor = "android.aidl.tests.INamedCallback"; INamedCallback::INamedCallback() {} INamedCallback::~INamedCallback() {} std::shared_ptr INamedCallback::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_tests_INamedCallback_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t INamedCallback::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t INamedCallback::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = INamedCallback::fromBinder(binder); return STATUS_OK; } bool INamedCallback::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!INamedCallback::default_impl); if (impl) { INamedCallback::default_impl = impl; return true; } return false; } const std::shared_ptr& INamedCallback::getDefaultImpl() { return INamedCallback::default_impl; } std::shared_ptr INamedCallback::default_impl = nullptr; ::ndk::ScopedAStatus INamedCallbackDefault::GetName(std::string* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::SpAIBinder INamedCallbackDefault::asBinder() { return ::ndk::SpAIBinder(); } bool INamedCallbackDefault::isRemote() { return false; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_INa0100644 0000000 0000000 00000000213 15172120304 033162 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/INamedCallback.cpp.d 28 mtime=1776853188.6330000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/INamedCallback.cpp.0100644 0000000 0000000 00000000271 15172120304 032631 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/INamedCallback.cpp : \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_INe0100644 0000000 0000000 00000000034 15172120304 033167 xustar000000000 0000000 28 mtime=1776853188.6330000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/INewName.cpp0100644 0000000 0000000 00000014002 15172120304 031441 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/INewName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INewName.aidl */ #include "aidl/android/aidl/tests/INewName.h" #include #include #include namespace aidl { namespace android { namespace aidl { namespace tests { static binder_status_t _aidl_android_aidl_tests_INewName_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*RealName*/): { std::string _aidl_return; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RealName(&_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_tests_INewName_clazz = ::ndk::ICInterface::defineClass(INewName::descriptor, _aidl_android_aidl_tests_INewName_onTransact); BpNewName::BpNewName(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} BpNewName::~BpNewName() {} ::ndk::ScopedAStatus BpNewName::RealName(std::string* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*RealName*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && INewName::getDefaultImpl()) { _aidl_status = INewName::getDefaultImpl()->RealName(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } // Source for BnNewName BnNewName::BnNewName() {} BnNewName::~BnNewName() {} ::ndk::SpAIBinder BnNewName::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_tests_INewName_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for INewName const char* INewName::descriptor = "android.aidl.tests.IOldName"; INewName::INewName() {} INewName::~INewName() {} std::shared_ptr INewName::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_tests_INewName_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t INewName::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t INewName::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = INewName::fromBinder(binder); return STATUS_OK; } bool INewName::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!INewName::default_impl); if (impl) { INewName::default_impl = impl; return true; } return false; } const std::shared_ptr& INewName::getDefaultImpl() { return INewName::default_impl; } std::shared_ptr INewName::default_impl = nullptr; ::ndk::ScopedAStatus INewNameDefault::RealName(std::string* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::SpAIBinder INewNameDefault::asBinder() { return ::ndk::SpAIBinder(); } bool INewNameDefault::isRemote() { return false; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_INe0100644 0000000 0000000 00000000034 15172120304 033167 xustar000000000 0000000 28 mtime=1776853188.6330000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/INewName.cpp.d0100644 0000000 0000000 00000000255 15172120304 031670 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/INewName.cpp : \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_IOl0100644 0000000 0000000 00000000034 15172120304 033177 xustar000000000 0000000 28 mtime=1776853188.6330000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/IOldName.cpp0100644 0000000 0000000 00000014002 15172120304 031426 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/IOldName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IOldName.aidl */ #include "aidl/android/aidl/tests/IOldName.h" #include #include #include namespace aidl { namespace android { namespace aidl { namespace tests { static binder_status_t _aidl_android_aidl_tests_IOldName_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*RealName*/): { std::string _aidl_return; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RealName(&_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_tests_IOldName_clazz = ::ndk::ICInterface::defineClass(IOldName::descriptor, _aidl_android_aidl_tests_IOldName_onTransact); BpOldName::BpOldName(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} BpOldName::~BpOldName() {} ::ndk::ScopedAStatus BpOldName::RealName(std::string* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*RealName*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IOldName::getDefaultImpl()) { _aidl_status = IOldName::getDefaultImpl()->RealName(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } // Source for BnOldName BnOldName::BnOldName() {} BnOldName::~BnOldName() {} ::ndk::SpAIBinder BnOldName::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_tests_IOldName_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for IOldName const char* IOldName::descriptor = "android.aidl.tests.IOldName"; IOldName::IOldName() {} IOldName::~IOldName() {} std::shared_ptr IOldName::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_tests_IOldName_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t IOldName::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t IOldName::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = IOldName::fromBinder(binder); return STATUS_OK; } bool IOldName::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!IOldName::default_impl); if (impl) { IOldName::default_impl = impl; return true; } return false; } const std::shared_ptr& IOldName::getDefaultImpl() { return IOldName::default_impl; } std::shared_ptr IOldName::default_impl = nullptr; ::ndk::ScopedAStatus IOldNameDefault::RealName(std::string* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::SpAIBinder IOldNameDefault::asBinder() { return ::ndk::SpAIBinder(); } bool IOldNameDefault::isRemote() { return false; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_IOl0100644 0000000 0000000 00000000034 15172120304 033177 xustar000000000 0000000 28 mtime=1776853188.6330000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/IOldName.cpp.d0100644 0000000 0000000 00000000255 15172120304 031655 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/IOldName.cpp : \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_ITe0100644 0000000 0000000 00000000034 15172120304 033175 xustar000000000 0000000 28 mtime=1776853188.6340000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/ITestService.cpp0100644 0000000 0000000 00000721650 15172120304 032365 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ITestService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ITestService.aidl */ #include "aidl/android/aidl/tests/ITestService.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace aidl { namespace android { namespace aidl { namespace tests { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated" static binder_status_t _aidl_android_aidl_tests_ITestService_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*UnimplementedMethod*/): { int32_t in_arg; int32_t _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_arg); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->UnimplementedMethod(in_arg, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 1 /*Deprecated*/): { ::ndk::ScopedAStatus _aidl_status = _aidl_impl->Deprecated(); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } case (FIRST_CALL_TRANSACTION + 2 /*TestOneway*/): { ::ndk::ScopedAStatus _aidl_status = _aidl_impl->TestOneway(); _aidl_ret_status = STATUS_OK; break; } case (FIRST_CALL_TRANSACTION + 3 /*RepeatBoolean*/): { bool in_token; bool _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_token); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatBoolean(in_token, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 4 /*RepeatByte*/): { int8_t in_token; int8_t _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_token); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatByte(in_token, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 5 /*RepeatChar*/): { char16_t in_token; char16_t _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_token); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatChar(in_token, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 6 /*RepeatInt*/): { int32_t in_token; int32_t _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_token); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatInt(in_token, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 7 /*RepeatLong*/): { int64_t in_token; int64_t _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_token); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatLong(in_token, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 8 /*RepeatFloat*/): { float in_token; float _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_token); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatFloat(in_token, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 9 /*RepeatDouble*/): { double in_token; double _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_token); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatDouble(in_token, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 10 /*RepeatString*/): { std::string in_token; std::string _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_token); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatString(in_token, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 11 /*RepeatByteEnum*/): { ::aidl::android::aidl::tests::ByteEnum in_token; ::aidl::android::aidl::tests::ByteEnum _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_token); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatByteEnum(in_token, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 12 /*RepeatIntEnum*/): { ::aidl::android::aidl::tests::IntEnum in_token; ::aidl::android::aidl::tests::IntEnum _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_token); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatIntEnum(in_token, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 13 /*RepeatLongEnum*/): { ::aidl::android::aidl::tests::LongEnum in_token; ::aidl::android::aidl::tests::LongEnum _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_token); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatLongEnum(in_token, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 14 /*ReverseBoolean*/): { std::vector in_input; std::vector out_repeated; std::vector _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_repeated); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseBoolean(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 15 /*ReverseByte*/): { std::vector in_input; std::vector out_repeated; std::vector _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_repeated); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseByte(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 16 /*ReverseChar*/): { std::vector in_input; std::vector out_repeated; std::vector _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_repeated); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseChar(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 17 /*ReverseInt*/): { std::vector in_input; std::vector out_repeated; std::vector _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_repeated); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseInt(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 18 /*ReverseLong*/): { std::vector in_input; std::vector out_repeated; std::vector _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_repeated); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseLong(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 19 /*ReverseFloat*/): { std::vector in_input; std::vector out_repeated; std::vector _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_repeated); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseFloat(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 20 /*ReverseDouble*/): { std::vector in_input; std::vector out_repeated; std::vector _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_repeated); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseDouble(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 21 /*ReverseString*/): { std::vector in_input; std::vector out_repeated; std::vector _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_repeated); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseString(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 22 /*ReverseByteEnum*/): { std::vector<::aidl::android::aidl::tests::ByteEnum> in_input; std::vector<::aidl::android::aidl::tests::ByteEnum> out_repeated; std::vector<::aidl::android::aidl::tests::ByteEnum> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_repeated); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseByteEnum(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 23 /*ReverseIntEnum*/): { std::vector<::aidl::android::aidl::tests::IntEnum> in_input; std::vector<::aidl::android::aidl::tests::IntEnum> out_repeated; std::vector<::aidl::android::aidl::tests::IntEnum> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_repeated); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseIntEnum(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 24 /*ReverseLongEnum*/): { std::vector<::aidl::android::aidl::tests::LongEnum> in_input; std::vector<::aidl::android::aidl::tests::LongEnum> out_repeated; std::vector<::aidl::android::aidl::tests::LongEnum> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_repeated); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseLongEnum(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 25 /*GetOtherTestService*/): { std::string in_name; std::shared_ptr<::aidl::android::aidl::tests::INamedCallback> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_name); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->GetOtherTestService(in_name, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 26 /*SetOtherTestService*/): { std::string in_name; std::shared_ptr<::aidl::android::aidl::tests::INamedCallback> in_service; bool _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_name); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_service); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->SetOtherTestService(in_name, in_service, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 27 /*VerifyName*/): { std::shared_ptr<::aidl::android::aidl::tests::INamedCallback> in_service; std::string in_name; bool _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_service); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_name); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->VerifyName(in_service, in_name, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 28 /*GetInterfaceArray*/): { std::vector in_names; std::vector> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_names); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->GetInterfaceArray(in_names, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 29 /*VerifyNamesWithInterfaceArray*/): { std::vector> in_services; std::vector in_names; bool _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_services); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_names); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->VerifyNamesWithInterfaceArray(in_services, in_names, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 30 /*GetNullableInterfaceArray*/): { std::optional>> in_names; std::optional>> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_names); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->GetNullableInterfaceArray(in_names, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 31 /*VerifyNamesWithNullableInterfaceArray*/): { std::optional>> in_services; std::optional>> in_names; bool _aidl_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_services); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_names); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->VerifyNamesWithNullableInterfaceArray(in_services, in_names, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 32 /*GetInterfaceList*/): { std::optional>> in_names; std::optional>> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_names); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->GetInterfaceList(in_names, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 33 /*VerifyNamesWithInterfaceList*/): { std::optional>> in_services; std::optional>> in_names; bool _aidl_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_services); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_names); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->VerifyNamesWithInterfaceList(in_services, in_names, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 34 /*ReverseStringList*/): { std::vector in_input; std::vector out_repeated; std::vector _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseStringList(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 35 /*RepeatParcelFileDescriptor*/): { ::ndk::ScopedFileDescriptor in_read; ::ndk::ScopedFileDescriptor _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_read); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatParcelFileDescriptor(in_read, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 36 /*ReverseParcelFileDescriptorArray*/): { std::vector<::ndk::ScopedFileDescriptor> in_input; std::vector<::ndk::ScopedFileDescriptor> out_repeated; std::vector<::ndk::ScopedFileDescriptor> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_repeated); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseParcelFileDescriptorArray(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 37 /*ThrowServiceException*/): { int32_t in_code; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_code); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ThrowServiceException(in_code); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } case (FIRST_CALL_TRANSACTION + 38 /*RepeatNullableIntArray*/): { std::optional> in_input; std::optional> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatNullableIntArray(in_input, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 39 /*RepeatNullableByteEnumArray*/): { std::optional> in_input; std::optional> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatNullableByteEnumArray(in_input, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 40 /*RepeatNullableIntEnumArray*/): { std::optional> in_input; std::optional> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatNullableIntEnumArray(in_input, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 41 /*RepeatNullableLongEnumArray*/): { std::optional> in_input; std::optional> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatNullableLongEnumArray(in_input, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 42 /*RepeatNullableString*/): { std::optional in_input; std::optional _aidl_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatNullableString(in_input, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 43 /*RepeatNullableStringList*/): { std::optional>> in_input; std::optional>> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatNullableStringList(in_input, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 44 /*RepeatNullableParcelable*/): { std::optional<::aidl::android::aidl::tests::ITestService::Empty> in_input; std::optional<::aidl::android::aidl::tests::ITestService::Empty> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatNullableParcelable(in_input, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 45 /*RepeatNullableParcelableArray*/): { std::optional>> in_input; std::optional>> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatNullableParcelableArray(in_input, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 46 /*RepeatNullableParcelableList*/): { std::optional>> in_input; std::optional>> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatNullableParcelableList(in_input, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 47 /*TakesAnIBinder*/): { ::ndk::SpAIBinder in_input; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->TakesAnIBinder(in_input); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } case (FIRST_CALL_TRANSACTION + 48 /*TakesANullableIBinder*/): { ::ndk::SpAIBinder in_input; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->TakesANullableIBinder(in_input); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } case (FIRST_CALL_TRANSACTION + 49 /*TakesAnIBinderList*/): { std::vector<::ndk::SpAIBinder> in_input; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->TakesAnIBinderList(in_input); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } case (FIRST_CALL_TRANSACTION + 50 /*TakesANullableIBinderList*/): { std::optional> in_input; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->TakesANullableIBinderList(in_input); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } case (FIRST_CALL_TRANSACTION + 51 /*RepeatUtf8CppString*/): { std::string in_token; std::string _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_token); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatUtf8CppString(in_token, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 52 /*RepeatNullableUtf8CppString*/): { std::optional in_token; std::optional _aidl_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_token); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatNullableUtf8CppString(in_token, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 53 /*ReverseUtf8CppString*/): { std::vector in_input; std::vector out_repeated; std::vector _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_repeated); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseUtf8CppString(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 54 /*ReverseNullableUtf8CppString*/): { std::optional>> in_input; std::optional>> out_repeated; std::optional>> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_repeated); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseNullableUtf8CppString(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 55 /*ReverseUtf8CppStringList*/): { std::optional>> in_input; std::optional>> out_repeated; std::optional>> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseUtf8CppStringList(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 56 /*GetCallback*/): { bool in_return_null; std::shared_ptr<::aidl::android::aidl::tests::INamedCallback> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_return_null); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->GetCallback(in_return_null, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 57 /*FillOutStructuredParcelable*/): { ::aidl::android::aidl::tests::StructuredParcelable in_parcel; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_parcel); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->FillOutStructuredParcelable(&in_parcel); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, in_parcel); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 58 /*RepeatExtendableParcelable*/): { ::aidl::android::aidl::tests::extension::ExtendableParcelable in_ep; ::aidl::android::aidl::tests::extension::ExtendableParcelable out_ep2; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_ep); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatExtendableParcelable(in_ep, &out_ep2); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_ep2); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 59 /*ReverseList*/): { ::aidl::android::aidl::tests::RecursiveList in_list; ::aidl::android::aidl::tests::RecursiveList _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_list); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseList(in_list, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 60 /*ReverseIBinderArray*/): { std::vector<::ndk::SpAIBinder> in_input; std::vector<::ndk::SpAIBinder> out_repeated; std::vector<::ndk::SpAIBinder> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_repeated); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseIBinderArray(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 61 /*ReverseNullableIBinderArray*/): { std::optional> in_input; std::optional> out_repeated; std::optional> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_repeated); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseNullableIBinderArray(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 62 /*RepeatSimpleParcelable*/): { ::aidl::android::aidl::tests::SimpleParcelable in_input; ::aidl::android::aidl::tests::SimpleParcelable out_repeat; ::aidl::android::aidl::tests::SimpleParcelable _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->RepeatSimpleParcelable(in_input, &out_repeat, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeat); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 63 /*ReverseSimpleParcelables*/): { std::vector<::aidl::android::aidl::tests::SimpleParcelable> in_input; std::vector<::aidl::android::aidl::tests::SimpleParcelable> out_repeated; std::vector<::aidl::android::aidl::tests::SimpleParcelable> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &out_repeated); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ReverseSimpleParcelables(in_input, &out_repeated, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_repeated); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 64 /*GetOldNameInterface*/): { std::shared_ptr<::aidl::android::aidl::tests::IOldName> _aidl_return; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->GetOldNameInterface(&_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 65 /*GetNewNameInterface*/): { std::shared_ptr<::aidl::android::aidl::tests::INewName> _aidl_return; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->GetNewNameInterface(&_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 66 /*GetUnionTags*/): { std::vector<::aidl::android::aidl::tests::Union> in_input; std::vector<::aidl::android::aidl::tests::Union::Tag> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->GetUnionTags(in_input, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 67 /*GetCppJavaTests*/): { ::ndk::SpAIBinder _aidl_return; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->GetCppJavaTests(&_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 68 /*getBackendType*/): { ::aidl::android::aidl::tests::BackendType _aidl_return; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->getBackendType(&_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 69 /*GetCircular*/): { ::aidl::android::aidl::tests::CircularParcelable out_cp; std::shared_ptr<::aidl::android::aidl::tests::ICircular> _aidl_return; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->GetCircular(&out_cp, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_cp); if (_aidl_ret_status != STATUS_OK) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_tests_ITestService_clazz = ::ndk::ICInterface::defineClass(ITestService::descriptor, _aidl_android_aidl_tests_ITestService_onTransact); #pragma clang diagnostic pop BpTestService::BpTestService(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} BpTestService::~BpTestService() {} ::ndk::ScopedAStatus BpTestService::UnimplementedMethod(int32_t in_arg, int32_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_arg); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*UnimplementedMethod*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->UnimplementedMethod(in_arg, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::Deprecated() { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 1 /*Deprecated*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->Deprecated(); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::TestOneway() { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 2 /*TestOneway*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_ONEWAY | FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->TestOneway(); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatBoolean(bool in_token, bool* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_token); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 3 /*RepeatBoolean*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatBoolean(in_token, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatByte(int8_t in_token, int8_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_token); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 4 /*RepeatByte*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatByte(in_token, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatChar(char16_t in_token, char16_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_token); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 5 /*RepeatChar*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatChar(in_token, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatInt(int32_t in_token, int32_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_token); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 6 /*RepeatInt*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatInt(in_token, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatLong(int64_t in_token, int64_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_token); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 7 /*RepeatLong*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatLong(in_token, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatFloat(float in_token, float* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_token); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 8 /*RepeatFloat*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatFloat(in_token, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatDouble(double in_token, double* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_token); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 9 /*RepeatDouble*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatDouble(in_token, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatString(const std::string& in_token, std::string* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_token); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 10 /*RepeatString*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatString(in_token, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatByteEnum(::aidl::android::aidl::tests::ByteEnum in_token, ::aidl::android::aidl::tests::ByteEnum* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_token); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 11 /*RepeatByteEnum*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatByteEnum(in_token, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatIntEnum(::aidl::android::aidl::tests::IntEnum in_token, ::aidl::android::aidl::tests::IntEnum* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_token); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 12 /*RepeatIntEnum*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatIntEnum(in_token, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatLongEnum(::aidl::android::aidl::tests::LongEnum in_token, ::aidl::android::aidl::tests::LongEnum* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_token); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 13 /*RepeatLongEnum*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatLongEnum(in_token, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseBoolean(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 14 /*ReverseBoolean*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseBoolean(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseByte(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 15 /*ReverseByte*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseByte(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseChar(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 16 /*ReverseChar*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseChar(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseInt(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 17 /*ReverseInt*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseInt(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseLong(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 18 /*ReverseLong*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseLong(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseFloat(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 19 /*ReverseFloat*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseFloat(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseDouble(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 20 /*ReverseDouble*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseDouble(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseString(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 21 /*ReverseString*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseString(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseByteEnum(const std::vector<::aidl::android::aidl::tests::ByteEnum>& in_input, std::vector<::aidl::android::aidl::tests::ByteEnum>* out_repeated, std::vector<::aidl::android::aidl::tests::ByteEnum>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 22 /*ReverseByteEnum*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseByteEnum(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseIntEnum(const std::vector<::aidl::android::aidl::tests::IntEnum>& in_input, std::vector<::aidl::android::aidl::tests::IntEnum>* out_repeated, std::vector<::aidl::android::aidl::tests::IntEnum>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 23 /*ReverseIntEnum*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseIntEnum(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseLongEnum(const std::vector<::aidl::android::aidl::tests::LongEnum>& in_input, std::vector<::aidl::android::aidl::tests::LongEnum>* out_repeated, std::vector<::aidl::android::aidl::tests::LongEnum>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 24 /*ReverseLongEnum*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseLongEnum(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::GetOtherTestService(const std::string& in_name, std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_name); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 25 /*GetOtherTestService*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->GetOtherTestService(in_name, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::SetOtherTestService(const std::string& in_name, const std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>& in_service, bool* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_name); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_service); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 26 /*SetOtherTestService*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->SetOtherTestService(in_name, in_service, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::VerifyName(const std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>& in_service, const std::string& in_name, bool* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_service); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_name); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 27 /*VerifyName*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->VerifyName(in_service, in_name, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::GetInterfaceArray(const std::vector& in_names, std::vector>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_names); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 28 /*GetInterfaceArray*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->GetInterfaceArray(in_names, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::VerifyNamesWithInterfaceArray(const std::vector>& in_services, const std::vector& in_names, bool* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_services); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_names); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 29 /*VerifyNamesWithInterfaceArray*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->VerifyNamesWithInterfaceArray(in_services, in_names, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::GetNullableInterfaceArray(const std::optional>>& in_names, std::optional>>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_names); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 30 /*GetNullableInterfaceArray*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->GetNullableInterfaceArray(in_names, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::VerifyNamesWithNullableInterfaceArray(const std::optional>>& in_services, const std::optional>>& in_names, bool* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_services); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_names); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 31 /*VerifyNamesWithNullableInterfaceArray*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->VerifyNamesWithNullableInterfaceArray(in_services, in_names, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::GetInterfaceList(const std::optional>>& in_names, std::optional>>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_names); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 32 /*GetInterfaceList*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->GetInterfaceList(in_names, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::VerifyNamesWithInterfaceList(const std::optional>>& in_services, const std::optional>>& in_names, bool* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_services); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_names); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 33 /*VerifyNamesWithInterfaceList*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->VerifyNamesWithInterfaceList(in_services, in_names, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseStringList(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 34 /*ReverseStringList*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseStringList(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatParcelFileDescriptor(const ::ndk::ScopedFileDescriptor& in_read, ::ndk::ScopedFileDescriptor* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_read); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 35 /*RepeatParcelFileDescriptor*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatParcelFileDescriptor(in_read, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseParcelFileDescriptorArray(const std::vector<::ndk::ScopedFileDescriptor>& in_input, std::vector<::ndk::ScopedFileDescriptor>* out_repeated, std::vector<::ndk::ScopedFileDescriptor>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 36 /*ReverseParcelFileDescriptorArray*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseParcelFileDescriptorArray(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ThrowServiceException(int32_t in_code) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_code); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 37 /*ThrowServiceException*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ThrowServiceException(in_code); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatNullableIntArray(const std::optional>& in_input, std::optional>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 38 /*RepeatNullableIntArray*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatNullableIntArray(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatNullableByteEnumArray(const std::optional>& in_input, std::optional>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 39 /*RepeatNullableByteEnumArray*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatNullableByteEnumArray(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatNullableIntEnumArray(const std::optional>& in_input, std::optional>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 40 /*RepeatNullableIntEnumArray*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatNullableIntEnumArray(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatNullableLongEnumArray(const std::optional>& in_input, std::optional>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 41 /*RepeatNullableLongEnumArray*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatNullableLongEnumArray(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatNullableString(const std::optional& in_input, std::optional* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 42 /*RepeatNullableString*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatNullableString(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatNullableStringList(const std::optional>>& in_input, std::optional>>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 43 /*RepeatNullableStringList*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatNullableStringList(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatNullableParcelable(const std::optional<::aidl::android::aidl::tests::ITestService::Empty>& in_input, std::optional<::aidl::android::aidl::tests::ITestService::Empty>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 44 /*RepeatNullableParcelable*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatNullableParcelable(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatNullableParcelableArray(const std::optional>>& in_input, std::optional>>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 45 /*RepeatNullableParcelableArray*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatNullableParcelableArray(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatNullableParcelableList(const std::optional>>& in_input, std::optional>>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 46 /*RepeatNullableParcelableList*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatNullableParcelableList(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::TakesAnIBinder(const ::ndk::SpAIBinder& in_input) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 47 /*TakesAnIBinder*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->TakesAnIBinder(in_input); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::TakesANullableIBinder(const ::ndk::SpAIBinder& in_input) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 48 /*TakesANullableIBinder*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->TakesANullableIBinder(in_input); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::TakesAnIBinderList(const std::vector<::ndk::SpAIBinder>& in_input) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 49 /*TakesAnIBinderList*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->TakesAnIBinderList(in_input); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::TakesANullableIBinderList(const std::optional>& in_input) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 50 /*TakesANullableIBinderList*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->TakesANullableIBinderList(in_input); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatUtf8CppString(const std::string& in_token, std::string* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_token); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 51 /*RepeatUtf8CppString*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatUtf8CppString(in_token, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatNullableUtf8CppString(const std::optional& in_token, std::optional* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_token); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 52 /*RepeatNullableUtf8CppString*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatNullableUtf8CppString(in_token, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseUtf8CppString(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 53 /*ReverseUtf8CppString*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseUtf8CppString(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseNullableUtf8CppString(const std::optional>>& in_input, std::optional>>* out_repeated, std::optional>>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 54 /*ReverseNullableUtf8CppString*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseNullableUtf8CppString(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseUtf8CppStringList(const std::optional>>& in_input, std::optional>>* out_repeated, std::optional>>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 55 /*ReverseUtf8CppStringList*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseUtf8CppStringList(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::GetCallback(bool in_return_null, std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_return_null); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 56 /*GetCallback*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->GetCallback(in_return_null, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::FillOutStructuredParcelable(::aidl::android::aidl::tests::StructuredParcelable* in_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), *in_parcel); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 57 /*FillOutStructuredParcelable*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->FillOutStructuredParcelable(in_parcel); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), in_parcel); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatExtendableParcelable(const ::aidl::android::aidl::tests::extension::ExtendableParcelable& in_ep, ::aidl::android::aidl::tests::extension::ExtendableParcelable* out_ep2) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_ep); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 58 /*RepeatExtendableParcelable*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatExtendableParcelable(in_ep, out_ep2); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_ep2); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseList(const ::aidl::android::aidl::tests::RecursiveList& in_list, ::aidl::android::aidl::tests::RecursiveList* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_list); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 59 /*ReverseList*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseList(in_list, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseIBinderArray(const std::vector<::ndk::SpAIBinder>& in_input, std::vector<::ndk::SpAIBinder>* out_repeated, std::vector<::ndk::SpAIBinder>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 60 /*ReverseIBinderArray*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseIBinderArray(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseNullableIBinderArray(const std::optional>& in_input, std::optional>* out_repeated, std::optional>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 61 /*ReverseNullableIBinderArray*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseNullableIBinderArray(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::RepeatSimpleParcelable(const ::aidl::android::aidl::tests::SimpleParcelable& in_input, ::aidl::android::aidl::tests::SimpleParcelable* out_repeat, ::aidl::android::aidl::tests::SimpleParcelable* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 62 /*RepeatSimpleParcelable*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->RepeatSimpleParcelable(in_input, out_repeat, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeat); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::ReverseSimpleParcelables(const std::vector<::aidl::android::aidl::tests::SimpleParcelable>& in_input, std::vector<::aidl::android::aidl::tests::SimpleParcelable>* out_repeated, std::vector<::aidl::android::aidl::tests::SimpleParcelable>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 63 /*ReverseSimpleParcelables*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->ReverseSimpleParcelables(in_input, out_repeated, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_repeated); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::GetOldNameInterface(std::shared_ptr<::aidl::android::aidl::tests::IOldName>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 64 /*GetOldNameInterface*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->GetOldNameInterface(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::GetNewNameInterface(std::shared_ptr<::aidl::android::aidl::tests::INewName>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 65 /*GetNewNameInterface*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->GetNewNameInterface(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::GetUnionTags(const std::vector<::aidl::android::aidl::tests::Union>& in_input, std::vector<::aidl::android::aidl::tests::Union::Tag>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 66 /*GetUnionTags*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->GetUnionTags(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::GetCppJavaTests(::ndk::SpAIBinder* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 67 /*GetCppJavaTests*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->GetCppJavaTests(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::getBackendType(::aidl::android::aidl::tests::BackendType* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 68 /*getBackendType*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->getBackendType(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpTestService::GetCircular(::aidl::android::aidl::tests::CircularParcelable* out_cp, std::shared_ptr<::aidl::android::aidl::tests::ICircular>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); AParcel_markSensitive(_aidl_in.get()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 69 /*GetCircular*/), _aidl_in.getR(), _aidl_out.getR(), FLAG_CLEAR_BUF #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITestService::getDefaultImpl()) { _aidl_status = ITestService::getDefaultImpl()->GetCircular(out_cp, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_cp); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } // Source for BnTestService BnTestService::BnTestService() {} BnTestService::~BnTestService() {} ::ndk::SpAIBinder BnTestService::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_tests_ITestService_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for ITestService const char* ITestService::descriptor = "android.aidl.tests.ITestService"; ITestService::ITestService() {} ITestService::~ITestService() {} const char* ITestService::STRING_CONSTANT = "foo"; const char* ITestService::STRING_CONSTANT2 = "bar"; const char* ITestService::STRING_CONSTANT_UTF8 = "baz"; std::shared_ptr ITestService::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_tests_ITestService_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t ITestService::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t ITestService::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = ITestService::fromBinder(binder); return STATUS_OK; } bool ITestService::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!ITestService::default_impl); if (impl) { ITestService::default_impl = impl; return true; } return false; } const std::shared_ptr& ITestService::getDefaultImpl() { return ITestService::default_impl; } std::shared_ptr ITestService::default_impl = nullptr; ::ndk::ScopedAStatus ITestServiceDefault::UnimplementedMethod(int32_t /*in_arg*/, int32_t* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::Deprecated() { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::TestOneway() { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatBoolean(bool /*in_token*/, bool* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatByte(int8_t /*in_token*/, int8_t* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatChar(char16_t /*in_token*/, char16_t* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatInt(int32_t /*in_token*/, int32_t* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatLong(int64_t /*in_token*/, int64_t* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatFloat(float /*in_token*/, float* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatDouble(double /*in_token*/, double* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatString(const std::string& /*in_token*/, std::string* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatByteEnum(::aidl::android::aidl::tests::ByteEnum /*in_token*/, ::aidl::android::aidl::tests::ByteEnum* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatIntEnum(::aidl::android::aidl::tests::IntEnum /*in_token*/, ::aidl::android::aidl::tests::IntEnum* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatLongEnum(::aidl::android::aidl::tests::LongEnum /*in_token*/, ::aidl::android::aidl::tests::LongEnum* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseBoolean(const std::vector& /*in_input*/, std::vector* /*out_repeated*/, std::vector* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseByte(const std::vector& /*in_input*/, std::vector* /*out_repeated*/, std::vector* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseChar(const std::vector& /*in_input*/, std::vector* /*out_repeated*/, std::vector* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseInt(const std::vector& /*in_input*/, std::vector* /*out_repeated*/, std::vector* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseLong(const std::vector& /*in_input*/, std::vector* /*out_repeated*/, std::vector* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseFloat(const std::vector& /*in_input*/, std::vector* /*out_repeated*/, std::vector* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseDouble(const std::vector& /*in_input*/, std::vector* /*out_repeated*/, std::vector* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseString(const std::vector& /*in_input*/, std::vector* /*out_repeated*/, std::vector* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseByteEnum(const std::vector<::aidl::android::aidl::tests::ByteEnum>& /*in_input*/, std::vector<::aidl::android::aidl::tests::ByteEnum>* /*out_repeated*/, std::vector<::aidl::android::aidl::tests::ByteEnum>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseIntEnum(const std::vector<::aidl::android::aidl::tests::IntEnum>& /*in_input*/, std::vector<::aidl::android::aidl::tests::IntEnum>* /*out_repeated*/, std::vector<::aidl::android::aidl::tests::IntEnum>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseLongEnum(const std::vector<::aidl::android::aidl::tests::LongEnum>& /*in_input*/, std::vector<::aidl::android::aidl::tests::LongEnum>* /*out_repeated*/, std::vector<::aidl::android::aidl::tests::LongEnum>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::GetOtherTestService(const std::string& /*in_name*/, std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::SetOtherTestService(const std::string& /*in_name*/, const std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>& /*in_service*/, bool* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::VerifyName(const std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>& /*in_service*/, const std::string& /*in_name*/, bool* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::GetInterfaceArray(const std::vector& /*in_names*/, std::vector>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::VerifyNamesWithInterfaceArray(const std::vector>& /*in_services*/, const std::vector& /*in_names*/, bool* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::GetNullableInterfaceArray(const std::optional>>& /*in_names*/, std::optional>>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::VerifyNamesWithNullableInterfaceArray(const std::optional>>& /*in_services*/, const std::optional>>& /*in_names*/, bool* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::GetInterfaceList(const std::optional>>& /*in_names*/, std::optional>>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::VerifyNamesWithInterfaceList(const std::optional>>& /*in_services*/, const std::optional>>& /*in_names*/, bool* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseStringList(const std::vector& /*in_input*/, std::vector* /*out_repeated*/, std::vector* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatParcelFileDescriptor(const ::ndk::ScopedFileDescriptor& /*in_read*/, ::ndk::ScopedFileDescriptor* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseParcelFileDescriptorArray(const std::vector<::ndk::ScopedFileDescriptor>& /*in_input*/, std::vector<::ndk::ScopedFileDescriptor>* /*out_repeated*/, std::vector<::ndk::ScopedFileDescriptor>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ThrowServiceException(int32_t /*in_code*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatNullableIntArray(const std::optional>& /*in_input*/, std::optional>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatNullableByteEnumArray(const std::optional>& /*in_input*/, std::optional>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatNullableIntEnumArray(const std::optional>& /*in_input*/, std::optional>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatNullableLongEnumArray(const std::optional>& /*in_input*/, std::optional>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatNullableString(const std::optional& /*in_input*/, std::optional* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatNullableStringList(const std::optional>>& /*in_input*/, std::optional>>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatNullableParcelable(const std::optional<::aidl::android::aidl::tests::ITestService::Empty>& /*in_input*/, std::optional<::aidl::android::aidl::tests::ITestService::Empty>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatNullableParcelableArray(const std::optional>>& /*in_input*/, std::optional>>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatNullableParcelableList(const std::optional>>& /*in_input*/, std::optional>>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::TakesAnIBinder(const ::ndk::SpAIBinder& /*in_input*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::TakesANullableIBinder(const ::ndk::SpAIBinder& /*in_input*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::TakesAnIBinderList(const std::vector<::ndk::SpAIBinder>& /*in_input*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::TakesANullableIBinderList(const std::optional>& /*in_input*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatUtf8CppString(const std::string& /*in_token*/, std::string* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatNullableUtf8CppString(const std::optional& /*in_token*/, std::optional* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseUtf8CppString(const std::vector& /*in_input*/, std::vector* /*out_repeated*/, std::vector* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseNullableUtf8CppString(const std::optional>>& /*in_input*/, std::optional>>* /*out_repeated*/, std::optional>>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseUtf8CppStringList(const std::optional>>& /*in_input*/, std::optional>>* /*out_repeated*/, std::optional>>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::GetCallback(bool /*in_return_null*/, std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::FillOutStructuredParcelable(::aidl::android::aidl::tests::StructuredParcelable* /*in_parcel*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatExtendableParcelable(const ::aidl::android::aidl::tests::extension::ExtendableParcelable& /*in_ep*/, ::aidl::android::aidl::tests::extension::ExtendableParcelable* /*out_ep2*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseList(const ::aidl::android::aidl::tests::RecursiveList& /*in_list*/, ::aidl::android::aidl::tests::RecursiveList* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseIBinderArray(const std::vector<::ndk::SpAIBinder>& /*in_input*/, std::vector<::ndk::SpAIBinder>* /*out_repeated*/, std::vector<::ndk::SpAIBinder>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseNullableIBinderArray(const std::optional>& /*in_input*/, std::optional>* /*out_repeated*/, std::optional>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::RepeatSimpleParcelable(const ::aidl::android::aidl::tests::SimpleParcelable& /*in_input*/, ::aidl::android::aidl::tests::SimpleParcelable* /*out_repeat*/, ::aidl::android::aidl::tests::SimpleParcelable* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::ReverseSimpleParcelables(const std::vector<::aidl::android::aidl::tests::SimpleParcelable>& /*in_input*/, std::vector<::aidl::android::aidl::tests::SimpleParcelable>* /*out_repeated*/, std::vector<::aidl::android::aidl::tests::SimpleParcelable>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::GetOldNameInterface(std::shared_ptr<::aidl::android::aidl::tests::IOldName>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::GetNewNameInterface(std::shared_ptr<::aidl::android::aidl::tests::INewName>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::GetUnionTags(const std::vector<::aidl::android::aidl::tests::Union>& /*in_input*/, std::vector<::aidl::android::aidl::tests::Union::Tag>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::GetCppJavaTests(::ndk::SpAIBinder* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::getBackendType(::aidl::android::aidl::tests::BackendType* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITestServiceDefault::GetCircular(::aidl::android::aidl::tests::CircularParcelable* /*out_cp*/, std::shared_ptr<::aidl::android::aidl::tests::ICircular>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::SpAIBinder ITestServiceDefault::asBinder() { return ::ndk::SpAIBinder(); } bool ITestServiceDefault::isRemote() { return false; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { const char* ITestService::Empty::descriptor = "android.aidl.tests.ITestService.Empty"; binder_status_t ITestService::Empty::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t ITestService::Empty::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { const char* ITestService::CompilerChecks::descriptor = "android.aidl.tests.ITestService.CompilerChecks"; binder_status_t ITestService::CompilerChecks::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &binder); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &nullable_binder); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &binder_array); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &nullable_binder_array); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &binder_list); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &nullable_binder_list); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &pfd); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &nullable_pfd); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &pfd_array); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &nullable_pfd_array); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &pfd_list); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &nullable_pfd_list); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &parcel); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &nullable_parcel); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &parcel_array); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &nullable_parcel_array); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &parcel_list); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &nullable_parcel_list); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t ITestService::CompilerChecks::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, binder); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, nullable_binder); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, binder_array); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, nullable_binder_array); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, binder_list); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, nullable_binder_list); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, pfd); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, nullable_pfd); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, pfd_array); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, nullable_pfd_array); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, pfd_list); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, nullable_pfd_list); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, parcel); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, nullable_parcel); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, parcel_array); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, nullable_parcel_array); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, parcel_list); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, nullable_parcel_list); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { static binder_status_t _aidl_android_aidl_tests_ITestService_CompilerChecks_Foo_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; (void)_aidl_binder; (void)_aidl_code; return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_tests_ITestService_CompilerChecks_Foo_clazz = ::ndk::ICInterface::defineClass(ITestService::CompilerChecks::IFoo::descriptor, _aidl_android_aidl_tests_ITestService_CompilerChecks_Foo_onTransact); ITestService::CompilerChecks::BpFoo::BpFoo(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} ITestService::CompilerChecks::BpFoo::~BpFoo() {} // Source for BnFoo ITestService::CompilerChecks::BnFoo::BnFoo() {} ITestService::CompilerChecks::BnFoo::~BnFoo() {} ::ndk::SpAIBinder ITestService::CompilerChecks::BnFoo::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_tests_ITestService_CompilerChecks_Foo_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for IFoo const char* ITestService::CompilerChecks::IFoo::descriptor = "android.aidl.tests.ITestService.CompilerChecks.Foo"; ITestService::CompilerChecks::IFoo::IFoo() {} ITestService::CompilerChecks::IFoo::~IFoo() {} std::shared_ptr ITestService::CompilerChecks::IFoo::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_tests_ITestService_CompilerChecks_Foo_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t ITestService::CompilerChecks::IFoo::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t ITestService::CompilerChecks::IFoo::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = IFoo::fromBinder(binder); return STATUS_OK; } bool ITestService::CompilerChecks::IFoo::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!IFoo::default_impl); if (impl) { IFoo::default_impl = impl; return true; } return false; } const std::shared_ptr& ITestService::CompilerChecks::IFoo::getDefaultImpl() { return IFoo::default_impl; } std::shared_ptr ITestService::CompilerChecks::IFoo::default_impl = nullptr; ::ndk::SpAIBinder ITestService::CompilerChecks::IFooDefault::asBinder() { return ::ndk::SpAIBinder(); } bool ITestService::CompilerChecks::IFooDefault::isRemote() { return false; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { const char* ITestService::CompilerChecks::HasDeprecated::descriptor = "android.aidl.tests.ITestService.CompilerChecks.HasDeprecated"; #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" binder_status_t ITestService::CompilerChecks::HasDeprecated::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &deprecated); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t ITestService::CompilerChecks::HasDeprecated::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, deprecated); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } #pragma clang diagnostic pop } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { const char* ITestService::CompilerChecks::UsingHasDeprecated::descriptor = "android.aidl.tests.ITestService.CompilerChecks.UsingHasDeprecated"; binder_status_t ITestService::CompilerChecks::UsingHasDeprecated::readFromParcel(const AParcel* _parcel) { binder_status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_tag)) != STATUS_OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case n: { int32_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case m: { ::aidl::android::aidl::tests::ITestService::CompilerChecks::HasDeprecated _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::aidl::android::aidl::tests::ITestService::CompilerChecks::HasDeprecated>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } } return STATUS_BAD_VALUE; } binder_status_t ITestService::CompilerChecks::UsingHasDeprecated::writeToParcel(AParcel* _parcel) const { binder_status_t _aidl_ret_status = ::ndk::AParcel_writeData(_parcel, static_cast(getTag())); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; switch (getTag()) { case n: return ::ndk::AParcel_writeData(_parcel, get()); case m: return ::ndk::AParcel_writeData(_parcel, get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { static binder_status_t _aidl_android_aidl_tests_ITestService_CompilerChecks_NoPrefixInterface_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*foo*/): { ::ndk::ScopedAStatus _aidl_status = _aidl_impl->foo(); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_tests_ITestService_CompilerChecks_NoPrefixInterface_clazz = ::ndk::ICInterface::defineClass(ITestService::CompilerChecks::INoPrefixInterface::descriptor, _aidl_android_aidl_tests_ITestService_CompilerChecks_NoPrefixInterface_onTransact); ITestService::CompilerChecks::BpNoPrefixInterface::BpNoPrefixInterface(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} ITestService::CompilerChecks::BpNoPrefixInterface::~BpNoPrefixInterface() {} ::ndk::ScopedAStatus ITestService::CompilerChecks::BpNoPrefixInterface::foo() { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*foo*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && INoPrefixInterface::getDefaultImpl()) { _aidl_status = INoPrefixInterface::getDefaultImpl()->foo(); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } // Source for BnNoPrefixInterface ITestService::CompilerChecks::BnNoPrefixInterface::BnNoPrefixInterface() {} ITestService::CompilerChecks::BnNoPrefixInterface::~BnNoPrefixInterface() {} ::ndk::SpAIBinder ITestService::CompilerChecks::BnNoPrefixInterface::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_tests_ITestService_CompilerChecks_NoPrefixInterface_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for INoPrefixInterface const char* ITestService::CompilerChecks::INoPrefixInterface::descriptor = "android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface"; ITestService::CompilerChecks::INoPrefixInterface::INoPrefixInterface() {} ITestService::CompilerChecks::INoPrefixInterface::~INoPrefixInterface() {} std::shared_ptr ITestService::CompilerChecks::INoPrefixInterface::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_tests_ITestService_CompilerChecks_NoPrefixInterface_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t ITestService::CompilerChecks::INoPrefixInterface::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t ITestService::CompilerChecks::INoPrefixInterface::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = INoPrefixInterface::fromBinder(binder); return STATUS_OK; } bool ITestService::CompilerChecks::INoPrefixInterface::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!INoPrefixInterface::default_impl); if (impl) { INoPrefixInterface::default_impl = impl; return true; } return false; } const std::shared_ptr& ITestService::CompilerChecks::INoPrefixInterface::getDefaultImpl() { return INoPrefixInterface::default_impl; } std::shared_ptr ITestService::CompilerChecks::INoPrefixInterface::default_impl = nullptr; ::ndk::ScopedAStatus ITestService::CompilerChecks::INoPrefixInterfaceDefault::foo() { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::SpAIBinder ITestService::CompilerChecks::INoPrefixInterfaceDefault::asBinder() { return ::ndk::SpAIBinder(); } bool ITestService::CompilerChecks::INoPrefixInterfaceDefault::isRemote() { return false; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { const char* ITestService::CompilerChecks::INoPrefixInterface::Nested::descriptor = "android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.Nested"; binder_status_t ITestService::CompilerChecks::INoPrefixInterface::Nested::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t ITestService::CompilerChecks::INoPrefixInterface::Nested::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { static binder_status_t _aidl_android_aidl_tests_ITestService_CompilerChecks_NoPrefixInterface_NestedNoPrefixInterface_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*foo*/): { ::ndk::ScopedAStatus _aidl_status = _aidl_impl->foo(); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_tests_ITestService_CompilerChecks_NoPrefixInterface_NestedNoPrefixInterface_clazz = ::ndk::ICInterface::defineClass(ITestService::CompilerChecks::INoPrefixInterface::INestedNoPrefixInterface::descriptor, _aidl_android_aidl_tests_ITestService_CompilerChecks_NoPrefixInterface_NestedNoPrefixInterface_onTransact); ITestService::CompilerChecks::INoPrefixInterface::BpNestedNoPrefixInterface::BpNestedNoPrefixInterface(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} ITestService::CompilerChecks::INoPrefixInterface::BpNestedNoPrefixInterface::~BpNestedNoPrefixInterface() {} ::ndk::ScopedAStatus ITestService::CompilerChecks::INoPrefixInterface::BpNestedNoPrefixInterface::foo() { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*foo*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && INestedNoPrefixInterface::getDefaultImpl()) { _aidl_status = INestedNoPrefixInterface::getDefaultImpl()->foo(); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } // Source for BnNestedNoPrefixInterface ITestService::CompilerChecks::INoPrefixInterface::BnNestedNoPrefixInterface::BnNestedNoPrefixInterface() {} ITestService::CompilerChecks::INoPrefixInterface::BnNestedNoPrefixInterface::~BnNestedNoPrefixInterface() {} ::ndk::SpAIBinder ITestService::CompilerChecks::INoPrefixInterface::BnNestedNoPrefixInterface::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_tests_ITestService_CompilerChecks_NoPrefixInterface_NestedNoPrefixInterface_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for INestedNoPrefixInterface const char* ITestService::CompilerChecks::INoPrefixInterface::INestedNoPrefixInterface::descriptor = "android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.NestedNoPrefixInterface"; ITestService::CompilerChecks::INoPrefixInterface::INestedNoPrefixInterface::INestedNoPrefixInterface() {} ITestService::CompilerChecks::INoPrefixInterface::INestedNoPrefixInterface::~INestedNoPrefixInterface() {} std::shared_ptr ITestService::CompilerChecks::INoPrefixInterface::INestedNoPrefixInterface::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_tests_ITestService_CompilerChecks_NoPrefixInterface_NestedNoPrefixInterface_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t ITestService::CompilerChecks::INoPrefixInterface::INestedNoPrefixInterface::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t ITestService::CompilerChecks::INoPrefixInterface::INestedNoPrefixInterface::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = INestedNoPrefixInterface::fromBinder(binder); return STATUS_OK; } bool ITestService::CompilerChecks::INoPrefixInterface::INestedNoPrefixInterface::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!INestedNoPrefixInterface::default_impl); if (impl) { INestedNoPrefixInterface::default_impl = impl; return true; } return false; } const std::shared_ptr& ITestService::CompilerChecks::INoPrefixInterface::INestedNoPrefixInterface::getDefaultImpl() { return INestedNoPrefixInterface::default_impl; } std::shared_ptr ITestService::CompilerChecks::INoPrefixInterface::INestedNoPrefixInterface::default_impl = nullptr; ::ndk::ScopedAStatus ITestService::CompilerChecks::INoPrefixInterface::INestedNoPrefixInterfaceDefault::foo() { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::SpAIBinder ITestService::CompilerChecks::INoPrefixInterface::INestedNoPrefixInterfaceDefault::asBinder() { return ::ndk::SpAIBinder(); } bool ITestService::CompilerChecks::INoPrefixInterface::INestedNoPrefixInterfaceDefault::isRemote() { return false; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_ITe0100644 0000000 0000000 00000000034 15172120304 033175 xustar000000000 0000000 28 mtime=1776853188.6370000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/ITestService.cpp.d0100644 0000000 0000000 00000002225 15172120304 032575 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/ITestService.cpp : \ system/tools/aidl/tests/android/aidl/tests/ITestService.aidl \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ICircular.aidl \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl \ system/tools/aidl/tests/android/aidl/tests/SimpleParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Int0100644 0000000 0000000 00000000034 15172120304 033246 xustar000000000 0000000 28 mtime=1776853188.6370000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/IntEnum.cpp0100644 0000000 0000000 00000001226 15172120304 031361 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/IntEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl */ // This file is intentionally left blank as placeholder for enum declaration. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Int0100644 0000000 0000000 00000000034 15172120304 033246 xustar000000000 0000000 28 mtime=1776853188.6370000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/IntEnum.cpp.d0100644 0000000 0000000 00000000253 15172120304 031602 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/IntEnum.cpp : \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Lis0100644 0000000 0000000 00000000213 15172120304 033242 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/ListOfInterfaces.cpp 28 mtime=1776853188.6380000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/ListOfInterfaces.cp0100644 0000000 0000000 00000062470 15172120304 033036 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ListOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ListOfInterfaces.aidl */ #include "aidl/android/aidl/tests/ListOfInterfaces.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { const char* ListOfInterfaces::descriptor = "android.aidl.tests.ListOfInterfaces"; binder_status_t ListOfInterfaces::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t ListOfInterfaces::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { static binder_status_t _aidl_android_aidl_tests_ListOfInterfaces_IEmptyInterface_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; (void)_aidl_binder; (void)_aidl_code; return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_tests_ListOfInterfaces_IEmptyInterface_clazz = ::ndk::ICInterface::defineClass(ListOfInterfaces::IEmptyInterface::descriptor, _aidl_android_aidl_tests_ListOfInterfaces_IEmptyInterface_onTransact); ListOfInterfaces::BpEmptyInterface::BpEmptyInterface(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} ListOfInterfaces::BpEmptyInterface::~BpEmptyInterface() {} // Source for BnEmptyInterface ListOfInterfaces::BnEmptyInterface::BnEmptyInterface() {} ListOfInterfaces::BnEmptyInterface::~BnEmptyInterface() {} ::ndk::SpAIBinder ListOfInterfaces::BnEmptyInterface::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_tests_ListOfInterfaces_IEmptyInterface_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for IEmptyInterface const char* ListOfInterfaces::IEmptyInterface::descriptor = "android.aidl.tests.ListOfInterfaces.IEmptyInterface"; ListOfInterfaces::IEmptyInterface::IEmptyInterface() {} ListOfInterfaces::IEmptyInterface::~IEmptyInterface() {} std::shared_ptr ListOfInterfaces::IEmptyInterface::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_tests_ListOfInterfaces_IEmptyInterface_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t ListOfInterfaces::IEmptyInterface::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t ListOfInterfaces::IEmptyInterface::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = IEmptyInterface::fromBinder(binder); return STATUS_OK; } bool ListOfInterfaces::IEmptyInterface::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!IEmptyInterface::default_impl); if (impl) { IEmptyInterface::default_impl = impl; return true; } return false; } const std::shared_ptr& ListOfInterfaces::IEmptyInterface::getDefaultImpl() { return IEmptyInterface::default_impl; } std::shared_ptr ListOfInterfaces::IEmptyInterface::default_impl = nullptr; ::ndk::SpAIBinder ListOfInterfaces::IEmptyInterfaceDefault::asBinder() { return ::ndk::SpAIBinder(); } bool ListOfInterfaces::IEmptyInterfaceDefault::isRemote() { return false; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { static binder_status_t _aidl_android_aidl_tests_ListOfInterfaces_IMyInterface_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*methodWithInterfaces*/): { std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface> in_iface; std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface> in_nullable_iface; std::vector> in_iface_list_in; std::vector> out_iface_list_out; std::vector> in_iface_list_inout; std::optional>> in_nullable_iface_list_in; std::optional>> out_nullable_iface_list_out; std::optional>> in_nullable_iface_list_inout; std::optional>> _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_iface); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_nullable_iface); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_iface_list_in); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_iface_list_inout); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_nullable_iface_list_in); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_nullable_iface_list_inout); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->methodWithInterfaces(in_iface, in_nullable_iface, in_iface_list_in, &out_iface_list_out, &in_iface_list_inout, in_nullable_iface_list_in, &out_nullable_iface_list_out, &in_nullable_iface_list_inout, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_iface_list_out); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, in_iface_list_inout); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, out_nullable_iface_list_out); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, in_nullable_iface_list_inout); if (_aidl_ret_status != STATUS_OK) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_tests_ListOfInterfaces_IMyInterface_clazz = ::ndk::ICInterface::defineClass(ListOfInterfaces::IMyInterface::descriptor, _aidl_android_aidl_tests_ListOfInterfaces_IMyInterface_onTransact); ListOfInterfaces::BpMyInterface::BpMyInterface(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} ListOfInterfaces::BpMyInterface::~BpMyInterface() {} ::ndk::ScopedAStatus ListOfInterfaces::BpMyInterface::methodWithInterfaces(const std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& in_iface, const std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& in_nullable_iface, const std::vector>& in_iface_list_in, std::vector>* out_iface_list_out, std::vector>* in_iface_list_inout, const std::optional>>& in_nullable_iface_list_in, std::optional>>* out_nullable_iface_list_out, std::optional>>* in_nullable_iface_list_inout, std::optional>>* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_iface); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_nullable_iface); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_iface_list_in); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), *in_iface_list_inout); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_nullable_iface_list_in); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), *in_nullable_iface_list_inout); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*methodWithInterfaces*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IMyInterface::getDefaultImpl()) { _aidl_status = IMyInterface::getDefaultImpl()->methodWithInterfaces(in_iface, in_nullable_iface, in_iface_list_in, out_iface_list_out, in_iface_list_inout, in_nullable_iface_list_in, out_nullable_iface_list_out, in_nullable_iface_list_inout, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_iface_list_out); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), in_iface_list_inout); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), out_nullable_iface_list_out); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), in_nullable_iface_list_inout); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } // Source for BnMyInterface ListOfInterfaces::BnMyInterface::BnMyInterface() {} ListOfInterfaces::BnMyInterface::~BnMyInterface() {} ::ndk::SpAIBinder ListOfInterfaces::BnMyInterface::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_tests_ListOfInterfaces_IMyInterface_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for IMyInterface const char* ListOfInterfaces::IMyInterface::descriptor = "android.aidl.tests.ListOfInterfaces.IMyInterface"; ListOfInterfaces::IMyInterface::IMyInterface() {} ListOfInterfaces::IMyInterface::~IMyInterface() {} std::shared_ptr ListOfInterfaces::IMyInterface::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_tests_ListOfInterfaces_IMyInterface_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t ListOfInterfaces::IMyInterface::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t ListOfInterfaces::IMyInterface::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = IMyInterface::fromBinder(binder); return STATUS_OK; } bool ListOfInterfaces::IMyInterface::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!IMyInterface::default_impl); if (impl) { IMyInterface::default_impl = impl; return true; } return false; } const std::shared_ptr& ListOfInterfaces::IMyInterface::getDefaultImpl() { return IMyInterface::default_impl; } std::shared_ptr ListOfInterfaces::IMyInterface::default_impl = nullptr; ::ndk::ScopedAStatus ListOfInterfaces::IMyInterfaceDefault::methodWithInterfaces(const std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& /*in_iface*/, const std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& /*in_nullable_iface*/, const std::vector>& /*in_iface_list_in*/, std::vector>* /*out_iface_list_out*/, std::vector>* /*in_iface_list_inout*/, const std::optional>>& /*in_nullable_iface_list_in*/, std::optional>>* /*out_nullable_iface_list_out*/, std::optional>>* /*in_nullable_iface_list_inout*/, std::optional>>* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::SpAIBinder ListOfInterfaces::IMyInterfaceDefault::asBinder() { return ::ndk::SpAIBinder(); } bool ListOfInterfaces::IMyInterfaceDefault::isRemote() { return false; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { const char* ListOfInterfaces::MyParcelable::descriptor = "android.aidl.tests.ListOfInterfaces.MyParcelable"; binder_status_t ListOfInterfaces::MyParcelable::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &iface); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &nullable_iface); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &iface_list); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &nullable_iface_list); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t ListOfInterfaces::MyParcelable::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, iface); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, nullable_iface); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, iface_list); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, nullable_iface_list); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { const char* ListOfInterfaces::MyUnion::descriptor = "android.aidl.tests.ListOfInterfaces.MyUnion"; binder_status_t ListOfInterfaces::MyUnion::readFromParcel(const AParcel* _parcel) { binder_status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_tag)) != STATUS_OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case iface: { std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface> _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case nullable_iface: { std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface> _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readNullableData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case iface_list: { std::vector> _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v>>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case nullable_iface_list: { std::optional>> _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readNullableData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v>>>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } } return STATUS_BAD_VALUE; } binder_status_t ListOfInterfaces::MyUnion::writeToParcel(AParcel* _parcel) const { binder_status_t _aidl_ret_status = ::ndk::AParcel_writeData(_parcel, static_cast(getTag())); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; switch (getTag()) { case iface: return ::ndk::AParcel_writeData(_parcel, get()); case nullable_iface: return ::ndk::AParcel_writeNullableData(_parcel, get()); case iface_list: return ::ndk::AParcel_writeData(_parcel, get()); case nullable_iface_list: return ::ndk::AParcel_writeNullableData(_parcel, get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Lis0100644 0000000 0000000 00000000215 15172120304 033244 xustar000000000 0000000 113 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/ListOfInterfaces.cpp.d 28 mtime=1776853188.6380000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/ListOfInterfaces.cp0100644 0000000 0000000 00000000275 15172120304 033031 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/ListOfInterfaces.cpp : \ system/tools/aidl/tests/android/aidl/tests/ListOfInterfaces.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Lon0100644 0000000 0000000 00000000034 15172120304 033244 xustar000000000 0000000 28 mtime=1776853188.6380000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/LongEnum.cpp0100644 0000000 0000000 00000001230 15172120304 031521 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/LongEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl */ // This file is intentionally left blank as placeholder for enum declaration. ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Lon0100644 0000000 0000000 00000000034 15172120304 033244 xustar000000000 0000000 28 mtime=1776853188.6380000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/LongEnum.cpp.d0100644 0000000 0000000 00000000255 15172120304 031751 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/LongEnum.cpp : \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Oth0100644 0000000 0000000 00000000225 15172120304 033250 xustar000000000 0000000 121 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/OtherParcelableForToString.cpp 28 mtime=1776853188.6380000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/OtherParcelableForT0100644 0000000 0000000 00000005176 15172120304 033060 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/OtherParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl */ #include "aidl/android/aidl/tests/OtherParcelableForToString.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { const char* OtherParcelableForToString::descriptor = "android.aidl.tests.OtherParcelableForToString"; binder_status_t OtherParcelableForToString::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &field); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t OtherParcelableForToString::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, field); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Oth0100644 0000000 0000000 00000000227 15172120304 033252 xustar000000000 0000000 123 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/OtherParcelableForToString.cpp.d 28 mtime=1776853188.6380000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/OtherParcelableForT0100644 0000000 0000000 00000000321 15172120304 033043 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/OtherParcelableForToString.cpp : \ system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Par0100644 0000000 0000000 00000000220 15172120304 033233 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/ParcelableForToString.cpp 28 mtime=1776853188.6380000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/ParcelableForToStri0100644 0000000 0000000 00000031647 15172120304 033101 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ParcelableForToString.aidl */ #include "aidl/android/aidl/tests/ParcelableForToString.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { const char* ParcelableForToString::descriptor = "android.aidl.tests.ParcelableForToString"; binder_status_t ParcelableForToString::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &intValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &intArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &longValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &longArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &doubleValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &doubleArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &floatValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &floatArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &byteValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &byteArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &booleanValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &booleanArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &stringValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &stringArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &stringList); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &parcelableValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &parcelableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &enumValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &enumArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &nullArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &nullList); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &parcelableGeneric); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &unionValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t ParcelableForToString::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, intValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, intArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, longValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, longArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, doubleValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, doubleArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, floatValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, floatArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, byteValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, byteArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, booleanValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, booleanArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, stringValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, stringArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, stringList); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, parcelableValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, parcelableArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, enumValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, enumArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, nullArray); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, nullList); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, parcelableGeneric); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, unionValue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Par0100644 0000000 0000000 00000000222 15172120304 033235 xustar000000000 0000000 118 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/ParcelableForToString.cpp.d 28 mtime=1776853188.6380000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/ParcelableForToStri0100644 0000000 0000000 00000001352 15172120304 033067 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/ParcelableForToString.cpp : \ system/tools/aidl/tests/android/aidl/tests/ParcelableForToString.aidl \ system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Rec0100644 0000000 0000000 00000000034 15172120304 033225 xustar000000000 0000000 28 mtime=1776853188.6390000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/RecursiveList.cpp0100644 0000000 0000000 00000006006 15172120304 032606 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/RecursiveList.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl */ #include "aidl/android/aidl/tests/RecursiveList.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { const char* RecursiveList::descriptor = "android.aidl.tests.RecursiveList"; binder_status_t RecursiveList::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &value); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &next); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t RecursiveList::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, value); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, next); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Rec0100644 0000000 0000000 00000000212 15172120304 033223 xustar000000000 0000000 110 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/RecursiveList.cpp.d 28 mtime=1776853188.6390000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/RecursiveList.cpp.d0100644 0000000 0000000 00000000267 15172120304 033033 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/RecursiveList.cpp : \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Str0100644 0000000 0000000 00000000217 15172120304 033267 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/StructuredParcelable.cpp 28 mtime=1776853188.6390000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/StructuredParcelabl0100644 0000000 0000000 00000073423 15172120304 033203 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/StructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl */ #include "aidl/android/aidl/tests/StructuredParcelable.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { const char* StructuredParcelable::descriptor = "android.aidl.tests.StructuredParcelable"; binder_status_t StructuredParcelable::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &shouldContainThreeFs); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &f); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &shouldBeJerry); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &shouldBeByteBar); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &shouldBeIntBar); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &shouldBeLongBar); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &shouldContainTwoByteFoos); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &shouldContainTwoIntFoos); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &shouldContainTwoLongFoos); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &stringDefaultsToFoo); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &byteDefaultsToFour); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &intDefaultsToFive); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &longDefaultsToNegativeSeven); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &booleanDefaultsToTrue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &charDefaultsToC); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &floatDefaultsToPi); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &doubleWithDefault); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &arrayDefaultsTo123); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &arrayDefaultsToEmpty); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &boolDefault); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &byteDefault); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &intDefault); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &longDefault); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &floatDefault); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &doubleDefault); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &checkDoubleFromFloat); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &checkStringArray1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &checkStringArray2); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &int32_min); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &int32_max); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &int64_max); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &hexInt32_neg_1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &ibinder); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &empty); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &int8_1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &int32_1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &int64_1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &hexInt32_pos_1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &hexInt64_pos_1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &const_exprs_1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &const_exprs_2); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &const_exprs_3); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &const_exprs_4); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &const_exprs_5); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &const_exprs_6); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &const_exprs_7); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &const_exprs_8); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &const_exprs_9); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &const_exprs_10); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &addString1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &addString2); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &shouldSetBit0AndBit2); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &u); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_parcel, &shouldBeConstS1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &defaultWithFoo); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t StructuredParcelable::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, shouldContainThreeFs); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, f); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, shouldBeJerry); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, shouldBeByteBar); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, shouldBeIntBar); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, shouldBeLongBar); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, shouldContainTwoByteFoos); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, shouldContainTwoIntFoos); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, shouldContainTwoLongFoos); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, stringDefaultsToFoo); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, byteDefaultsToFour); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, intDefaultsToFive); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, longDefaultsToNegativeSeven); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, booleanDefaultsToTrue); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, charDefaultsToC); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, floatDefaultsToPi); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, doubleWithDefault); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, arrayDefaultsTo123); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, arrayDefaultsToEmpty); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, boolDefault); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, byteDefault); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, intDefault); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, longDefault); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, floatDefault); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, doubleDefault); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, checkDoubleFromFloat); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, checkStringArray1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, checkStringArray2); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, int32_min); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, int32_max); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, int64_max); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, hexInt32_neg_1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, ibinder); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, empty); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, int8_1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, int32_1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, int64_1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, hexInt32_pos_1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, hexInt64_pos_1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, const_exprs_1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, const_exprs_2); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, const_exprs_3); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, const_exprs_4); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, const_exprs_5); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, const_exprs_6); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, const_exprs_7); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, const_exprs_8); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, const_exprs_9); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, const_exprs_10); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, addString1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, addString2); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, shouldSetBit0AndBit2); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, u); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_parcel, shouldBeConstS1); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, defaultWithFoo); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { const char* StructuredParcelable::Empty::descriptor = "android.aidl.tests.StructuredParcelable.Empty"; binder_status_t StructuredParcelable::Empty::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t StructuredParcelable::Empty::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Str0100644 0000000 0000000 00000000221 15172120304 033262 xustar000000000 0000000 117 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/StructuredParcelable.cpp.d 28 mtime=1776853188.6390000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/StructuredParcelabl0100644 0000000 0000000 00000001000 15172120304 033161 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/StructuredParcelable.cpp : \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Uni0100644 0000000 0000000 00000000034 15172120304 033247 xustar000000000 0000000 28 mtime=1776853188.6390000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/Union.cpp0100644 0000000 0000000 00000011325 15172120304 031073 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/Union.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/Union.aidl */ #include "aidl/android/aidl/tests/Union.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { const char* Union::descriptor = "android.aidl.tests.Union"; const char* Union::S1 = "a string constant in union"; binder_status_t Union::readFromParcel(const AParcel* _parcel) { binder_status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_tag)) != STATUS_OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case ns: { std::vector _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case n: { int32_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case m: { int32_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case s: { std::string _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case ibinder: { ::ndk::SpAIBinder _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readNullableData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::ndk::SpAIBinder>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case ss: { std::vector _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case be: { ::aidl::android::aidl::tests::ByteEnum _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::aidl::android::aidl::tests::ByteEnum>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } } return STATUS_BAD_VALUE; } binder_status_t Union::writeToParcel(AParcel* _parcel) const { binder_status_t _aidl_ret_status = ::ndk::AParcel_writeData(_parcel, static_cast(getTag())); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; switch (getTag()) { case ns: return ::ndk::AParcel_writeData(_parcel, get()); case n: return ::ndk::AParcel_writeData(_parcel, get()); case m: return ::ndk::AParcel_writeData(_parcel, get()); case s: return ::ndk::AParcel_writeData(_parcel, get()); case ibinder: return ::ndk::AParcel_writeNullableData(_parcel, get()); case ss: return ::ndk::AParcel_writeData(_parcel, get()); case be: return ::ndk::AParcel_writeData(_parcel, get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Uni0100644 0000000 0000000 00000000034 15172120304 033247 xustar000000000 0000000 28 mtime=1776853188.6390000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/Union.cpp.d0100644 0000000 0000000 00000000344 15172120304 031314 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/Union.cpp : \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Uni0100644 0000000 0000000 00000000034 15172120304 033247 xustar000000000 0000000 28 mtime=1776853188.6390000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/UnionWithFd.cpp0100644 0000000 0000000 00000004675 15172120304 032213 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/UnionWithFd.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/UnionWithFd.aidl */ #include "aidl/android/aidl/tests/UnionWithFd.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { const char* UnionWithFd::descriptor = "android.aidl.tests.UnionWithFd"; binder_status_t UnionWithFd::readFromParcel(const AParcel* _parcel) { binder_status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_tag)) != STATUS_OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case num: { int32_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case pfd: { ::ndk::ScopedFileDescriptor _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::ndk::ScopedFileDescriptor>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } } return STATUS_BAD_VALUE; } binder_status_t UnionWithFd::writeToParcel(AParcel* _parcel) const { binder_status_t _aidl_ret_status = ::ndk::AParcel_writeData(_parcel, static_cast(getTag())); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; switch (getTag()) { case num: return ::ndk::AParcel_writeData(_parcel, get()); case pfd: return ::ndk::AParcel_writeData(_parcel, get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_Uni0100644 0000000 0000000 00000000034 15172120304 033247 xustar000000000 0000000 28 mtime=1776853188.6390000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/UnionWithFd.cpp.d0100644 0000000 0000000 00000000263 15172120304 032422 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/UnionWithFd.cpp : \ system/tools/aidl/tests/android/aidl/tests/UnionWithFd.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_ext0100644 0000000 0000000 00000000034 15172120304 033314 xustar000000000 0000000 28 mtime=1776853188.6390000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/0040755 0000000 0000000 00000000000 15172120304 031314 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_ext0100644 0000000 0000000 00000000231 15172120304 033313 xustar000000000 0000000 125 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/ExtendableParcelable.cpp 28 mtime=1776853188.6400000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/Extendabl0100644 0000000 0000000 00000010742 15172120304 033146 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/extension/ExtendableParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl */ #include "aidl/android/aidl/tests/extension/ExtendableParcelable.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { namespace extension { const char* ExtendableParcelable::descriptor = "android.aidl.tests.extension.ExtendableParcelable"; binder_status_t ExtendableParcelable::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &a); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &b); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &ext); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &c); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &ext2); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t ExtendableParcelable::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, a); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, b); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, ext); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, c); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, ext2); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace extension } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_ext0100644 0000000 0000000 00000000233 15172120304 033315 xustar000000000 0000000 127 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/ExtendableParcelable.cpp.d 28 mtime=1776853188.6400000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/Extendabl0100644 0000000 0000000 00000000331 15172120304 033137 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/ExtendableParcelable.cpp : \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_ext0100644 0000000 0000000 00000000212 15172120304 033312 xustar000000000 0000000 110 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/MyExt.cpp 28 mtime=1776853188.6400000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/MyExt.cpp0100644 0000000 0000000 00000006010 15172120304 033060 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/extension/MyExt.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl */ #include "aidl/android/aidl/tests/extension/MyExt.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { namespace extension { const char* MyExt::descriptor = "android.aidl.tests.extension.MyExt"; binder_status_t MyExt::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &a); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &b); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t MyExt::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, a); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, b); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace extension } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_ext0100644 0000000 0000000 00000000214 15172120304 033314 xustar000000000 0000000 112 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/MyExt.cpp.d 28 mtime=1776853188.6400000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/MyExt.cpp0100644 0000000 0000000 00000000273 15172120304 033065 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/MyExt.cpp : \ system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_ext0100644 0000000 0000000 00000000213 15172120304 033313 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/MyExt2.cpp 28 mtime=1776853188.6400000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/MyExt2.cp0100644 0000000 0000000 00000006734 15172120304 032777 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/extension/MyExt2.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt2.aidl */ #include "aidl/android/aidl/tests/extension/MyExt2.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { namespace extension { const char* MyExt2::descriptor = "android.aidl.tests.extension.MyExt2"; binder_status_t MyExt2::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &a); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &b); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &c); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t MyExt2::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, a); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, b); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, c); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace extension } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_ext0100644 0000000 0000000 00000000215 15172120304 033315 xustar000000000 0000000 113 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/MyExt2.cpp.d 28 mtime=1776853188.6400000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/MyExt2.cp0100644 0000000 0000000 00000000401 15172120304 032760 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/MyExt2.cpp : \ system/tools/aidl/tests/android/aidl/tests/extension/MyExt2.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_ext0100644 0000000 0000000 00000000216 15172120304 033316 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/MyExtLike.cpp 28 mtime=1776853188.6400000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/MyExtLike0100644 0000000 0000000 00000006044 15172120304 033113 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/extension/MyExtLike.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExtLike.aidl */ #include "aidl/android/aidl/tests/extension/MyExtLike.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { namespace extension { const char* MyExtLike::descriptor = "android.aidl.tests.extension.MyExtLike"; binder_status_t MyExtLike::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &a); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &b); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t MyExtLike::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, a); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, b); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace extension } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_ext0100644 0000000 0000000 00000000220 15172120304 033311 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/MyExtLike.cpp.d 28 mtime=1776853188.6400000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/MyExtLike0100644 0000000 0000000 00000000303 15172120304 033103 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/extension/MyExtLike.cpp : \ system/tools/aidl/tests/android/aidl/tests/extension/MyExtLike.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_nes0100644 0000000 0000000 00000000034 15172120304 033301 xustar000000000 0000000 28 mtime=1776853188.6400000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/nested/0040755 0000000 0000000 00000000000 15172120304 030562 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_nes0100644 0000000 0000000 00000000216 15172120304 033303 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/nested/DeeplyNested.cpp 28 mtime=1776853188.6400000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/nested/DeeplyNested0100644 0000000 0000000 00000020713 15172120304 033072 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/nested/DeeplyNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/DeeplyNested.aidl */ #include "aidl/android/aidl/tests/nested/DeeplyNested.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { namespace nested { const char* DeeplyNested::descriptor = "android.aidl.tests.nested.DeeplyNested"; binder_status_t DeeplyNested::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t DeeplyNested::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { namespace nested { const char* DeeplyNested::A::descriptor = "android.aidl.tests.nested.DeeplyNested.A"; binder_status_t DeeplyNested::A::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &e); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t DeeplyNested::A::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, e); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { namespace nested { const char* DeeplyNested::B::descriptor = "android.aidl.tests.nested.DeeplyNested.B"; binder_status_t DeeplyNested::B::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t DeeplyNested::B::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { namespace nested { const char* DeeplyNested::B::C::descriptor = "android.aidl.tests.nested.DeeplyNested.B.C"; binder_status_t DeeplyNested::B::C::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t DeeplyNested::B::C::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { namespace nested { const char* DeeplyNested::B::C::D::descriptor = "android.aidl.tests.nested.DeeplyNested.B.C.D"; binder_status_t DeeplyNested::B::C::D::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t DeeplyNested::B::C::D::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_nes0100644 0000000 0000000 00000000220 15172120304 033276 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/nested/DeeplyNested.cpp.d 28 mtime=1776853188.6400000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/nested/DeeplyNested0100644 0000000 0000000 00000000303 15172120304 033063 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/nested/DeeplyNested.cpp : \ system/tools/aidl/tests/android/aidl/tests/nested/DeeplyNested.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_nes0100644 0000000 0000000 00000000220 15172120304 033276 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/nested/INestedService.cpp 28 mtime=1776853188.6400000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/nested/INestedServi0100644 0000000 0000000 00000043413 15172120304 033053 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/nested/INestedService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/INestedService.aidl */ #include "aidl/android/aidl/tests/nested/INestedService.h" #include #include #include namespace aidl { namespace android { namespace aidl { namespace tests { namespace nested { static binder_status_t _aidl_android_aidl_tests_nested_INestedService_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*flipStatus*/): { ::aidl::android::aidl::tests::nested::ParcelableWithNested in_p; ::aidl::android::aidl::tests::nested::INestedService::Result _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_p); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->flipStatus(in_p, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 1 /*flipStatusWithCallback*/): { ::aidl::android::aidl::tests::nested::ParcelableWithNested::Status in_status; std::shared_ptr<::aidl::android::aidl::tests::nested::INestedService::ICallback> in_cb; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_status); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_cb); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->flipStatusWithCallback(in_status, in_cb); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_tests_nested_INestedService_clazz = ::ndk::ICInterface::defineClass(INestedService::descriptor, _aidl_android_aidl_tests_nested_INestedService_onTransact); BpNestedService::BpNestedService(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} BpNestedService::~BpNestedService() {} ::ndk::ScopedAStatus BpNestedService::flipStatus(const ::aidl::android::aidl::tests::nested::ParcelableWithNested& in_p, ::aidl::android::aidl::tests::nested::INestedService::Result* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_p); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*flipStatus*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && INestedService::getDefaultImpl()) { _aidl_status = INestedService::getDefaultImpl()->flipStatus(in_p, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpNestedService::flipStatusWithCallback(::aidl::android::aidl::tests::nested::ParcelableWithNested::Status in_status, const std::shared_ptr<::aidl::android::aidl::tests::nested::INestedService::ICallback>& in_cb) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_status); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_cb); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 1 /*flipStatusWithCallback*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && INestedService::getDefaultImpl()) { _aidl_status = INestedService::getDefaultImpl()->flipStatusWithCallback(in_status, in_cb); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } // Source for BnNestedService BnNestedService::BnNestedService() {} BnNestedService::~BnNestedService() {} ::ndk::SpAIBinder BnNestedService::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_tests_nested_INestedService_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for INestedService const char* INestedService::descriptor = "android.aidl.tests.nested.INestedService"; INestedService::INestedService() {} INestedService::~INestedService() {} std::shared_ptr INestedService::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_tests_nested_INestedService_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t INestedService::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t INestedService::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = INestedService::fromBinder(binder); return STATUS_OK; } bool INestedService::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!INestedService::default_impl); if (impl) { INestedService::default_impl = impl; return true; } return false; } const std::shared_ptr& INestedService::getDefaultImpl() { return INestedService::default_impl; } std::shared_ptr INestedService::default_impl = nullptr; ::ndk::ScopedAStatus INestedServiceDefault::flipStatus(const ::aidl::android::aidl::tests::nested::ParcelableWithNested& /*in_p*/, ::aidl::android::aidl::tests::nested::INestedService::Result* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus INestedServiceDefault::flipStatusWithCallback(::aidl::android::aidl::tests::nested::ParcelableWithNested::Status /*in_status*/, const std::shared_ptr<::aidl::android::aidl::tests::nested::INestedService::ICallback>& /*in_cb*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::SpAIBinder INestedServiceDefault::asBinder() { return ::ndk::SpAIBinder(); } bool INestedServiceDefault::isRemote() { return false; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { namespace nested { const char* INestedService::Result::descriptor = "android.aidl.tests.nested.INestedService.Result"; binder_status_t INestedService::Result::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &status); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t INestedService::Result::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, status); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { namespace nested { static binder_status_t _aidl_android_aidl_tests_nested_INestedService_ICallback_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*done*/): { ::aidl::android::aidl::tests::nested::ParcelableWithNested::Status in_status; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_status); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->done(in_status); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_tests_nested_INestedService_ICallback_clazz = ::ndk::ICInterface::defineClass(INestedService::ICallback::descriptor, _aidl_android_aidl_tests_nested_INestedService_ICallback_onTransact); INestedService::BpCallback::BpCallback(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} INestedService::BpCallback::~BpCallback() {} ::ndk::ScopedAStatus INestedService::BpCallback::done(::aidl::android::aidl::tests::nested::ParcelableWithNested::Status in_status) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_status); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*done*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ICallback::getDefaultImpl()) { _aidl_status = ICallback::getDefaultImpl()->done(in_status); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } // Source for BnCallback INestedService::BnCallback::BnCallback() {} INestedService::BnCallback::~BnCallback() {} ::ndk::SpAIBinder INestedService::BnCallback::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_tests_nested_INestedService_ICallback_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for ICallback const char* INestedService::ICallback::descriptor = "android.aidl.tests.nested.INestedService.ICallback"; INestedService::ICallback::ICallback() {} INestedService::ICallback::~ICallback() {} std::shared_ptr INestedService::ICallback::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_tests_nested_INestedService_ICallback_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t INestedService::ICallback::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t INestedService::ICallback::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = ICallback::fromBinder(binder); return STATUS_OK; } bool INestedService::ICallback::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!ICallback::default_impl); if (impl) { ICallback::default_impl = impl; return true; } return false; } const std::shared_ptr& INestedService::ICallback::getDefaultImpl() { return ICallback::default_impl; } std::shared_ptr INestedService::ICallback::default_impl = nullptr; ::ndk::ScopedAStatus INestedService::ICallbackDefault::done(::aidl::android::aidl::tests::nested::ParcelableWithNested::Status /*in_status*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::SpAIBinder INestedService::ICallbackDefault::asBinder() { return ::ndk::SpAIBinder(); } bool INestedService::ICallbackDefault::isRemote() { return false; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_nes0100644 0000000 0000000 00000000222 15172120304 033300 xustar000000000 0000000 118 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/nested/INestedService.cpp.d 28 mtime=1776853188.6410000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/nested/INestedServi0100644 0000000 0000000 00000000427 15172120304 033051 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/nested/INestedService.cpp : \ system/tools/aidl/tests/android/aidl/tests/nested/INestedService.aidl \ system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_nes0100644 0000000 0000000 00000000226 15172120304 033304 xustar000000000 0000000 122 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/nested/ParcelableWithNested.cpp 28 mtime=1776853188.6410000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/nested/ParcelableWi0100644 0000000 0000000 00000005234 15172120304 033040 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/nested/ParcelableWithNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl */ #include "aidl/android/aidl/tests/nested/ParcelableWithNested.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { namespace nested { const char* ParcelableWithNested::descriptor = "android.aidl.tests.nested.ParcelableWithNested"; binder_status_t ParcelableWithNested::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &status); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t ParcelableWithNested::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, status); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace nested } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_nes0100644 0000000 0000000 00000000230 15172120304 033277 xustar000000000 0000000 124 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/nested/ParcelableWithNested.cpp.d 28 mtime=1776853188.6410000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/nested/ParcelableWi0100644 0000000 0000000 00000000323 15172120304 033032 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/nested/ParcelableWithNested.cpp : \ system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_uni0100644 0000000 0000000 00000000034 15172120304 033307 xustar000000000 0000000 28 mtime=1776853188.6410000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/unions/0040755 0000000 0000000 00000000000 15172120304 030613 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_uni0100644 0000000 0000000 00000000213 15172120304 033306 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/unions/EnumUnion.cpp 28 mtime=1776853188.6410000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/unions/EnumUnion.cp0100644 0000000 0000000 00000006541 15172120304 033057 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/unions/EnumUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl */ #include "aidl/android/aidl/tests/unions/EnumUnion.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { namespace unions { const char* EnumUnion::descriptor = "android.aidl.tests.unions.EnumUnion"; #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" binder_status_t EnumUnion::readFromParcel(const AParcel* _parcel) { binder_status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_tag)) != STATUS_OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case intEnum: { ::aidl::android::aidl::tests::IntEnum _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::aidl::android::aidl::tests::IntEnum>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case longEnum: { ::aidl::android::aidl::tests::LongEnum _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::aidl::android::aidl::tests::LongEnum>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case deprecatedField: { int32_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } } return STATUS_BAD_VALUE; } binder_status_t EnumUnion::writeToParcel(AParcel* _parcel) const { binder_status_t _aidl_ret_status = ::ndk::AParcel_writeData(_parcel, static_cast(getTag())); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; switch (getTag()) { case intEnum: return ::ndk::AParcel_writeData(_parcel, get()); case longEnum: return ::ndk::AParcel_writeData(_parcel, get()); #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" case deprecatedField: return ::ndk::AParcel_writeData(_parcel, get()); #pragma clang diagnostic pop } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } #pragma clang diagnostic pop } // namespace unions } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_uni0100644 0000000 0000000 00000000215 15172120304 033310 xustar000000000 0000000 113 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/unions/EnumUnion.cpp.d 28 mtime=1776853188.6410000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/unions/EnumUnion.cp0100644 0000000 0000000 00000000466 15172120304 033057 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/unions/EnumUnion.cpp : \ system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_uni0100644 0000000 0000000 00000000216 15172120304 033311 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/unions/UnionInUnion.cpp 28 mtime=1776853188.6410000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/unions/UnionInUnion0100644 0000000 0000000 00000005113 15172120304 033123 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/unions/UnionInUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/UnionInUnion.aidl */ #include "aidl/android/aidl/tests/unions/UnionInUnion.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { namespace unions { const char* UnionInUnion::descriptor = "android.aidl.tests.unions.UnionInUnion"; binder_status_t UnionInUnion::readFromParcel(const AParcel* _parcel) { binder_status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_tag)) != STATUS_OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case first: { ::aidl::android::aidl::tests::unions::EnumUnion _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::aidl::android::aidl::tests::unions::EnumUnion>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case second: { int32_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } } return STATUS_BAD_VALUE; } binder_status_t UnionInUnion::writeToParcel(AParcel* _parcel) const { binder_status_t _aidl_ret_status = ::ndk::AParcel_writeData(_parcel, static_cast(getTag())); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; switch (getTag()) { case first: return ::ndk::AParcel_writeData(_parcel, get()); case second: return ::ndk::AParcel_writeData(_parcel, get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace unions } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_android_aidl_tests_uni0100644 0000000 0000000 00000000220 15172120304 033304 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/unions/UnionInUnion.cpp.d 28 mtime=1776853188.6410000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/android/aidl/tests/unions/UnionInUnion0100644 0000000 0000000 00000000601 15172120304 033120 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/android/aidl/tests/unions/UnionInUnion.cpp : \ system/tools/aidl/tests/android/aidl/tests/unions/UnionInUnion.aidl \ system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_0100644 0000000 0000000 00000000034 15172120304 030363 xustar000000000 0000000 28 mtime=1776853188.6410000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/0040755 0000000 0000000 00000000000 15172120304 025230 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_0100644 0000000 0000000 00000000034 15172120304 031354 xustar000000000 0000000 28 mtime=1776853188.6410000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/0040755 0000000 0000000 00000000000 15172120304 026141 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_0100644 0000000 0000000 00000000034 15172120304 033054 xustar000000000 0000000 28 mtime=1776853188.6410000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/0040755 0000000 0000000 00000000000 15172120304 027561 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000034 15172120304 033215 xustar000000000 0000000 28 mtime=1776853188.6410000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/0040755 0000000 0000000 00000000000 15172120304 030472 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000034 15172120304 033215 xustar000000000 0000000 28 mtime=1776853188.6410000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/0040755 0000000 0000000 00000000000 15172120304 031634 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000227 15172120304 033221 xustar000000000 0000000 123 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/ArrayOfInterfaces.h 28 mtime=1776853188.6420000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/ArrayO0100644 0000000 0000000 00000037645 15172120304 032770 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ArrayOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ArrayOfInterfaces.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace aidl { namespace android { namespace aidl { namespace tests { class ArrayOfInterfaces { public: typedef std::false_type fixed_size; static const char* descriptor; class IEmptyInterfaceDelegator; class IEmptyInterface : public ::ndk::ICInterface { public: typedef IEmptyInterfaceDelegator DefaultDelegator; static const char* descriptor; IEmptyInterface(); virtual ~IEmptyInterface(); static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); private: static std::shared_ptr default_impl; }; class IEmptyInterfaceDefault : public IEmptyInterface { public: ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; class BpEmptyInterface : public ::ndk::BpCInterface { public: explicit BpEmptyInterface(const ::ndk::SpAIBinder& binder); virtual ~BpEmptyInterface(); }; class BnEmptyInterface : public ::ndk::BnCInterface { public: BnEmptyInterface(); virtual ~BnEmptyInterface(); protected: ::ndk::SpAIBinder createBinder() override; private: }; class IMyInterfaceDelegator; class IMyInterface : public ::ndk::ICInterface { public: typedef IMyInterfaceDelegator DefaultDelegator; static const char* descriptor; IMyInterface(); virtual ~IMyInterface(); static constexpr uint32_t TRANSACTION_methodWithInterfaces = FIRST_CALL_TRANSACTION + 0; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus methodWithInterfaces(const std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& in_iface, const std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& in_nullable_iface, const std::vector>& in_iface_array_in, std::vector>* out_iface_array_out, std::vector>* in_iface_array_inout, const std::optional>>& in_nullable_iface_array_in, std::optional>>* out_nullable_iface_array_out, std::optional>>* in_nullable_iface_array_inout, std::optional>>* _aidl_return) = 0; private: static std::shared_ptr default_impl; }; class IMyInterfaceDefault : public IMyInterface { public: ::ndk::ScopedAStatus methodWithInterfaces(const std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& in_iface, const std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& in_nullable_iface, const std::vector>& in_iface_array_in, std::vector>* out_iface_array_out, std::vector>* in_iface_array_inout, const std::optional>>& in_nullable_iface_array_in, std::optional>>* out_nullable_iface_array_out, std::optional>>* in_nullable_iface_array_inout, std::optional>>* _aidl_return) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; class BpMyInterface : public ::ndk::BpCInterface { public: explicit BpMyInterface(const ::ndk::SpAIBinder& binder); virtual ~BpMyInterface(); ::ndk::ScopedAStatus methodWithInterfaces(const std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& in_iface, const std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>& in_nullable_iface, const std::vector>& in_iface_array_in, std::vector>* out_iface_array_out, std::vector>* in_iface_array_inout, const std::optional>>& in_nullable_iface_array_in, std::optional>>* out_nullable_iface_array_out, std::optional>>* in_nullable_iface_array_inout, std::optional>>* _aidl_return) override; }; class BnMyInterface : public ::ndk::BnCInterface { public: BnMyInterface(); virtual ~BnMyInterface(); protected: ::ndk::SpAIBinder createBinder() override; private: }; class MyParcelable { public: typedef std::false_type fixed_size; static const char* descriptor; std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface> iface; std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface> nullable_iface; std::vector> iface_array; std::optional>> nullable_iface_array; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const MyParcelable& _rhs) const { return std::tie(iface, nullable_iface, iface_array, nullable_iface_array) == std::tie(_rhs.iface, _rhs.nullable_iface, _rhs.iface_array, _rhs.nullable_iface_array); } inline bool operator<(const MyParcelable& _rhs) const { return std::tie(iface, nullable_iface, iface_array, nullable_iface_array) < std::tie(_rhs.iface, _rhs.nullable_iface, _rhs.iface_array, _rhs.nullable_iface_array); } inline bool operator!=(const MyParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyParcelable& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "MyParcelable{"; _aidl_os << "iface: " << ::android::internal::ToString(iface); _aidl_os << ", nullable_iface: " << ::android::internal::ToString(nullable_iface); _aidl_os << ", iface_array: " << ::android::internal::ToString(iface_array); _aidl_os << ", nullable_iface_array: " << ::android::internal::ToString(nullable_iface_array); _aidl_os << "}"; return _aidl_os.str(); } }; class MyUnion { public: typedef std::false_type fixed_size; static const char* descriptor; enum class Tag : int32_t { iface = 0, nullable_iface = 1, iface_array = 2, nullable_iface_array = 3, }; // Expose tag symbols for legacy code static const inline Tag iface = Tag::iface; static const inline Tag nullable_iface = Tag::nullable_iface; static const inline Tag iface_array = Tag::iface_array; static const inline Tag nullable_iface_array = Tag::nullable_iface_array; template static constexpr bool _not_self = !std::is_same_v>, MyUnion>; MyUnion() : _value(std::in_place_index(iface)>, std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>()) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr MyUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit MyUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static MyUnion make(_Tp&&... _args) { return MyUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static MyUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return MyUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } binder_status_t readFromParcel(const AParcel* _parcel); binder_status_t writeToParcel(AParcel* _parcel) const; inline bool operator==(const MyUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const MyUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const MyUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyUnion& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream os; os << "MyUnion{"; switch (getTag()) { case iface: os << "iface: " << ::android::internal::ToString(get()); break; case nullable_iface: os << "nullable_iface: " << ::android::internal::ToString(get()); break; case iface_array: os << "iface_array: " << ::android::internal::ToString(get()); break; case nullable_iface_array: os << "nullable_iface_array: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant, std::shared_ptr<::aidl::android::aidl::tests::ArrayOfInterfaces::IEmptyInterface>, std::vector>, std::optional>>> _value; }; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const ArrayOfInterfaces&) const { return std::tie() == std::tie(); } inline bool operator<(const ArrayOfInterfaces&) const { return std::tie() < std::tie(); } inline bool operator!=(const ArrayOfInterfaces& _rhs) const { return !(*this == _rhs); } inline bool operator>(const ArrayOfInterfaces& _rhs) const { return _rhs < *this; } inline bool operator>=(const ArrayOfInterfaces& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const ArrayOfInterfaces& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "ArrayOfInterfaces{"; _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(ArrayOfInterfaces::MyUnion::Tag val) { switch(val) { case ArrayOfInterfaces::MyUnion::Tag::iface: return "iface"; case ArrayOfInterfaces::MyUnion::Tag::nullable_iface: return "nullable_iface"; case ArrayOfInterfaces::MyUnion::Tag::iface_array: return "iface_array"; case ArrayOfInterfaces::MyUnion::Tag::nullable_iface_array: return "nullable_iface_array"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::tests::ArrayOfInterfaces::MyUnion::Tag::iface, aidl::android::aidl::tests::ArrayOfInterfaces::MyUnion::Tag::nullable_iface, aidl::android::aidl::tests::ArrayOfInterfaces::MyUnion::Tag::iface_array, aidl::android::aidl::tests::ArrayOfInterfaces::MyUnion::Tag::nullable_iface_array, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000221 15172120304 033213 xustar000000000 0000000 117 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BackendType.h 28 mtime=1776853188.6420000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/Backen0100644 0000000 0000000 00000004114 15172120304 032737 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/BackendType.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/BackendType.aidl */ #pragma once #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { enum class BackendType : int8_t { CPP = 0, JAVA = 1, NDK = 2, RUST = 3, }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(BackendType val) { switch(val) { case BackendType::CPP: return "CPP"; case BackendType::JAVA: return "JAVA"; case BackendType::NDK: return "NDK"; case BackendType::RUST: return "RUST"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::tests::BackendType::CPP, aidl::android::aidl::tests::BackendType::JAVA, aidl::android::aidl::tests::BackendType::NDK, aidl::android::aidl::tests::BackendType::RUST, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000231 15172120304 033214 xustar000000000 0000000 125 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnArrayOfInterfaces.h 28 mtime=1776853188.6420000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnArra0100644 0000000 0000000 00000001232 15172120304 032717 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ArrayOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ArrayOfInterfaces.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000223 15172120304 033215 xustar000000000 0000000 119 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnBackendType.h 28 mtime=1776853188.6420000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnBack0100644 0000000 0000000 00000001206 15172120304 032673 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/BackendType.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/BackendType.aidl */ #error TODO(b/111362593) enums do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000220 15172120304 033212 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnByteEnum.h 28 mtime=1776853188.6440000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnByte0100644 0000000 0000000 00000001200 15172120304 032730 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ByteEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl */ #error TODO(b/111362593) enums do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000220 15172120304 033212 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnCircular.h 28 mtime=1776853188.6440000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnCirc0100644 0000000 0000000 00000002751 15172120304 032721 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ICircular.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ICircular.aidl */ #pragma once #include "aidl/android/aidl/tests/ICircular.h" #include #include #ifndef __BIONIC__ #ifndef __assert2 #define __assert2(a,b,c,d) ((void)0) #endif #endif namespace aidl { namespace android { namespace aidl { namespace tests { class BnCircular : public ::ndk::BnCInterface { public: BnCircular(); virtual ~BnCircular(); protected: ::ndk::SpAIBinder createBinder() override; private: }; class ICircularDelegator : public BnCircular { public: explicit ICircularDelegator(const std::shared_ptr &impl) : _impl(impl) { } ::ndk::ScopedAStatus GetTestService(std::shared_ptr<::aidl::android::aidl::tests::ITestService>* _aidl_return) override { return _impl->GetTestService(_aidl_return); } protected: private: std::shared_ptr _impl; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000232 15172120304 033215 xustar000000000 0000000 126 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnCircularParcelable.h 28 mtime=1776853188.6440000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnCirc0100644 0000000 0000000 00000001234 15172120304 032714 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/CircularParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000236 15172120304 033221 xustar000000000 0000000 130 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnConstantExpressionEnum.h 28 mtime=1776853188.6440000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnCons0100644 0000000 0000000 00000001234 15172120304 032736 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ConstantExpressionEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl */ #error TODO(b/111362593) enums do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000222 15172120304 033214 xustar000000000 0000000 118 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnDeprecated.h 28 mtime=1776853188.6440000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnDepr0100644 0000000 0000000 00000002631 15172120304 032730 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/IDeprecated.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IDeprecated.aidl */ #pragma once #include "aidl/android/aidl/tests/IDeprecated.h" #include #include #ifndef __BIONIC__ #ifndef __assert2 #define __assert2(a,b,c,d) ((void)0) #endif #endif namespace aidl { namespace android { namespace aidl { namespace tests { class __attribute__((deprecated("test"))) BnDeprecated : public ::ndk::BnCInterface { public: BnDeprecated(); virtual ~BnDeprecated(); protected: ::ndk::SpAIBinder createBinder() override; private: }; class __attribute__((deprecated("test"))) IDeprecatedDelegator : public BnDeprecated { public: explicit IDeprecatedDelegator(const std::shared_ptr &impl) : _impl(impl) { } protected: private: std::shared_ptr _impl; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000226 15172120304 033220 xustar000000000 0000000 122 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnDeprecatedEnum.h 28 mtime=1776853188.6440000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnDepr0100644 0000000 0000000 00000001214 15172120304 032724 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/DeprecatedEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedEnum.aidl */ #error TODO(b/111362593) enums do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000234 15172120304 033217 xustar000000000 0000000 128 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnDeprecatedParcelable.h 28 mtime=1776853188.6440000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnDepr0100644 0000000 0000000 00000001240 15172120304 032723 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/DeprecatedParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedParcelable.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000221 15172120304 033213 xustar000000000 0000000 117 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnFixedSize.h 28 mtime=1776853188.6450000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnFixe0100644 0000000 0000000 00000001212 15172120304 032723 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/FixedSize.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/FixedSize.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000243 15172120304 033217 xustar000000000 0000000 135 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnGenericStructuredParcelable.h 28 mtime=1776853188.6450000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnGene0100644 0000000 0000000 00000001256 15172120304 032716 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/GenericStructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000217 15172120304 033220 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnIntEnum.h 28 mtime=1776853188.6450000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnIntE0100644 0000000 0000000 00000001176 15172120304 032700 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/IntEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl */ #error TODO(b/111362593) enums do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000230 15172120304 033213 xustar000000000 0000000 124 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnListOfInterfaces.h 28 mtime=1776853188.6450000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnList0100644 0000000 0000000 00000001230 15172120304 032743 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ListOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ListOfInterfaces.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000220 15172120304 033212 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnLongEnum.h 28 mtime=1776853188.6450000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnLong0100644 0000000 0000000 00000001200 15172120304 032724 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/LongEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl */ #error TODO(b/111362593) enums do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000225 15172120304 033217 xustar000000000 0000000 121 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnNamedCallback.h 28 mtime=1776853188.6450000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnName0100644 0000000 0000000 00000002747 15172120304 032726 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/INamedCallback.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl */ #pragma once #include "aidl/android/aidl/tests/INamedCallback.h" #include #include #ifndef __BIONIC__ #ifndef __assert2 #define __assert2(a,b,c,d) ((void)0) #endif #endif namespace aidl { namespace android { namespace aidl { namespace tests { class BnNamedCallback : public ::ndk::BnCInterface { public: BnNamedCallback(); virtual ~BnNamedCallback(); protected: ::ndk::SpAIBinder createBinder() override; private: }; class INamedCallbackDelegator : public BnNamedCallback { public: explicit INamedCallbackDelegator(const std::shared_ptr &impl) : _impl(impl) { } ::ndk::ScopedAStatus GetName(std::string* _aidl_return) override { return _impl->GetName(_aidl_return); } protected: private: std::shared_ptr _impl; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000217 15172120304 033220 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnNewName.h 28 mtime=1776853188.6450000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnNewN0100644 0000000 0000000 00000002641 15172120304 032706 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/INewName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INewName.aidl */ #pragma once #include "aidl/android/aidl/tests/INewName.h" #include #include #ifndef __BIONIC__ #ifndef __assert2 #define __assert2(a,b,c,d) ((void)0) #endif #endif namespace aidl { namespace android { namespace aidl { namespace tests { class BnNewName : public ::ndk::BnCInterface { public: BnNewName(); virtual ~BnNewName(); protected: ::ndk::SpAIBinder createBinder() override; private: }; class INewNameDelegator : public BnNewName { public: explicit INewNameDelegator(const std::shared_ptr &impl) : _impl(impl) { } ::ndk::ScopedAStatus RealName(std::string* _aidl_return) override { return _impl->RealName(_aidl_return); } protected: private: std::shared_ptr _impl; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000217 15172120304 033220 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnOldName.h 28 mtime=1776853188.6450000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnOldN0100644 0000000 0000000 00000002641 15172120304 032673 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/IOldName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IOldName.aidl */ #pragma once #include "aidl/android/aidl/tests/IOldName.h" #include #include #ifndef __BIONIC__ #ifndef __assert2 #define __assert2(a,b,c,d) ((void)0) #endif #endif namespace aidl { namespace android { namespace aidl { namespace tests { class BnOldName : public ::ndk::BnCInterface { public: BnOldName(); virtual ~BnOldName(); protected: ::ndk::SpAIBinder createBinder() override; private: }; class IOldNameDelegator : public BnOldName { public: explicit IOldNameDelegator(const std::shared_ptr &impl) : _impl(impl) { } ::ndk::ScopedAStatus RealName(std::string* _aidl_return) override { return _impl->RealName(_aidl_return); } protected: private: std::shared_ptr _impl; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000242 15172120304 033216 xustar000000000 0000000 134 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnOtherParcelableForToString.h 28 mtime=1776853188.6450000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnOthe0100644 0000000 0000000 00000001254 15172120304 032735 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/OtherParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000235 15172120304 033220 xustar000000000 0000000 129 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnParcelableForToString.h 28 mtime=1776853188.6450000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnParc0100644 0000000 0000000 00000001242 15172120304 032720 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ParcelableForToString.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000225 15172120304 033217 xustar000000000 0000000 121 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnRecursiveList.h 28 mtime=1776853188.6450000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnRecu0100644 0000000 0000000 00000001222 15172120304 032727 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/RecursiveList.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000234 15172120304 033217 xustar000000000 0000000 128 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnStructuredParcelable.h 28 mtime=1776853188.6450000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnStru0100644 0000000 0000000 00000001240 15172120304 032766 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/StructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000223 15172120304 033215 xustar000000000 0000000 119 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnTestService.h 28 mtime=1776853188.6450000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnTest0100644 0000000 0000000 00000043124 15172120304 032757 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ITestService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ITestService.aidl */ #pragma once #include "aidl/android/aidl/tests/ITestService.h" #include #include #ifndef __BIONIC__ #ifndef __assert2 #define __assert2(a,b,c,d) ((void)0) #endif #endif namespace aidl { namespace android { namespace aidl { namespace tests { class BnTestService : public ::ndk::BnCInterface { public: BnTestService(); virtual ~BnTestService(); protected: ::ndk::SpAIBinder createBinder() override; private: }; class ITestServiceDelegator : public BnTestService { public: explicit ITestServiceDelegator(const std::shared_ptr &impl) : _impl(impl) { } ::ndk::ScopedAStatus UnimplementedMethod(int32_t in_arg, int32_t* _aidl_return) override { return _impl->UnimplementedMethod(in_arg, _aidl_return); } ::ndk::ScopedAStatus Deprecated() override __attribute__((deprecated("to make sure we have something in system/tools/aidl which does a compile check of deprecated and make sure this is reflected in goldens"))) { return _impl->Deprecated(); } ::ndk::ScopedAStatus TestOneway() override { return _impl->TestOneway(); } ::ndk::ScopedAStatus RepeatBoolean(bool in_token, bool* _aidl_return) override { return _impl->RepeatBoolean(in_token, _aidl_return); } ::ndk::ScopedAStatus RepeatByte(int8_t in_token, int8_t* _aidl_return) override { return _impl->RepeatByte(in_token, _aidl_return); } ::ndk::ScopedAStatus RepeatChar(char16_t in_token, char16_t* _aidl_return) override { return _impl->RepeatChar(in_token, _aidl_return); } ::ndk::ScopedAStatus RepeatInt(int32_t in_token, int32_t* _aidl_return) override { return _impl->RepeatInt(in_token, _aidl_return); } ::ndk::ScopedAStatus RepeatLong(int64_t in_token, int64_t* _aidl_return) override { return _impl->RepeatLong(in_token, _aidl_return); } ::ndk::ScopedAStatus RepeatFloat(float in_token, float* _aidl_return) override { return _impl->RepeatFloat(in_token, _aidl_return); } ::ndk::ScopedAStatus RepeatDouble(double in_token, double* _aidl_return) override { return _impl->RepeatDouble(in_token, _aidl_return); } ::ndk::ScopedAStatus RepeatString(const std::string& in_token, std::string* _aidl_return) override { return _impl->RepeatString(in_token, _aidl_return); } ::ndk::ScopedAStatus RepeatByteEnum(::aidl::android::aidl::tests::ByteEnum in_token, ::aidl::android::aidl::tests::ByteEnum* _aidl_return) override { return _impl->RepeatByteEnum(in_token, _aidl_return); } ::ndk::ScopedAStatus RepeatIntEnum(::aidl::android::aidl::tests::IntEnum in_token, ::aidl::android::aidl::tests::IntEnum* _aidl_return) override { return _impl->RepeatIntEnum(in_token, _aidl_return); } ::ndk::ScopedAStatus RepeatLongEnum(::aidl::android::aidl::tests::LongEnum in_token, ::aidl::android::aidl::tests::LongEnum* _aidl_return) override { return _impl->RepeatLongEnum(in_token, _aidl_return); } ::ndk::ScopedAStatus ReverseBoolean(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override { return _impl->ReverseBoolean(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus ReverseByte(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override { return _impl->ReverseByte(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus ReverseChar(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override { return _impl->ReverseChar(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus ReverseInt(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override { return _impl->ReverseInt(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus ReverseLong(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override { return _impl->ReverseLong(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus ReverseFloat(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override { return _impl->ReverseFloat(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus ReverseDouble(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override { return _impl->ReverseDouble(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus ReverseString(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override { return _impl->ReverseString(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus ReverseByteEnum(const std::vector<::aidl::android::aidl::tests::ByteEnum>& in_input, std::vector<::aidl::android::aidl::tests::ByteEnum>* out_repeated, std::vector<::aidl::android::aidl::tests::ByteEnum>* _aidl_return) override { return _impl->ReverseByteEnum(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus ReverseIntEnum(const std::vector<::aidl::android::aidl::tests::IntEnum>& in_input, std::vector<::aidl::android::aidl::tests::IntEnum>* out_repeated, std::vector<::aidl::android::aidl::tests::IntEnum>* _aidl_return) override { return _impl->ReverseIntEnum(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus ReverseLongEnum(const std::vector<::aidl::android::aidl::tests::LongEnum>& in_input, std::vector<::aidl::android::aidl::tests::LongEnum>* out_repeated, std::vector<::aidl::android::aidl::tests::LongEnum>* _aidl_return) override { return _impl->ReverseLongEnum(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus GetOtherTestService(const std::string& in_name, std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>* _aidl_return) override { return _impl->GetOtherTestService(in_name, _aidl_return); } ::ndk::ScopedAStatus SetOtherTestService(const std::string& in_name, const std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>& in_service, bool* _aidl_return) override { return _impl->SetOtherTestService(in_name, in_service, _aidl_return); } ::ndk::ScopedAStatus VerifyName(const std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>& in_service, const std::string& in_name, bool* _aidl_return) override { return _impl->VerifyName(in_service, in_name, _aidl_return); } ::ndk::ScopedAStatus GetInterfaceArray(const std::vector& in_names, std::vector>* _aidl_return) override { return _impl->GetInterfaceArray(in_names, _aidl_return); } ::ndk::ScopedAStatus VerifyNamesWithInterfaceArray(const std::vector>& in_services, const std::vector& in_names, bool* _aidl_return) override { return _impl->VerifyNamesWithInterfaceArray(in_services, in_names, _aidl_return); } ::ndk::ScopedAStatus GetNullableInterfaceArray(const std::optional>>& in_names, std::optional>>* _aidl_return) override { return _impl->GetNullableInterfaceArray(in_names, _aidl_return); } ::ndk::ScopedAStatus VerifyNamesWithNullableInterfaceArray(const std::optional>>& in_services, const std::optional>>& in_names, bool* _aidl_return) override { return _impl->VerifyNamesWithNullableInterfaceArray(in_services, in_names, _aidl_return); } ::ndk::ScopedAStatus GetInterfaceList(const std::optional>>& in_names, std::optional>>* _aidl_return) override { return _impl->GetInterfaceList(in_names, _aidl_return); } ::ndk::ScopedAStatus VerifyNamesWithInterfaceList(const std::optional>>& in_services, const std::optional>>& in_names, bool* _aidl_return) override { return _impl->VerifyNamesWithInterfaceList(in_services, in_names, _aidl_return); } ::ndk::ScopedAStatus ReverseStringList(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override { return _impl->ReverseStringList(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus RepeatParcelFileDescriptor(const ::ndk::ScopedFileDescriptor& in_read, ::ndk::ScopedFileDescriptor* _aidl_return) override { return _impl->RepeatParcelFileDescriptor(in_read, _aidl_return); } ::ndk::ScopedAStatus ReverseParcelFileDescriptorArray(const std::vector<::ndk::ScopedFileDescriptor>& in_input, std::vector<::ndk::ScopedFileDescriptor>* out_repeated, std::vector<::ndk::ScopedFileDescriptor>* _aidl_return) override { return _impl->ReverseParcelFileDescriptorArray(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus ThrowServiceException(int32_t in_code) override { return _impl->ThrowServiceException(in_code); } ::ndk::ScopedAStatus RepeatNullableIntArray(const std::optional>& in_input, std::optional>* _aidl_return) override { return _impl->RepeatNullableIntArray(in_input, _aidl_return); } ::ndk::ScopedAStatus RepeatNullableByteEnumArray(const std::optional>& in_input, std::optional>* _aidl_return) override { return _impl->RepeatNullableByteEnumArray(in_input, _aidl_return); } ::ndk::ScopedAStatus RepeatNullableIntEnumArray(const std::optional>& in_input, std::optional>* _aidl_return) override { return _impl->RepeatNullableIntEnumArray(in_input, _aidl_return); } ::ndk::ScopedAStatus RepeatNullableLongEnumArray(const std::optional>& in_input, std::optional>* _aidl_return) override { return _impl->RepeatNullableLongEnumArray(in_input, _aidl_return); } ::ndk::ScopedAStatus RepeatNullableString(const std::optional& in_input, std::optional* _aidl_return) override { return _impl->RepeatNullableString(in_input, _aidl_return); } ::ndk::ScopedAStatus RepeatNullableStringList(const std::optional>>& in_input, std::optional>>* _aidl_return) override { return _impl->RepeatNullableStringList(in_input, _aidl_return); } ::ndk::ScopedAStatus RepeatNullableParcelable(const std::optional<::aidl::android::aidl::tests::ITestService::Empty>& in_input, std::optional<::aidl::android::aidl::tests::ITestService::Empty>* _aidl_return) override { return _impl->RepeatNullableParcelable(in_input, _aidl_return); } ::ndk::ScopedAStatus RepeatNullableParcelableArray(const std::optional>>& in_input, std::optional>>* _aidl_return) override { return _impl->RepeatNullableParcelableArray(in_input, _aidl_return); } ::ndk::ScopedAStatus RepeatNullableParcelableList(const std::optional>>& in_input, std::optional>>* _aidl_return) override { return _impl->RepeatNullableParcelableList(in_input, _aidl_return); } ::ndk::ScopedAStatus TakesAnIBinder(const ::ndk::SpAIBinder& in_input) override { return _impl->TakesAnIBinder(in_input); } ::ndk::ScopedAStatus TakesANullableIBinder(const ::ndk::SpAIBinder& in_input) override { return _impl->TakesANullableIBinder(in_input); } ::ndk::ScopedAStatus TakesAnIBinderList(const std::vector<::ndk::SpAIBinder>& in_input) override { return _impl->TakesAnIBinderList(in_input); } ::ndk::ScopedAStatus TakesANullableIBinderList(const std::optional>& in_input) override { return _impl->TakesANullableIBinderList(in_input); } ::ndk::ScopedAStatus RepeatUtf8CppString(const std::string& in_token, std::string* _aidl_return) override { return _impl->RepeatUtf8CppString(in_token, _aidl_return); } ::ndk::ScopedAStatus RepeatNullableUtf8CppString(const std::optional& in_token, std::optional* _aidl_return) override { return _impl->RepeatNullableUtf8CppString(in_token, _aidl_return); } ::ndk::ScopedAStatus ReverseUtf8CppString(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override { return _impl->ReverseUtf8CppString(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus ReverseNullableUtf8CppString(const std::optional>>& in_input, std::optional>>* out_repeated, std::optional>>* _aidl_return) override { return _impl->ReverseNullableUtf8CppString(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus ReverseUtf8CppStringList(const std::optional>>& in_input, std::optional>>* out_repeated, std::optional>>* _aidl_return) override { return _impl->ReverseUtf8CppStringList(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus GetCallback(bool in_return_null, std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>* _aidl_return) override { return _impl->GetCallback(in_return_null, _aidl_return); } ::ndk::ScopedAStatus FillOutStructuredParcelable(::aidl::android::aidl::tests::StructuredParcelable* in_parcel) override { return _impl->FillOutStructuredParcelable(in_parcel); } ::ndk::ScopedAStatus RepeatExtendableParcelable(const ::aidl::android::aidl::tests::extension::ExtendableParcelable& in_ep, ::aidl::android::aidl::tests::extension::ExtendableParcelable* out_ep2) override { return _impl->RepeatExtendableParcelable(in_ep, out_ep2); } ::ndk::ScopedAStatus ReverseList(const ::aidl::android::aidl::tests::RecursiveList& in_list, ::aidl::android::aidl::tests::RecursiveList* _aidl_return) override { return _impl->ReverseList(in_list, _aidl_return); } ::ndk::ScopedAStatus ReverseIBinderArray(const std::vector<::ndk::SpAIBinder>& in_input, std::vector<::ndk::SpAIBinder>* out_repeated, std::vector<::ndk::SpAIBinder>* _aidl_return) override { return _impl->ReverseIBinderArray(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus ReverseNullableIBinderArray(const std::optional>& in_input, std::optional>* out_repeated, std::optional>* _aidl_return) override { return _impl->ReverseNullableIBinderArray(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus RepeatSimpleParcelable(const ::aidl::android::aidl::tests::SimpleParcelable& in_input, ::aidl::android::aidl::tests::SimpleParcelable* out_repeat, ::aidl::android::aidl::tests::SimpleParcelable* _aidl_return) override { return _impl->RepeatSimpleParcelable(in_input, out_repeat, _aidl_return); } ::ndk::ScopedAStatus ReverseSimpleParcelables(const std::vector<::aidl::android::aidl::tests::SimpleParcelable>& in_input, std::vector<::aidl::android::aidl::tests::SimpleParcelable>* out_repeated, std::vector<::aidl::android::aidl::tests::SimpleParcelable>* _aidl_return) override { return _impl->ReverseSimpleParcelables(in_input, out_repeated, _aidl_return); } ::ndk::ScopedAStatus GetOldNameInterface(std::shared_ptr<::aidl::android::aidl::tests::IOldName>* _aidl_return) override { return _impl->GetOldNameInterface(_aidl_return); } ::ndk::ScopedAStatus GetNewNameInterface(std::shared_ptr<::aidl::android::aidl::tests::INewName>* _aidl_return) override { return _impl->GetNewNameInterface(_aidl_return); } ::ndk::ScopedAStatus GetUnionTags(const std::vector<::aidl::android::aidl::tests::Union>& in_input, std::vector<::aidl::android::aidl::tests::Union::Tag>* _aidl_return) override { return _impl->GetUnionTags(in_input, _aidl_return); } ::ndk::ScopedAStatus GetCppJavaTests(::ndk::SpAIBinder* _aidl_return) override { return _impl->GetCppJavaTests(_aidl_return); } ::ndk::ScopedAStatus getBackendType(::aidl::android::aidl::tests::BackendType* _aidl_return) override { return _impl->getBackendType(_aidl_return); } ::ndk::ScopedAStatus GetCircular(::aidl::android::aidl::tests::CircularParcelable* out_cp, std::shared_ptr<::aidl::android::aidl::tests::ICircular>* _aidl_return) override { return _impl->GetCircular(out_cp, _aidl_return); } protected: private: std::shared_ptr _impl; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000215 15172120304 033216 xustar000000000 0000000 113 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnUnion.h 28 mtime=1776853188.6460000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnUnio0100644 0000000 0000000 00000001202 15172120304 032741 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/Union.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/Union.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000223 15172120304 033215 xustar000000000 0000000 119 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnUnionWithFd.h 28 mtime=1776853188.6460000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BnUnio0100644 0000000 0000000 00000001216 15172120304 032746 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/UnionWithFd.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/UnionWithFd.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000231 15172120304 033214 xustar000000000 0000000 125 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpArrayOfInterfaces.h 28 mtime=1776853188.6460000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpArra0100644 0000000 0000000 00000001232 15172120304 032721 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ArrayOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ArrayOfInterfaces.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000223 15172120304 033215 xustar000000000 0000000 119 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpBackendType.h 28 mtime=1776853188.6460000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpBack0100644 0000000 0000000 00000001206 15172120304 032675 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/BackendType.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/BackendType.aidl */ #error TODO(b/111362593) enums do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000220 15172120304 033212 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpByteEnum.h 28 mtime=1776853188.6460000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpByte0100644 0000000 0000000 00000001200 15172120304 032732 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ByteEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl */ #error TODO(b/111362593) enums do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000220 15172120304 033212 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpCircular.h 28 mtime=1776853188.6460000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpCirc0100644 0000000 0000000 00000002142 15172120304 032715 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ICircular.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ICircular.aidl */ #pragma once #include "aidl/android/aidl/tests/ICircular.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { class BpCircular : public ::ndk::BpCInterface { public: explicit BpCircular(const ::ndk::SpAIBinder& binder); virtual ~BpCircular(); ::ndk::ScopedAStatus GetTestService(std::shared_ptr<::aidl::android::aidl::tests::ITestService>* _aidl_return) override; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000232 15172120304 033215 xustar000000000 0000000 126 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpCircularParcelable.h 28 mtime=1776853188.6460000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpCirc0100644 0000000 0000000 00000001234 15172120304 032716 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/CircularParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000236 15172120304 033221 xustar000000000 0000000 130 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpConstantExpressionEnum.h 28 mtime=1776853188.6460000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpCons0100644 0000000 0000000 00000001234 15172120304 032740 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ConstantExpressionEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl */ #error TODO(b/111362593) enums do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000222 15172120304 033214 xustar000000000 0000000 118 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpDeprecated.h 28 mtime=1776853188.6460000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpDepr0100644 0000000 0000000 00000002031 15172120304 032724 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/IDeprecated.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IDeprecated.aidl */ #pragma once #include "aidl/android/aidl/tests/IDeprecated.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { class __attribute__((deprecated("test"))) BpDeprecated : public ::ndk::BpCInterface { public: explicit BpDeprecated(const ::ndk::SpAIBinder& binder); virtual ~BpDeprecated(); }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000226 15172120304 033220 xustar000000000 0000000 122 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpDeprecatedEnum.h 28 mtime=1776853188.6470000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpDepr0100644 0000000 0000000 00000001214 15172120304 032726 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/DeprecatedEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedEnum.aidl */ #error TODO(b/111362593) enums do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000234 15172120304 033217 xustar000000000 0000000 128 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpDeprecatedParcelable.h 28 mtime=1776853188.6470000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpDepr0100644 0000000 0000000 00000001240 15172120304 032725 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/DeprecatedParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedParcelable.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000221 15172120304 033213 xustar000000000 0000000 117 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpFixedSize.h 28 mtime=1776853188.6470000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpFixe0100644 0000000 0000000 00000001212 15172120304 032725 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/FixedSize.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/FixedSize.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000243 15172120304 033217 xustar000000000 0000000 135 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpGenericStructuredParcelable.h 28 mtime=1776853188.6470000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpGene0100644 0000000 0000000 00000001256 15172120304 032720 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/GenericStructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000217 15172120304 033220 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpIntEnum.h 28 mtime=1776853188.6470000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpIntE0100644 0000000 0000000 00000001176 15172120304 032702 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/IntEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl */ #error TODO(b/111362593) enums do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000230 15172120304 033213 xustar000000000 0000000 124 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpListOfInterfaces.h 28 mtime=1776853188.6470000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpList0100644 0000000 0000000 00000001230 15172120304 032745 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ListOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ListOfInterfaces.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000220 15172120304 033212 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpLongEnum.h 28 mtime=1776853188.6470000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpLong0100644 0000000 0000000 00000001200 15172120304 032726 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/LongEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl */ #error TODO(b/111362593) enums do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000225 15172120304 033217 xustar000000000 0000000 121 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpNamedCallback.h 28 mtime=1776853188.6470000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpName0100644 0000000 0000000 00000002116 15172120304 032716 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/INamedCallback.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl */ #pragma once #include "aidl/android/aidl/tests/INamedCallback.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { class BpNamedCallback : public ::ndk::BpCInterface { public: explicit BpNamedCallback(const ::ndk::SpAIBinder& binder); virtual ~BpNamedCallback(); ::ndk::ScopedAStatus GetName(std::string* _aidl_return) override; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000217 15172120304 033220 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpNewName.h 28 mtime=1776853188.6470000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpNewN0100644 0000000 0000000 00000002045 15172120304 032706 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/INewName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INewName.aidl */ #pragma once #include "aidl/android/aidl/tests/INewName.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { class BpNewName : public ::ndk::BpCInterface { public: explicit BpNewName(const ::ndk::SpAIBinder& binder); virtual ~BpNewName(); ::ndk::ScopedAStatus RealName(std::string* _aidl_return) override; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000217 15172120304 033220 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpOldName.h 28 mtime=1776853188.6470000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpOldN0100644 0000000 0000000 00000002045 15172120304 032673 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/IOldName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IOldName.aidl */ #pragma once #include "aidl/android/aidl/tests/IOldName.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { class BpOldName : public ::ndk::BpCInterface { public: explicit BpOldName(const ::ndk::SpAIBinder& binder); virtual ~BpOldName(); ::ndk::ScopedAStatus RealName(std::string* _aidl_return) override; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000242 15172120304 033216 xustar000000000 0000000 134 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpOtherParcelableForToString.h 28 mtime=1776853188.6470000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpOthe0100644 0000000 0000000 00000001254 15172120304 032737 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/OtherParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000235 15172120304 033220 xustar000000000 0000000 129 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpParcelableForToString.h 28 mtime=1776853188.6480000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpParc0100644 0000000 0000000 00000001242 15172120304 032722 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ParcelableForToString.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000225 15172120304 033217 xustar000000000 0000000 121 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpRecursiveList.h 28 mtime=1776853188.6480000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpRecu0100644 0000000 0000000 00000001222 15172120304 032731 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/RecursiveList.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000234 15172120304 033217 xustar000000000 0000000 128 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpStructuredParcelable.h 28 mtime=1776853188.6480000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpStru0100644 0000000 0000000 00000001240 15172120304 032770 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/StructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000223 15172120304 033215 xustar000000000 0000000 119 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpTestService.h 28 mtime=1776853188.6480000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpTest0100644 0000000 0000000 00000030751 15172120304 032763 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ITestService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ITestService.aidl */ #pragma once #include "aidl/android/aidl/tests/ITestService.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { class BpTestService : public ::ndk::BpCInterface { public: explicit BpTestService(const ::ndk::SpAIBinder& binder); virtual ~BpTestService(); ::ndk::ScopedAStatus UnimplementedMethod(int32_t in_arg, int32_t* _aidl_return) override; ::ndk::ScopedAStatus Deprecated() override __attribute__((deprecated("to make sure we have something in system/tools/aidl which does a compile check of deprecated and make sure this is reflected in goldens"))); ::ndk::ScopedAStatus TestOneway() override; ::ndk::ScopedAStatus RepeatBoolean(bool in_token, bool* _aidl_return) override; ::ndk::ScopedAStatus RepeatByte(int8_t in_token, int8_t* _aidl_return) override; ::ndk::ScopedAStatus RepeatChar(char16_t in_token, char16_t* _aidl_return) override; ::ndk::ScopedAStatus RepeatInt(int32_t in_token, int32_t* _aidl_return) override; ::ndk::ScopedAStatus RepeatLong(int64_t in_token, int64_t* _aidl_return) override; ::ndk::ScopedAStatus RepeatFloat(float in_token, float* _aidl_return) override; ::ndk::ScopedAStatus RepeatDouble(double in_token, double* _aidl_return) override; ::ndk::ScopedAStatus RepeatString(const std::string& in_token, std::string* _aidl_return) override; ::ndk::ScopedAStatus RepeatByteEnum(::aidl::android::aidl::tests::ByteEnum in_token, ::aidl::android::aidl::tests::ByteEnum* _aidl_return) override; ::ndk::ScopedAStatus RepeatIntEnum(::aidl::android::aidl::tests::IntEnum in_token, ::aidl::android::aidl::tests::IntEnum* _aidl_return) override; ::ndk::ScopedAStatus RepeatLongEnum(::aidl::android::aidl::tests::LongEnum in_token, ::aidl::android::aidl::tests::LongEnum* _aidl_return) override; ::ndk::ScopedAStatus ReverseBoolean(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseByte(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseChar(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseInt(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseLong(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseFloat(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseDouble(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseString(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseByteEnum(const std::vector<::aidl::android::aidl::tests::ByteEnum>& in_input, std::vector<::aidl::android::aidl::tests::ByteEnum>* out_repeated, std::vector<::aidl::android::aidl::tests::ByteEnum>* _aidl_return) override; ::ndk::ScopedAStatus ReverseIntEnum(const std::vector<::aidl::android::aidl::tests::IntEnum>& in_input, std::vector<::aidl::android::aidl::tests::IntEnum>* out_repeated, std::vector<::aidl::android::aidl::tests::IntEnum>* _aidl_return) override; ::ndk::ScopedAStatus ReverseLongEnum(const std::vector<::aidl::android::aidl::tests::LongEnum>& in_input, std::vector<::aidl::android::aidl::tests::LongEnum>* out_repeated, std::vector<::aidl::android::aidl::tests::LongEnum>* _aidl_return) override; ::ndk::ScopedAStatus GetOtherTestService(const std::string& in_name, std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>* _aidl_return) override; ::ndk::ScopedAStatus SetOtherTestService(const std::string& in_name, const std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>& in_service, bool* _aidl_return) override; ::ndk::ScopedAStatus VerifyName(const std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>& in_service, const std::string& in_name, bool* _aidl_return) override; ::ndk::ScopedAStatus GetInterfaceArray(const std::vector& in_names, std::vector>* _aidl_return) override; ::ndk::ScopedAStatus VerifyNamesWithInterfaceArray(const std::vector>& in_services, const std::vector& in_names, bool* _aidl_return) override; ::ndk::ScopedAStatus GetNullableInterfaceArray(const std::optional>>& in_names, std::optional>>* _aidl_return) override; ::ndk::ScopedAStatus VerifyNamesWithNullableInterfaceArray(const std::optional>>& in_services, const std::optional>>& in_names, bool* _aidl_return) override; ::ndk::ScopedAStatus GetInterfaceList(const std::optional>>& in_names, std::optional>>* _aidl_return) override; ::ndk::ScopedAStatus VerifyNamesWithInterfaceList(const std::optional>>& in_services, const std::optional>>& in_names, bool* _aidl_return) override; ::ndk::ScopedAStatus ReverseStringList(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus RepeatParcelFileDescriptor(const ::ndk::ScopedFileDescriptor& in_read, ::ndk::ScopedFileDescriptor* _aidl_return) override; ::ndk::ScopedAStatus ReverseParcelFileDescriptorArray(const std::vector<::ndk::ScopedFileDescriptor>& in_input, std::vector<::ndk::ScopedFileDescriptor>* out_repeated, std::vector<::ndk::ScopedFileDescriptor>* _aidl_return) override; ::ndk::ScopedAStatus ThrowServiceException(int32_t in_code) override; ::ndk::ScopedAStatus RepeatNullableIntArray(const std::optional>& in_input, std::optional>* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableByteEnumArray(const std::optional>& in_input, std::optional>* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableIntEnumArray(const std::optional>& in_input, std::optional>* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableLongEnumArray(const std::optional>& in_input, std::optional>* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableString(const std::optional& in_input, std::optional* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableStringList(const std::optional>>& in_input, std::optional>>* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableParcelable(const std::optional<::aidl::android::aidl::tests::ITestService::Empty>& in_input, std::optional<::aidl::android::aidl::tests::ITestService::Empty>* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableParcelableArray(const std::optional>>& in_input, std::optional>>* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableParcelableList(const std::optional>>& in_input, std::optional>>* _aidl_return) override; ::ndk::ScopedAStatus TakesAnIBinder(const ::ndk::SpAIBinder& in_input) override; ::ndk::ScopedAStatus TakesANullableIBinder(const ::ndk::SpAIBinder& in_input) override; ::ndk::ScopedAStatus TakesAnIBinderList(const std::vector<::ndk::SpAIBinder>& in_input) override; ::ndk::ScopedAStatus TakesANullableIBinderList(const std::optional>& in_input) override; ::ndk::ScopedAStatus RepeatUtf8CppString(const std::string& in_token, std::string* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableUtf8CppString(const std::optional& in_token, std::optional* _aidl_return) override; ::ndk::ScopedAStatus ReverseUtf8CppString(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseNullableUtf8CppString(const std::optional>>& in_input, std::optional>>* out_repeated, std::optional>>* _aidl_return) override; ::ndk::ScopedAStatus ReverseUtf8CppStringList(const std::optional>>& in_input, std::optional>>* out_repeated, std::optional>>* _aidl_return) override; ::ndk::ScopedAStatus GetCallback(bool in_return_null, std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>* _aidl_return) override; ::ndk::ScopedAStatus FillOutStructuredParcelable(::aidl::android::aidl::tests::StructuredParcelable* in_parcel) override; ::ndk::ScopedAStatus RepeatExtendableParcelable(const ::aidl::android::aidl::tests::extension::ExtendableParcelable& in_ep, ::aidl::android::aidl::tests::extension::ExtendableParcelable* out_ep2) override; ::ndk::ScopedAStatus ReverseList(const ::aidl::android::aidl::tests::RecursiveList& in_list, ::aidl::android::aidl::tests::RecursiveList* _aidl_return) override; ::ndk::ScopedAStatus ReverseIBinderArray(const std::vector<::ndk::SpAIBinder>& in_input, std::vector<::ndk::SpAIBinder>* out_repeated, std::vector<::ndk::SpAIBinder>* _aidl_return) override; ::ndk::ScopedAStatus ReverseNullableIBinderArray(const std::optional>& in_input, std::optional>* out_repeated, std::optional>* _aidl_return) override; ::ndk::ScopedAStatus RepeatSimpleParcelable(const ::aidl::android::aidl::tests::SimpleParcelable& in_input, ::aidl::android::aidl::tests::SimpleParcelable* out_repeat, ::aidl::android::aidl::tests::SimpleParcelable* _aidl_return) override; ::ndk::ScopedAStatus ReverseSimpleParcelables(const std::vector<::aidl::android::aidl::tests::SimpleParcelable>& in_input, std::vector<::aidl::android::aidl::tests::SimpleParcelable>* out_repeated, std::vector<::aidl::android::aidl::tests::SimpleParcelable>* _aidl_return) override; ::ndk::ScopedAStatus GetOldNameInterface(std::shared_ptr<::aidl::android::aidl::tests::IOldName>* _aidl_return) override; ::ndk::ScopedAStatus GetNewNameInterface(std::shared_ptr<::aidl::android::aidl::tests::INewName>* _aidl_return) override; ::ndk::ScopedAStatus GetUnionTags(const std::vector<::aidl::android::aidl::tests::Union>& in_input, std::vector<::aidl::android::aidl::tests::Union::Tag>* _aidl_return) override; ::ndk::ScopedAStatus GetCppJavaTests(::ndk::SpAIBinder* _aidl_return) override; ::ndk::ScopedAStatus getBackendType(::aidl::android::aidl::tests::BackendType* _aidl_return) override; ::ndk::ScopedAStatus GetCircular(::aidl::android::aidl::tests::CircularParcelable* out_cp, std::shared_ptr<::aidl::android::aidl::tests::ICircular>* _aidl_return) override; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000215 15172120304 033216 xustar000000000 0000000 113 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpUnion.h 28 mtime=1776853188.6480000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpUnio0100644 0000000 0000000 00000001202 15172120304 032743 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/Union.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/Union.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000223 15172120304 033215 xustar000000000 0000000 119 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpUnionWithFd.h 28 mtime=1776853188.6480000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/BpUnio0100644 0000000 0000000 00000001216 15172120304 032750 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/UnionWithFd.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/UnionWithFd.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000216 15172120304 033217 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/ByteEnum.h 28 mtime=1776853188.6490000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/ByteEn0100644 0000000 0000000 00000003672 15172120304 032752 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ByteEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl */ #pragma once #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { enum class ByteEnum : int8_t { FOO = 1, BAR = 2, BAZ = 3, }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(ByteEnum val) { switch(val) { case ByteEnum::FOO: return "FOO"; case ByteEnum::BAR: return "BAR"; case ByteEnum::BAZ: return "BAZ"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::tests::ByteEnum::FOO, aidl::android::aidl::tests::ByteEnum::BAR, aidl::android::aidl::tests::ByteEnum::BAZ, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000230 15172120304 033213 xustar000000000 0000000 124 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/CircularParcelable.h 28 mtime=1776853188.6490000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/Circul0100644 0000000 0000000 00000004753 15172120304 033006 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/CircularParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl::android::aidl::tests { class ITestService; } // namespace aidl::android::aidl::tests namespace aidl { namespace android { namespace aidl { namespace tests { class CircularParcelable { public: typedef std::false_type fixed_size; static const char* descriptor; std::shared_ptr<::aidl::android::aidl::tests::ITestService> testService; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const CircularParcelable& _rhs) const { return std::tie(testService) == std::tie(_rhs.testService); } inline bool operator<(const CircularParcelable& _rhs) const { return std::tie(testService) < std::tie(_rhs.testService); } inline bool operator!=(const CircularParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const CircularParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const CircularParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const CircularParcelable& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "CircularParcelable{"; _aidl_os << "testService: " << ::android::internal::ToString(testService); _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000234 15172120304 033217 xustar000000000 0000000 128 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/ConstantExpressionEnum.h 28 mtime=1776853188.6490000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/Consta0100644 0000000 0000000 00000005175 15172120304 033013 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ConstantExpressionEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl */ #pragma once #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { enum class ConstantExpressionEnum : int32_t { decInt32_1 = 1, decInt32_2 = 1, decInt64_1 = 1, decInt64_2 = 1, decInt64_3 = 1, decInt64_4 = 1, hexInt32_1 = 1, hexInt32_2 = 1, hexInt32_3 = 1, hexInt64_1 = 1, }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(ConstantExpressionEnum val) { switch(val) { case ConstantExpressionEnum::decInt32_1: return "decInt32_1"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::tests::ConstantExpressionEnum::decInt32_1, aidl::android::aidl::tests::ConstantExpressionEnum::decInt32_2, aidl::android::aidl::tests::ConstantExpressionEnum::decInt64_1, aidl::android::aidl::tests::ConstantExpressionEnum::decInt64_2, aidl::android::aidl::tests::ConstantExpressionEnum::decInt64_3, aidl::android::aidl::tests::ConstantExpressionEnum::decInt64_4, aidl::android::aidl::tests::ConstantExpressionEnum::hexInt32_1, aidl::android::aidl::tests::ConstantExpressionEnum::hexInt32_2, aidl::android::aidl::tests::ConstantExpressionEnum::hexInt32_3, aidl::android::aidl::tests::ConstantExpressionEnum::hexInt64_1, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000224 15172120304 033216 xustar000000000 0000000 120 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/DeprecatedEnum.h 28 mtime=1776853188.6490000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/Deprec0100644 0000000 0000000 00000004305 15172120304 032760 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/DeprecatedEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedEnum.aidl */ #pragma once #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { enum class __attribute__((deprecated("test"))) DeprecatedEnum : int32_t { A = 0, B = 1, C = 2, }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" [[nodiscard]] static inline std::string toString(DeprecatedEnum val) { switch(val) { case DeprecatedEnum::A: return "A"; case DeprecatedEnum::B: return "B"; case DeprecatedEnum::C: return "C"; default: return std::to_string(static_cast(val)); } } #pragma clang diagnostic pop } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" #pragma clang diagnostic ignored "-Wdeprecated-declarations" template <> constexpr inline std::array enum_values = { aidl::android::aidl::tests::DeprecatedEnum::A, aidl::android::aidl::tests::DeprecatedEnum::B, aidl::android::aidl::tests::DeprecatedEnum::C, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000232 15172120304 033215 xustar000000000 0000000 126 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/DeprecatedParcelable.h 28 mtime=1776853188.6490000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/Deprec0100644 0000000 0000000 00000004261 15172120304 032761 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/DeprecatedParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedParcelable.aidl */ #pragma once #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { class __attribute__((deprecated("test"))) DeprecatedParcelable { public: typedef std::false_type fixed_size; static const char* descriptor; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const DeprecatedParcelable&) const { return std::tie() == std::tie(); } inline bool operator<(const DeprecatedParcelable&) const { return std::tie() < std::tie(); } inline bool operator!=(const DeprecatedParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const DeprecatedParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const DeprecatedParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const DeprecatedParcelable& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "DeprecatedParcelable{"; _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000217 15172120304 033220 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/FixedSize.h 28 mtime=1776853188.6490000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/FixedS0100644 0000000 0000000 00000027613 15172120304 032747 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/FixedSize.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/FixedSize.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace aidl { namespace android { namespace aidl { namespace tests { class FixedSize { public: typedef std::false_type fixed_size; static const char* descriptor; class FixedUnion { public: typedef std::true_type fixed_size; static const char* descriptor; enum class Tag : int8_t { booleanValue = 0, byteValue = 1, charValue = 2, intValue = 3, longValue = 4, floatValue = 5, doubleValue = 6, enumValue = 7, }; // Expose tag symbols for legacy code static const inline Tag booleanValue = Tag::booleanValue; static const inline Tag byteValue = Tag::byteValue; static const inline Tag charValue = Tag::charValue; static const inline Tag intValue = Tag::intValue; static const inline Tag longValue = Tag::longValue; static const inline Tag floatValue = Tag::floatValue; static const inline Tag doubleValue = Tag::doubleValue; static const inline Tag enumValue = Tag::enumValue; template using _at = typename std::tuple_element(_Tag), std::tuple>::type; template static FixedUnion make(_Type&& _arg) { FixedUnion _inst; _inst.set<_Tag>(std::forward<_Type>(_arg)); return _inst; } constexpr Tag getTag() const { return _tag; } template const _at<_Tag>& get() const { if (_Tag != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return *(_at<_Tag>*)(&_value); } template _at<_Tag>& get() { if (_Tag != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return *(_at<_Tag>*)(&_value); } template void set(_Type&& _arg) { _tag = _Tag; get<_Tag>() = std::forward<_Type>(_arg); } binder_status_t readFromParcel(const AParcel* _parcel); binder_status_t writeToParcel(AParcel* _parcel) const; static int _cmp(const FixedUnion& _lhs, const FixedUnion& _rhs) { return _cmp_value(_lhs.getTag(), _rhs.getTag()) || _cmp_value_at(_lhs, _rhs); } template static int _cmp_value_at(const FixedUnion& _lhs, const FixedUnion& _rhs) { if constexpr (_Tag == booleanValue) { return _cmp_value(_lhs.get<_Tag>(), _rhs.get<_Tag>()); } else { return (_lhs.getTag() == _Tag) ? _cmp_value(_lhs.get<_Tag>(), _rhs.get<_Tag>()) : _cmp_value_at(static_cast(_Tag)-1)>(_lhs, _rhs); } } template static int _cmp_value(const _Type& _lhs, const _Type& _rhs) { return (_lhs == _rhs) ? 0 : (_lhs < _rhs) ? -1 : 1; } inline bool operator!=(const FixedUnion&_rhs) const { return _cmp(*this, _rhs) != 0; } inline bool operator<(const FixedUnion&_rhs) const { return _cmp(*this, _rhs) < 0; } inline bool operator<=(const FixedUnion&_rhs) const { return _cmp(*this, _rhs) <= 0; } inline bool operator==(const FixedUnion&_rhs) const { return _cmp(*this, _rhs) == 0; } inline bool operator>(const FixedUnion&_rhs) const { return _cmp(*this, _rhs) > 0; } inline bool operator>=(const FixedUnion&_rhs) const { return _cmp(*this, _rhs) >= 0; } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream os; os << "FixedUnion{"; switch (getTag()) { case booleanValue: os << "booleanValue: " << ::android::internal::ToString(get()); break; case byteValue: os << "byteValue: " << ::android::internal::ToString(get()); break; case charValue: os << "charValue: " << ::android::internal::ToString(get()); break; case intValue: os << "intValue: " << ::android::internal::ToString(get()); break; case longValue: os << "longValue: " << ::android::internal::ToString(get()); break; case floatValue: os << "floatValue: " << ::android::internal::ToString(get()); break; case doubleValue: os << "doubleValue: " << ::android::internal::ToString(get()); break; case enumValue: os << "enumValue: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: Tag _tag = booleanValue; union _value_t { _value_t() {} ~_value_t() {} bool booleanValue __attribute__((aligned (1))) = bool(false); int8_t byteValue __attribute__((aligned (1))); char16_t charValue __attribute__((aligned (2))); int32_t intValue __attribute__((aligned (4))); int64_t longValue __attribute__((aligned (8))); float floatValue __attribute__((aligned (4))); double doubleValue __attribute__((aligned (8))); ::aidl::android::aidl::tests::LongEnum enumValue __attribute__((aligned (8))); } _value; }; class FixedParcelable { public: typedef std::true_type fixed_size; static const char* descriptor; bool booleanValue __attribute__((aligned (1))) = false; int8_t byteValue __attribute__((aligned (1))) = 0; char16_t charValue __attribute__((aligned (2))) = '\0'; int32_t intValue __attribute__((aligned (4))) = 0; int64_t longValue __attribute__((aligned (8))) = 0L; float floatValue __attribute__((aligned (4))) = 0.000000f; double doubleValue __attribute__((aligned (8))) = 0.000000; ::aidl::android::aidl::tests::LongEnum enumValue __attribute__((aligned (8))) = ::aidl::android::aidl::tests::LongEnum::FOO; ::aidl::android::aidl::tests::FixedSize::FixedUnion parcelableValue; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const FixedParcelable& _rhs) const { return std::tie(booleanValue, byteValue, charValue, intValue, longValue, floatValue, doubleValue, enumValue, parcelableValue) == std::tie(_rhs.booleanValue, _rhs.byteValue, _rhs.charValue, _rhs.intValue, _rhs.longValue, _rhs.floatValue, _rhs.doubleValue, _rhs.enumValue, _rhs.parcelableValue); } inline bool operator<(const FixedParcelable& _rhs) const { return std::tie(booleanValue, byteValue, charValue, intValue, longValue, floatValue, doubleValue, enumValue, parcelableValue) < std::tie(_rhs.booleanValue, _rhs.byteValue, _rhs.charValue, _rhs.intValue, _rhs.longValue, _rhs.floatValue, _rhs.doubleValue, _rhs.enumValue, _rhs.parcelableValue); } inline bool operator!=(const FixedParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const FixedParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const FixedParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const FixedParcelable& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "FixedParcelable{"; _aidl_os << "booleanValue: " << ::android::internal::ToString(booleanValue); _aidl_os << ", byteValue: " << ::android::internal::ToString(byteValue); _aidl_os << ", charValue: " << ::android::internal::ToString(charValue); _aidl_os << ", intValue: " << ::android::internal::ToString(intValue); _aidl_os << ", longValue: " << ::android::internal::ToString(longValue); _aidl_os << ", floatValue: " << ::android::internal::ToString(floatValue); _aidl_os << ", doubleValue: " << ::android::internal::ToString(doubleValue); _aidl_os << ", enumValue: " << ::android::internal::ToString(enumValue); _aidl_os << ", parcelableValue: " << ::android::internal::ToString(parcelableValue); _aidl_os << "}"; return _aidl_os.str(); } }; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const FixedSize&) const { return std::tie() == std::tie(); } inline bool operator<(const FixedSize&) const { return std::tie() < std::tie(); } inline bool operator!=(const FixedSize& _rhs) const { return !(*this == _rhs); } inline bool operator>(const FixedSize& _rhs) const { return _rhs < *this; } inline bool operator>=(const FixedSize& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const FixedSize& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "FixedSize{"; _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(FixedSize::FixedUnion::Tag val) { switch(val) { case FixedSize::FixedUnion::Tag::booleanValue: return "booleanValue"; case FixedSize::FixedUnion::Tag::byteValue: return "byteValue"; case FixedSize::FixedUnion::Tag::charValue: return "charValue"; case FixedSize::FixedUnion::Tag::intValue: return "intValue"; case FixedSize::FixedUnion::Tag::longValue: return "longValue"; case FixedSize::FixedUnion::Tag::floatValue: return "floatValue"; case FixedSize::FixedUnion::Tag::doubleValue: return "doubleValue"; case FixedSize::FixedUnion::Tag::enumValue: return "enumValue"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::tests::FixedSize::FixedUnion::Tag::booleanValue, aidl::android::aidl::tests::FixedSize::FixedUnion::Tag::byteValue, aidl::android::aidl::tests::FixedSize::FixedUnion::Tag::charValue, aidl::android::aidl::tests::FixedSize::FixedUnion::Tag::intValue, aidl::android::aidl::tests::FixedSize::FixedUnion::Tag::longValue, aidl::android::aidl::tests::FixedSize::FixedUnion::Tag::floatValue, aidl::android::aidl::tests::FixedSize::FixedUnion::Tag::doubleValue, aidl::android::aidl::tests::FixedSize::FixedUnion::Tag::enumValue, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000241 15172120304 033215 xustar000000000 0000000 133 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/GenericStructuredParcelable.h 28 mtime=1776853188.6500000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/Generi0100644 0000000 0000000 00000012110 15172120304 032760 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/GenericStructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl */ #pragma once #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { template class GenericStructuredParcelable { public: typedef std::false_type fixed_size; static const char* descriptor; int32_t a = 0; int32_t b = 0; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const GenericStructuredParcelable& _rhs) const { return std::tie(a, b) == std::tie(_rhs.a, _rhs.b); } inline bool operator<(const GenericStructuredParcelable& _rhs) const { return std::tie(a, b) < std::tie(_rhs.a, _rhs.b); } inline bool operator!=(const GenericStructuredParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const GenericStructuredParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const GenericStructuredParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const GenericStructuredParcelable& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "GenericStructuredParcelable{"; _aidl_os << "a: " << ::android::internal::ToString(a); _aidl_os << ", b: " << ::android::internal::ToString(b); _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl #include "aidl/android/aidl/tests/GenericStructuredParcelable.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { template const char* GenericStructuredParcelable::descriptor = "android.aidl.tests.GenericStructuredParcelable"; template binder_status_t GenericStructuredParcelable::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &a); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &b); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } template binder_status_t GenericStructuredParcelable::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, a); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, b); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000217 15172120304 033220 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/ICircular.h 28 mtime=1776853188.6500000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/ICircu0100644 0000000 0000000 00000004367 15172120304 032744 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ICircular.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ICircular.aidl */ #pragma once #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl::android::aidl::tests { class ITestService; } // namespace aidl::android::aidl::tests namespace aidl { namespace android { namespace aidl { namespace tests { class ICircularDelegator; class ICircular : public ::ndk::ICInterface { public: typedef ICircularDelegator DefaultDelegator; static const char* descriptor; ICircular(); virtual ~ICircular(); static constexpr uint32_t TRANSACTION_GetTestService = FIRST_CALL_TRANSACTION + 0; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus GetTestService(std::shared_ptr<::aidl::android::aidl::tests::ITestService>* _aidl_return) = 0; private: static std::shared_ptr default_impl; }; class ICircularDefault : public ICircular { public: ::ndk::ScopedAStatus GetTestService(std::shared_ptr<::aidl::android::aidl::tests::ITestService>* _aidl_return) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000221 15172120304 033213 xustar000000000 0000000 117 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/IDeprecated.h 28 mtime=1776853188.6510000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/IDepre0100644 0000000 0000000 00000003567 15172120304 032737 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/IDeprecated.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IDeprecated.aidl */ #pragma once #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { class IDeprecatedDelegator; class __attribute__((deprecated("test"))) IDeprecated : public ::ndk::ICInterface { public: typedef IDeprecatedDelegator DefaultDelegator; static const char* descriptor; IDeprecated(); virtual ~IDeprecated(); static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); private: static std::shared_ptr default_impl; }; class __attribute__((deprecated("test"))) IDeprecatedDefault : public IDeprecated { public: ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000224 15172120304 033216 xustar000000000 0000000 120 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/INamedCallback.h 28 mtime=1776853188.6510000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/INamed0100644 0000000 0000000 00000004065 15172120304 032716 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/INamedCallback.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl */ #pragma once #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { class INamedCallbackDelegator; class INamedCallback : public ::ndk::ICInterface { public: typedef INamedCallbackDelegator DefaultDelegator; static const char* descriptor; INamedCallback(); virtual ~INamedCallback(); static constexpr uint32_t TRANSACTION_GetName = FIRST_CALL_TRANSACTION + 0; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus GetName(std::string* _aidl_return) = 0; private: static std::shared_ptr default_impl; }; class INamedCallbackDefault : public INamedCallback { public: ::ndk::ScopedAStatus GetName(std::string* _aidl_return) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000216 15172120304 033217 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/INewName.h 28 mtime=1776853188.6510000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/INewNa0100644 0000000 0000000 00000003736 15172120304 032706 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/INewName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INewName.aidl */ #pragma once #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { class INewNameDelegator; class INewName : public ::ndk::ICInterface { public: typedef INewNameDelegator DefaultDelegator; static const char* descriptor; INewName(); virtual ~INewName(); static constexpr uint32_t TRANSACTION_RealName = FIRST_CALL_TRANSACTION + 0; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus RealName(std::string* _aidl_return) = 0; private: static std::shared_ptr default_impl; }; class INewNameDefault : public INewName { public: ::ndk::ScopedAStatus RealName(std::string* _aidl_return) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000216 15172120304 033217 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/IOldName.h 28 mtime=1776853188.6510000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/IOldNa0100644 0000000 0000000 00000003736 15172120304 032673 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/IOldName.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IOldName.aidl */ #pragma once #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { class IOldNameDelegator; class IOldName : public ::ndk::ICInterface { public: typedef IOldNameDelegator DefaultDelegator; static const char* descriptor; IOldName(); virtual ~IOldName(); static constexpr uint32_t TRANSACTION_RealName = FIRST_CALL_TRANSACTION + 0; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus RealName(std::string* _aidl_return) = 0; private: static std::shared_ptr default_impl; }; class IOldNameDefault : public IOldName { public: ::ndk::ScopedAStatus RealName(std::string* _aidl_return) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000222 15172120304 033214 xustar000000000 0000000 118 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/ITestService.h 28 mtime=1776853188.6510000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/ITestS0100644 0000000 0000000 00000153104 15172120304 032733 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ITestService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ITestService.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace aidl::android::aidl::tests { class CircularParcelable; class ICircular; class INamedCallback; class INewName; class IOldName; class RecursiveList; class StructuredParcelable; } // namespace aidl::android::aidl::tests namespace aidl::android::aidl::tests::extension { class ExtendableParcelable; } // namespace aidl::android::aidl::tests::extension namespace aidl { namespace android { namespace aidl { namespace tests { class ITestServiceDelegator; class ITestService : public ::ndk::ICInterface { public: typedef ITestServiceDelegator DefaultDelegator; static const char* descriptor; ITestService(); virtual ~ITestService(); class Empty { public: typedef std::false_type fixed_size; static const char* descriptor; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const Empty&) const { return std::tie() == std::tie(); } inline bool operator<(const Empty&) const { return std::tie() < std::tie(); } inline bool operator!=(const Empty& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Empty& _rhs) const { return _rhs < *this; } inline bool operator>=(const Empty& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Empty& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "Empty{"; _aidl_os << "}"; return _aidl_os.str(); } }; class CompilerChecks { public: typedef std::false_type fixed_size; static const char* descriptor; class IFooDelegator; class IFoo : public ::ndk::ICInterface { public: typedef IFooDelegator DefaultDelegator; static const char* descriptor; IFoo(); virtual ~IFoo(); static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); private: static std::shared_ptr default_impl; }; class IFooDefault : public IFoo { public: ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; class BpFoo : public ::ndk::BpCInterface { public: explicit BpFoo(const ::ndk::SpAIBinder& binder); virtual ~BpFoo(); }; class BnFoo : public ::ndk::BnCInterface { public: BnFoo(); virtual ~BnFoo(); protected: ::ndk::SpAIBinder createBinder() override; private: }; #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" class HasDeprecated { public: typedef std::false_type fixed_size; static const char* descriptor; int32_t __attribute__((deprecated("field"))) deprecated = 0; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const HasDeprecated& _rhs) const { return std::tie(deprecated) == std::tie(_rhs.deprecated); } inline bool operator<(const HasDeprecated& _rhs) const { return std::tie(deprecated) < std::tie(_rhs.deprecated); } inline bool operator!=(const HasDeprecated& _rhs) const { return !(*this == _rhs); } inline bool operator>(const HasDeprecated& _rhs) const { return _rhs < *this; } inline bool operator>=(const HasDeprecated& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const HasDeprecated& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "HasDeprecated{"; _aidl_os << "deprecated: " << ::android::internal::ToString(deprecated); _aidl_os << "}"; return _aidl_os.str(); } }; #pragma clang diagnostic pop class UsingHasDeprecated { public: typedef std::false_type fixed_size; static const char* descriptor; enum class Tag : int32_t { n = 0, m = 1, }; // Expose tag symbols for legacy code static const inline Tag n = Tag::n; static const inline Tag m = Tag::m; template static constexpr bool _not_self = !std::is_same_v>, UsingHasDeprecated>; UsingHasDeprecated() : _value(std::in_place_index(n)>, int32_t(0)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr UsingHasDeprecated(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit UsingHasDeprecated(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static UsingHasDeprecated make(_Tp&&... _args) { return UsingHasDeprecated(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static UsingHasDeprecated make(std::initializer_list<_Tp> _il, _Up&&... _args) { return UsingHasDeprecated(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } binder_status_t readFromParcel(const AParcel* _parcel); binder_status_t writeToParcel(AParcel* _parcel) const; inline bool operator==(const UsingHasDeprecated& _rhs) const { return _value == _rhs._value; } inline bool operator<(const UsingHasDeprecated& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const UsingHasDeprecated& _rhs) const { return !(*this == _rhs); } inline bool operator>(const UsingHasDeprecated& _rhs) const { return _rhs < *this; } inline bool operator>=(const UsingHasDeprecated& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const UsingHasDeprecated& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream os; os << "UsingHasDeprecated{"; switch (getTag()) { case n: os << "n: " << ::android::internal::ToString(get()); break; case m: os << "m: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant _value; }; class INoPrefixInterfaceDelegator; class INoPrefixInterface : public ::ndk::ICInterface { public: typedef INoPrefixInterfaceDelegator DefaultDelegator; static const char* descriptor; INoPrefixInterface(); virtual ~INoPrefixInterface(); class Nested { public: typedef std::false_type fixed_size; static const char* descriptor; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const Nested&) const { return std::tie() == std::tie(); } inline bool operator<(const Nested&) const { return std::tie() < std::tie(); } inline bool operator!=(const Nested& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Nested& _rhs) const { return _rhs < *this; } inline bool operator>=(const Nested& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Nested& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "Nested{"; _aidl_os << "}"; return _aidl_os.str(); } }; class INestedNoPrefixInterfaceDelegator; class INestedNoPrefixInterface : public ::ndk::ICInterface { public: typedef INestedNoPrefixInterfaceDelegator DefaultDelegator; static const char* descriptor; INestedNoPrefixInterface(); virtual ~INestedNoPrefixInterface(); static constexpr uint32_t TRANSACTION_foo = FIRST_CALL_TRANSACTION + 0; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus foo() = 0; private: static std::shared_ptr default_impl; }; class INestedNoPrefixInterfaceDefault : public INestedNoPrefixInterface { public: ::ndk::ScopedAStatus foo() override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; class BpNestedNoPrefixInterface : public ::ndk::BpCInterface { public: explicit BpNestedNoPrefixInterface(const ::ndk::SpAIBinder& binder); virtual ~BpNestedNoPrefixInterface(); ::ndk::ScopedAStatus foo() override; }; class BnNestedNoPrefixInterface : public ::ndk::BnCInterface { public: BnNestedNoPrefixInterface(); virtual ~BnNestedNoPrefixInterface(); protected: ::ndk::SpAIBinder createBinder() override; private: }; static constexpr uint32_t TRANSACTION_foo = FIRST_CALL_TRANSACTION + 0; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus foo() = 0; private: static std::shared_ptr default_impl; }; class INoPrefixInterfaceDefault : public INoPrefixInterface { public: ::ndk::ScopedAStatus foo() override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; class BpNoPrefixInterface : public ::ndk::BpCInterface { public: explicit BpNoPrefixInterface(const ::ndk::SpAIBinder& binder); virtual ~BpNoPrefixInterface(); ::ndk::ScopedAStatus foo() override; }; class BnNoPrefixInterface : public ::ndk::BnCInterface { public: BnNoPrefixInterface(); virtual ~BnNoPrefixInterface(); protected: ::ndk::SpAIBinder createBinder() override; private: }; ::ndk::SpAIBinder binder; ::ndk::SpAIBinder nullable_binder; std::vector<::ndk::SpAIBinder> binder_array; std::optional> nullable_binder_array; std::vector<::ndk::SpAIBinder> binder_list; std::optional> nullable_binder_list; ::ndk::ScopedFileDescriptor pfd; ::ndk::ScopedFileDescriptor nullable_pfd; std::vector<::ndk::ScopedFileDescriptor> pfd_array; std::optional> nullable_pfd_array; std::vector<::ndk::ScopedFileDescriptor> pfd_list; std::optional> nullable_pfd_list; ::aidl::android::aidl::tests::ITestService::Empty parcel; std::optional<::aidl::android::aidl::tests::ITestService::Empty> nullable_parcel; std::vector<::aidl::android::aidl::tests::ITestService::Empty> parcel_array; std::optional>> nullable_parcel_array; std::vector<::aidl::android::aidl::tests::ITestService::Empty> parcel_list; std::optional>> nullable_parcel_list; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const CompilerChecks& _rhs) const { return std::tie(binder, nullable_binder, binder_array, nullable_binder_array, binder_list, nullable_binder_list, pfd, nullable_pfd, pfd_array, nullable_pfd_array, pfd_list, nullable_pfd_list, parcel, nullable_parcel, parcel_array, nullable_parcel_array, parcel_list, nullable_parcel_list) == std::tie(_rhs.binder, _rhs.nullable_binder, _rhs.binder_array, _rhs.nullable_binder_array, _rhs.binder_list, _rhs.nullable_binder_list, _rhs.pfd, _rhs.nullable_pfd, _rhs.pfd_array, _rhs.nullable_pfd_array, _rhs.pfd_list, _rhs.nullable_pfd_list, _rhs.parcel, _rhs.nullable_parcel, _rhs.parcel_array, _rhs.nullable_parcel_array, _rhs.parcel_list, _rhs.nullable_parcel_list); } inline bool operator<(const CompilerChecks& _rhs) const { return std::tie(binder, nullable_binder, binder_array, nullable_binder_array, binder_list, nullable_binder_list, pfd, nullable_pfd, pfd_array, nullable_pfd_array, pfd_list, nullable_pfd_list, parcel, nullable_parcel, parcel_array, nullable_parcel_array, parcel_list, nullable_parcel_list) < std::tie(_rhs.binder, _rhs.nullable_binder, _rhs.binder_array, _rhs.nullable_binder_array, _rhs.binder_list, _rhs.nullable_binder_list, _rhs.pfd, _rhs.nullable_pfd, _rhs.pfd_array, _rhs.nullable_pfd_array, _rhs.pfd_list, _rhs.nullable_pfd_list, _rhs.parcel, _rhs.nullable_parcel, _rhs.parcel_array, _rhs.nullable_parcel_array, _rhs.parcel_list, _rhs.nullable_parcel_list); } inline bool operator!=(const CompilerChecks& _rhs) const { return !(*this == _rhs); } inline bool operator>(const CompilerChecks& _rhs) const { return _rhs < *this; } inline bool operator>=(const CompilerChecks& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const CompilerChecks& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "CompilerChecks{"; _aidl_os << "binder: " << ::android::internal::ToString(binder); _aidl_os << ", nullable_binder: " << ::android::internal::ToString(nullable_binder); _aidl_os << ", binder_array: " << ::android::internal::ToString(binder_array); _aidl_os << ", nullable_binder_array: " << ::android::internal::ToString(nullable_binder_array); _aidl_os << ", binder_list: " << ::android::internal::ToString(binder_list); _aidl_os << ", nullable_binder_list: " << ::android::internal::ToString(nullable_binder_list); _aidl_os << ", pfd: " << ::android::internal::ToString(pfd); _aidl_os << ", nullable_pfd: " << ::android::internal::ToString(nullable_pfd); _aidl_os << ", pfd_array: " << ::android::internal::ToString(pfd_array); _aidl_os << ", nullable_pfd_array: " << ::android::internal::ToString(nullable_pfd_array); _aidl_os << ", pfd_list: " << ::android::internal::ToString(pfd_list); _aidl_os << ", nullable_pfd_list: " << ::android::internal::ToString(nullable_pfd_list); _aidl_os << ", parcel: " << ::android::internal::ToString(parcel); _aidl_os << ", nullable_parcel: " << ::android::internal::ToString(nullable_parcel); _aidl_os << ", parcel_array: " << ::android::internal::ToString(parcel_array); _aidl_os << ", nullable_parcel_array: " << ::android::internal::ToString(nullable_parcel_array); _aidl_os << ", parcel_list: " << ::android::internal::ToString(parcel_list); _aidl_os << ", nullable_parcel_list: " << ::android::internal::ToString(nullable_parcel_list); _aidl_os << "}"; return _aidl_os.str(); } }; enum : int32_t { CONSTANT = 42 }; enum : int32_t { CONSTANT2 = -42 }; enum : int32_t { CONSTANT3 = 42 }; enum : int32_t { CONSTANT4 = 4 }; enum : int32_t { CONSTANT5 = -4 }; enum : int32_t { CONSTANT6 = 0 }; enum : int32_t { CONSTANT7 = 0 }; enum : int32_t { CONSTANT8 = 0 }; enum : int32_t { CONSTANT9 = 86 }; enum : int32_t { CONSTANT10 = 165 }; enum : int32_t { CONSTANT11 = 250 }; enum : int32_t { CONSTANT12 = -1 }; enum : int8_t { BYTE_CONSTANT = 17 }; enum : int64_t { LONG_CONSTANT = 1099511627776L }; static const char* STRING_CONSTANT; static const char* STRING_CONSTANT2; static constexpr float FLOAT_CONSTANT = 1.000000f; static constexpr float FLOAT_CONSTANT2 = -1.000000f; static constexpr float FLOAT_CONSTANT3 = 1.000000f; static constexpr float FLOAT_CONSTANT4 = 2.200000f; static constexpr float FLOAT_CONSTANT5 = -2.200000f; static constexpr float FLOAT_CONSTANT6 = -0.000000f; static constexpr float FLOAT_CONSTANT7 = 0.000000f; static constexpr double DOUBLE_CONSTANT = 1.000000; static constexpr double DOUBLE_CONSTANT2 = -1.000000; static constexpr double DOUBLE_CONSTANT3 = 1.000000; static constexpr double DOUBLE_CONSTANT4 = 2.200000; static constexpr double DOUBLE_CONSTANT5 = -2.200000; static constexpr double DOUBLE_CONSTANT6 = -0.000000; static constexpr double DOUBLE_CONSTANT7 = 0.000000; static constexpr double DOUBLE_CONSTANT8 = 1.100000; static constexpr double DOUBLE_CONSTANT9 = -1.100000; static const char* STRING_CONSTANT_UTF8; enum : int32_t { A1 = 1 }; enum : int32_t { A2 = 1 }; enum : int32_t { A3 = 1 }; enum : int32_t { A4 = 1 }; enum : int32_t { A5 = 1 }; enum : int32_t { A6 = 1 }; enum : int32_t { A7 = 1 }; enum : int32_t { A8 = 1 }; enum : int32_t { A9 = 1 }; enum : int32_t { A10 = 1 }; enum : int32_t { A11 = 1 }; enum : int32_t { A12 = 1 }; enum : int32_t { A13 = 1 }; enum : int32_t { A14 = 1 }; enum : int32_t { A15 = 1 }; enum : int32_t { A16 = 1 }; enum : int32_t { A17 = 1 }; enum : int32_t { A18 = 1 }; enum : int32_t { A19 = 1 }; enum : int32_t { A20 = 1 }; enum : int32_t { A21 = 1 }; enum : int32_t { A22 = 1 }; enum : int32_t { A23 = 1 }; enum : int32_t { A24 = 1 }; enum : int32_t { A25 = 1 }; enum : int32_t { A26 = 1 }; enum : int32_t { A27 = 1 }; enum : int32_t { A28 = 1 }; enum : int32_t { A29 = 1 }; enum : int32_t { A30 = 1 }; enum : int32_t { A31 = 1 }; enum : int32_t { A32 = 1 }; enum : int32_t { A33 = 1 }; enum : int32_t { A34 = 1 }; enum : int32_t { A35 = 1 }; enum : int32_t { A36 = 1 }; enum : int32_t { A37 = 1 }; enum : int32_t { A38 = 1 }; enum : int32_t { A39 = 1 }; enum : int32_t { A40 = 1 }; enum : int32_t { A41 = 1 }; enum : int32_t { A42 = 1 }; enum : int32_t { A43 = 1 }; enum : int32_t { A44 = 1 }; enum : int32_t { A45 = 1 }; enum : int32_t { A46 = 1 }; enum : int32_t { A47 = 1 }; enum : int32_t { A48 = 1 }; enum : int32_t { A49 = 1 }; enum : int32_t { A50 = 1 }; enum : int32_t { A51 = 1 }; enum : int32_t { A52 = 1 }; enum : int32_t { A53 = 1 }; enum : int32_t { A54 = 1 }; enum : int32_t { A55 = 1 }; enum : int32_t { A56 = 1 }; enum : int32_t { A57 = 1 }; static constexpr uint32_t TRANSACTION_UnimplementedMethod = FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_Deprecated = FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_TestOneway = FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_RepeatBoolean = FIRST_CALL_TRANSACTION + 3; static constexpr uint32_t TRANSACTION_RepeatByte = FIRST_CALL_TRANSACTION + 4; static constexpr uint32_t TRANSACTION_RepeatChar = FIRST_CALL_TRANSACTION + 5; static constexpr uint32_t TRANSACTION_RepeatInt = FIRST_CALL_TRANSACTION + 6; static constexpr uint32_t TRANSACTION_RepeatLong = FIRST_CALL_TRANSACTION + 7; static constexpr uint32_t TRANSACTION_RepeatFloat = FIRST_CALL_TRANSACTION + 8; static constexpr uint32_t TRANSACTION_RepeatDouble = FIRST_CALL_TRANSACTION + 9; static constexpr uint32_t TRANSACTION_RepeatString = FIRST_CALL_TRANSACTION + 10; static constexpr uint32_t TRANSACTION_RepeatByteEnum = FIRST_CALL_TRANSACTION + 11; static constexpr uint32_t TRANSACTION_RepeatIntEnum = FIRST_CALL_TRANSACTION + 12; static constexpr uint32_t TRANSACTION_RepeatLongEnum = FIRST_CALL_TRANSACTION + 13; static constexpr uint32_t TRANSACTION_ReverseBoolean = FIRST_CALL_TRANSACTION + 14; static constexpr uint32_t TRANSACTION_ReverseByte = FIRST_CALL_TRANSACTION + 15; static constexpr uint32_t TRANSACTION_ReverseChar = FIRST_CALL_TRANSACTION + 16; static constexpr uint32_t TRANSACTION_ReverseInt = FIRST_CALL_TRANSACTION + 17; static constexpr uint32_t TRANSACTION_ReverseLong = FIRST_CALL_TRANSACTION + 18; static constexpr uint32_t TRANSACTION_ReverseFloat = FIRST_CALL_TRANSACTION + 19; static constexpr uint32_t TRANSACTION_ReverseDouble = FIRST_CALL_TRANSACTION + 20; static constexpr uint32_t TRANSACTION_ReverseString = FIRST_CALL_TRANSACTION + 21; static constexpr uint32_t TRANSACTION_ReverseByteEnum = FIRST_CALL_TRANSACTION + 22; static constexpr uint32_t TRANSACTION_ReverseIntEnum = FIRST_CALL_TRANSACTION + 23; static constexpr uint32_t TRANSACTION_ReverseLongEnum = FIRST_CALL_TRANSACTION + 24; static constexpr uint32_t TRANSACTION_GetOtherTestService = FIRST_CALL_TRANSACTION + 25; static constexpr uint32_t TRANSACTION_SetOtherTestService = FIRST_CALL_TRANSACTION + 26; static constexpr uint32_t TRANSACTION_VerifyName = FIRST_CALL_TRANSACTION + 27; static constexpr uint32_t TRANSACTION_GetInterfaceArray = FIRST_CALL_TRANSACTION + 28; static constexpr uint32_t TRANSACTION_VerifyNamesWithInterfaceArray = FIRST_CALL_TRANSACTION + 29; static constexpr uint32_t TRANSACTION_GetNullableInterfaceArray = FIRST_CALL_TRANSACTION + 30; static constexpr uint32_t TRANSACTION_VerifyNamesWithNullableInterfaceArray = FIRST_CALL_TRANSACTION + 31; static constexpr uint32_t TRANSACTION_GetInterfaceList = FIRST_CALL_TRANSACTION + 32; static constexpr uint32_t TRANSACTION_VerifyNamesWithInterfaceList = FIRST_CALL_TRANSACTION + 33; static constexpr uint32_t TRANSACTION_ReverseStringList = FIRST_CALL_TRANSACTION + 34; static constexpr uint32_t TRANSACTION_RepeatParcelFileDescriptor = FIRST_CALL_TRANSACTION + 35; static constexpr uint32_t TRANSACTION_ReverseParcelFileDescriptorArray = FIRST_CALL_TRANSACTION + 36; static constexpr uint32_t TRANSACTION_ThrowServiceException = FIRST_CALL_TRANSACTION + 37; static constexpr uint32_t TRANSACTION_RepeatNullableIntArray = FIRST_CALL_TRANSACTION + 38; static constexpr uint32_t TRANSACTION_RepeatNullableByteEnumArray = FIRST_CALL_TRANSACTION + 39; static constexpr uint32_t TRANSACTION_RepeatNullableIntEnumArray = FIRST_CALL_TRANSACTION + 40; static constexpr uint32_t TRANSACTION_RepeatNullableLongEnumArray = FIRST_CALL_TRANSACTION + 41; static constexpr uint32_t TRANSACTION_RepeatNullableString = FIRST_CALL_TRANSACTION + 42; static constexpr uint32_t TRANSACTION_RepeatNullableStringList = FIRST_CALL_TRANSACTION + 43; static constexpr uint32_t TRANSACTION_RepeatNullableParcelable = FIRST_CALL_TRANSACTION + 44; static constexpr uint32_t TRANSACTION_RepeatNullableParcelableArray = FIRST_CALL_TRANSACTION + 45; static constexpr uint32_t TRANSACTION_RepeatNullableParcelableList = FIRST_CALL_TRANSACTION + 46; static constexpr uint32_t TRANSACTION_TakesAnIBinder = FIRST_CALL_TRANSACTION + 47; static constexpr uint32_t TRANSACTION_TakesANullableIBinder = FIRST_CALL_TRANSACTION + 48; static constexpr uint32_t TRANSACTION_TakesAnIBinderList = FIRST_CALL_TRANSACTION + 49; static constexpr uint32_t TRANSACTION_TakesANullableIBinderList = FIRST_CALL_TRANSACTION + 50; static constexpr uint32_t TRANSACTION_RepeatUtf8CppString = FIRST_CALL_TRANSACTION + 51; static constexpr uint32_t TRANSACTION_RepeatNullableUtf8CppString = FIRST_CALL_TRANSACTION + 52; static constexpr uint32_t TRANSACTION_ReverseUtf8CppString = FIRST_CALL_TRANSACTION + 53; static constexpr uint32_t TRANSACTION_ReverseNullableUtf8CppString = FIRST_CALL_TRANSACTION + 54; static constexpr uint32_t TRANSACTION_ReverseUtf8CppStringList = FIRST_CALL_TRANSACTION + 55; static constexpr uint32_t TRANSACTION_GetCallback = FIRST_CALL_TRANSACTION + 56; static constexpr uint32_t TRANSACTION_FillOutStructuredParcelable = FIRST_CALL_TRANSACTION + 57; static constexpr uint32_t TRANSACTION_RepeatExtendableParcelable = FIRST_CALL_TRANSACTION + 58; static constexpr uint32_t TRANSACTION_ReverseList = FIRST_CALL_TRANSACTION + 59; static constexpr uint32_t TRANSACTION_ReverseIBinderArray = FIRST_CALL_TRANSACTION + 60; static constexpr uint32_t TRANSACTION_ReverseNullableIBinderArray = FIRST_CALL_TRANSACTION + 61; static constexpr uint32_t TRANSACTION_RepeatSimpleParcelable = FIRST_CALL_TRANSACTION + 62; static constexpr uint32_t TRANSACTION_ReverseSimpleParcelables = FIRST_CALL_TRANSACTION + 63; static constexpr uint32_t TRANSACTION_GetOldNameInterface = FIRST_CALL_TRANSACTION + 64; static constexpr uint32_t TRANSACTION_GetNewNameInterface = FIRST_CALL_TRANSACTION + 65; static constexpr uint32_t TRANSACTION_GetUnionTags = FIRST_CALL_TRANSACTION + 66; static constexpr uint32_t TRANSACTION_GetCppJavaTests = FIRST_CALL_TRANSACTION + 67; static constexpr uint32_t TRANSACTION_getBackendType = FIRST_CALL_TRANSACTION + 68; static constexpr uint32_t TRANSACTION_GetCircular = FIRST_CALL_TRANSACTION + 69; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus UnimplementedMethod(int32_t in_arg, int32_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus Deprecated() __attribute__((deprecated("to make sure we have something in system/tools/aidl which does a compile check of deprecated and make sure this is reflected in goldens"))) = 0; virtual ::ndk::ScopedAStatus TestOneway() = 0; virtual ::ndk::ScopedAStatus RepeatBoolean(bool in_token, bool* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatByte(int8_t in_token, int8_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatChar(char16_t in_token, char16_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatInt(int32_t in_token, int32_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatLong(int64_t in_token, int64_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatFloat(float in_token, float* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatDouble(double in_token, double* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatString(const std::string& in_token, std::string* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatByteEnum(::aidl::android::aidl::tests::ByteEnum in_token, ::aidl::android::aidl::tests::ByteEnum* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatIntEnum(::aidl::android::aidl::tests::IntEnum in_token, ::aidl::android::aidl::tests::IntEnum* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatLongEnum(::aidl::android::aidl::tests::LongEnum in_token, ::aidl::android::aidl::tests::LongEnum* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseBoolean(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseByte(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseChar(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseInt(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseLong(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseFloat(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseDouble(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseString(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseByteEnum(const std::vector<::aidl::android::aidl::tests::ByteEnum>& in_input, std::vector<::aidl::android::aidl::tests::ByteEnum>* out_repeated, std::vector<::aidl::android::aidl::tests::ByteEnum>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseIntEnum(const std::vector<::aidl::android::aidl::tests::IntEnum>& in_input, std::vector<::aidl::android::aidl::tests::IntEnum>* out_repeated, std::vector<::aidl::android::aidl::tests::IntEnum>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseLongEnum(const std::vector<::aidl::android::aidl::tests::LongEnum>& in_input, std::vector<::aidl::android::aidl::tests::LongEnum>* out_repeated, std::vector<::aidl::android::aidl::tests::LongEnum>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus GetOtherTestService(const std::string& in_name, std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus SetOtherTestService(const std::string& in_name, const std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>& in_service, bool* _aidl_return) = 0; virtual ::ndk::ScopedAStatus VerifyName(const std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>& in_service, const std::string& in_name, bool* _aidl_return) = 0; virtual ::ndk::ScopedAStatus GetInterfaceArray(const std::vector& in_names, std::vector>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus VerifyNamesWithInterfaceArray(const std::vector>& in_services, const std::vector& in_names, bool* _aidl_return) = 0; virtual ::ndk::ScopedAStatus GetNullableInterfaceArray(const std::optional>>& in_names, std::optional>>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus VerifyNamesWithNullableInterfaceArray(const std::optional>>& in_services, const std::optional>>& in_names, bool* _aidl_return) = 0; virtual ::ndk::ScopedAStatus GetInterfaceList(const std::optional>>& in_names, std::optional>>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus VerifyNamesWithInterfaceList(const std::optional>>& in_services, const std::optional>>& in_names, bool* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseStringList(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatParcelFileDescriptor(const ::ndk::ScopedFileDescriptor& in_read, ::ndk::ScopedFileDescriptor* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseParcelFileDescriptorArray(const std::vector<::ndk::ScopedFileDescriptor>& in_input, std::vector<::ndk::ScopedFileDescriptor>* out_repeated, std::vector<::ndk::ScopedFileDescriptor>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ThrowServiceException(int32_t in_code) = 0; virtual ::ndk::ScopedAStatus RepeatNullableIntArray(const std::optional>& in_input, std::optional>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatNullableByteEnumArray(const std::optional>& in_input, std::optional>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatNullableIntEnumArray(const std::optional>& in_input, std::optional>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatNullableLongEnumArray(const std::optional>& in_input, std::optional>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatNullableString(const std::optional& in_input, std::optional* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatNullableStringList(const std::optional>>& in_input, std::optional>>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatNullableParcelable(const std::optional<::aidl::android::aidl::tests::ITestService::Empty>& in_input, std::optional<::aidl::android::aidl::tests::ITestService::Empty>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatNullableParcelableArray(const std::optional>>& in_input, std::optional>>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatNullableParcelableList(const std::optional>>& in_input, std::optional>>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus TakesAnIBinder(const ::ndk::SpAIBinder& in_input) = 0; virtual ::ndk::ScopedAStatus TakesANullableIBinder(const ::ndk::SpAIBinder& in_input) = 0; virtual ::ndk::ScopedAStatus TakesAnIBinderList(const std::vector<::ndk::SpAIBinder>& in_input) = 0; virtual ::ndk::ScopedAStatus TakesANullableIBinderList(const std::optional>& in_input) = 0; virtual ::ndk::ScopedAStatus RepeatUtf8CppString(const std::string& in_token, std::string* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatNullableUtf8CppString(const std::optional& in_token, std::optional* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseUtf8CppString(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseNullableUtf8CppString(const std::optional>>& in_input, std::optional>>* out_repeated, std::optional>>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseUtf8CppStringList(const std::optional>>& in_input, std::optional>>* out_repeated, std::optional>>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus GetCallback(bool in_return_null, std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus FillOutStructuredParcelable(::aidl::android::aidl::tests::StructuredParcelable* in_parcel) = 0; virtual ::ndk::ScopedAStatus RepeatExtendableParcelable(const ::aidl::android::aidl::tests::extension::ExtendableParcelable& in_ep, ::aidl::android::aidl::tests::extension::ExtendableParcelable* out_ep2) = 0; virtual ::ndk::ScopedAStatus ReverseList(const ::aidl::android::aidl::tests::RecursiveList& in_list, ::aidl::android::aidl::tests::RecursiveList* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseIBinderArray(const std::vector<::ndk::SpAIBinder>& in_input, std::vector<::ndk::SpAIBinder>* out_repeated, std::vector<::ndk::SpAIBinder>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseNullableIBinderArray(const std::optional>& in_input, std::optional>* out_repeated, std::optional>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus RepeatSimpleParcelable(const ::aidl::android::aidl::tests::SimpleParcelable& in_input, ::aidl::android::aidl::tests::SimpleParcelable* out_repeat, ::aidl::android::aidl::tests::SimpleParcelable* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ReverseSimpleParcelables(const std::vector<::aidl::android::aidl::tests::SimpleParcelable>& in_input, std::vector<::aidl::android::aidl::tests::SimpleParcelable>* out_repeated, std::vector<::aidl::android::aidl::tests::SimpleParcelable>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus GetOldNameInterface(std::shared_ptr<::aidl::android::aidl::tests::IOldName>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus GetNewNameInterface(std::shared_ptr<::aidl::android::aidl::tests::INewName>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus GetUnionTags(const std::vector<::aidl::android::aidl::tests::Union>& in_input, std::vector<::aidl::android::aidl::tests::Union::Tag>* _aidl_return) = 0; virtual ::ndk::ScopedAStatus GetCppJavaTests(::ndk::SpAIBinder* _aidl_return) = 0; virtual ::ndk::ScopedAStatus getBackendType(::aidl::android::aidl::tests::BackendType* _aidl_return) = 0; virtual ::ndk::ScopedAStatus GetCircular(::aidl::android::aidl::tests::CircularParcelable* out_cp, std::shared_ptr<::aidl::android::aidl::tests::ICircular>* _aidl_return) = 0; private: static std::shared_ptr default_impl; }; class ITestServiceDefault : public ITestService { public: ::ndk::ScopedAStatus UnimplementedMethod(int32_t in_arg, int32_t* _aidl_return) override; ::ndk::ScopedAStatus Deprecated() override __attribute__((deprecated("to make sure we have something in system/tools/aidl which does a compile check of deprecated and make sure this is reflected in goldens"))); ::ndk::ScopedAStatus TestOneway() override; ::ndk::ScopedAStatus RepeatBoolean(bool in_token, bool* _aidl_return) override; ::ndk::ScopedAStatus RepeatByte(int8_t in_token, int8_t* _aidl_return) override; ::ndk::ScopedAStatus RepeatChar(char16_t in_token, char16_t* _aidl_return) override; ::ndk::ScopedAStatus RepeatInt(int32_t in_token, int32_t* _aidl_return) override; ::ndk::ScopedAStatus RepeatLong(int64_t in_token, int64_t* _aidl_return) override; ::ndk::ScopedAStatus RepeatFloat(float in_token, float* _aidl_return) override; ::ndk::ScopedAStatus RepeatDouble(double in_token, double* _aidl_return) override; ::ndk::ScopedAStatus RepeatString(const std::string& in_token, std::string* _aidl_return) override; ::ndk::ScopedAStatus RepeatByteEnum(::aidl::android::aidl::tests::ByteEnum in_token, ::aidl::android::aidl::tests::ByteEnum* _aidl_return) override; ::ndk::ScopedAStatus RepeatIntEnum(::aidl::android::aidl::tests::IntEnum in_token, ::aidl::android::aidl::tests::IntEnum* _aidl_return) override; ::ndk::ScopedAStatus RepeatLongEnum(::aidl::android::aidl::tests::LongEnum in_token, ::aidl::android::aidl::tests::LongEnum* _aidl_return) override; ::ndk::ScopedAStatus ReverseBoolean(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseByte(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseChar(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseInt(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseLong(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseFloat(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseDouble(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseString(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseByteEnum(const std::vector<::aidl::android::aidl::tests::ByteEnum>& in_input, std::vector<::aidl::android::aidl::tests::ByteEnum>* out_repeated, std::vector<::aidl::android::aidl::tests::ByteEnum>* _aidl_return) override; ::ndk::ScopedAStatus ReverseIntEnum(const std::vector<::aidl::android::aidl::tests::IntEnum>& in_input, std::vector<::aidl::android::aidl::tests::IntEnum>* out_repeated, std::vector<::aidl::android::aidl::tests::IntEnum>* _aidl_return) override; ::ndk::ScopedAStatus ReverseLongEnum(const std::vector<::aidl::android::aidl::tests::LongEnum>& in_input, std::vector<::aidl::android::aidl::tests::LongEnum>* out_repeated, std::vector<::aidl::android::aidl::tests::LongEnum>* _aidl_return) override; ::ndk::ScopedAStatus GetOtherTestService(const std::string& in_name, std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>* _aidl_return) override; ::ndk::ScopedAStatus SetOtherTestService(const std::string& in_name, const std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>& in_service, bool* _aidl_return) override; ::ndk::ScopedAStatus VerifyName(const std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>& in_service, const std::string& in_name, bool* _aidl_return) override; ::ndk::ScopedAStatus GetInterfaceArray(const std::vector& in_names, std::vector>* _aidl_return) override; ::ndk::ScopedAStatus VerifyNamesWithInterfaceArray(const std::vector>& in_services, const std::vector& in_names, bool* _aidl_return) override; ::ndk::ScopedAStatus GetNullableInterfaceArray(const std::optional>>& in_names, std::optional>>* _aidl_return) override; ::ndk::ScopedAStatus VerifyNamesWithNullableInterfaceArray(const std::optional>>& in_services, const std::optional>>& in_names, bool* _aidl_return) override; ::ndk::ScopedAStatus GetInterfaceList(const std::optional>>& in_names, std::optional>>* _aidl_return) override; ::ndk::ScopedAStatus VerifyNamesWithInterfaceList(const std::optional>>& in_services, const std::optional>>& in_names, bool* _aidl_return) override; ::ndk::ScopedAStatus ReverseStringList(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus RepeatParcelFileDescriptor(const ::ndk::ScopedFileDescriptor& in_read, ::ndk::ScopedFileDescriptor* _aidl_return) override; ::ndk::ScopedAStatus ReverseParcelFileDescriptorArray(const std::vector<::ndk::ScopedFileDescriptor>& in_input, std::vector<::ndk::ScopedFileDescriptor>* out_repeated, std::vector<::ndk::ScopedFileDescriptor>* _aidl_return) override; ::ndk::ScopedAStatus ThrowServiceException(int32_t in_code) override; ::ndk::ScopedAStatus RepeatNullableIntArray(const std::optional>& in_input, std::optional>* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableByteEnumArray(const std::optional>& in_input, std::optional>* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableIntEnumArray(const std::optional>& in_input, std::optional>* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableLongEnumArray(const std::optional>& in_input, std::optional>* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableString(const std::optional& in_input, std::optional* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableStringList(const std::optional>>& in_input, std::optional>>* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableParcelable(const std::optional<::aidl::android::aidl::tests::ITestService::Empty>& in_input, std::optional<::aidl::android::aidl::tests::ITestService::Empty>* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableParcelableArray(const std::optional>>& in_input, std::optional>>* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableParcelableList(const std::optional>>& in_input, std::optional>>* _aidl_return) override; ::ndk::ScopedAStatus TakesAnIBinder(const ::ndk::SpAIBinder& in_input) override; ::ndk::ScopedAStatus TakesANullableIBinder(const ::ndk::SpAIBinder& in_input) override; ::ndk::ScopedAStatus TakesAnIBinderList(const std::vector<::ndk::SpAIBinder>& in_input) override; ::ndk::ScopedAStatus TakesANullableIBinderList(const std::optional>& in_input) override; ::ndk::ScopedAStatus RepeatUtf8CppString(const std::string& in_token, std::string* _aidl_return) override; ::ndk::ScopedAStatus RepeatNullableUtf8CppString(const std::optional& in_token, std::optional* _aidl_return) override; ::ndk::ScopedAStatus ReverseUtf8CppString(const std::vector& in_input, std::vector* out_repeated, std::vector* _aidl_return) override; ::ndk::ScopedAStatus ReverseNullableUtf8CppString(const std::optional>>& in_input, std::optional>>* out_repeated, std::optional>>* _aidl_return) override; ::ndk::ScopedAStatus ReverseUtf8CppStringList(const std::optional>>& in_input, std::optional>>* out_repeated, std::optional>>* _aidl_return) override; ::ndk::ScopedAStatus GetCallback(bool in_return_null, std::shared_ptr<::aidl::android::aidl::tests::INamedCallback>* _aidl_return) override; ::ndk::ScopedAStatus FillOutStructuredParcelable(::aidl::android::aidl::tests::StructuredParcelable* in_parcel) override; ::ndk::ScopedAStatus RepeatExtendableParcelable(const ::aidl::android::aidl::tests::extension::ExtendableParcelable& in_ep, ::aidl::android::aidl::tests::extension::ExtendableParcelable* out_ep2) override; ::ndk::ScopedAStatus ReverseList(const ::aidl::android::aidl::tests::RecursiveList& in_list, ::aidl::android::aidl::tests::RecursiveList* _aidl_return) override; ::ndk::ScopedAStatus ReverseIBinderArray(const std::vector<::ndk::SpAIBinder>& in_input, std::vector<::ndk::SpAIBinder>* out_repeated, std::vector<::ndk::SpAIBinder>* _aidl_return) override; ::ndk::ScopedAStatus ReverseNullableIBinderArray(const std::optional>& in_input, std::optional>* out_repeated, std::optional>* _aidl_return) override; ::ndk::ScopedAStatus RepeatSimpleParcelable(const ::aidl::android::aidl::tests::SimpleParcelable& in_input, ::aidl::android::aidl::tests::SimpleParcelable* out_repeat, ::aidl::android::aidl::tests::SimpleParcelable* _aidl_return) override; ::ndk::ScopedAStatus ReverseSimpleParcelables(const std::vector<::aidl::android::aidl::tests::SimpleParcelable>& in_input, std::vector<::aidl::android::aidl::tests::SimpleParcelable>* out_repeated, std::vector<::aidl::android::aidl::tests::SimpleParcelable>* _aidl_return) override; ::ndk::ScopedAStatus GetOldNameInterface(std::shared_ptr<::aidl::android::aidl::tests::IOldName>* _aidl_return) override; ::ndk::ScopedAStatus GetNewNameInterface(std::shared_ptr<::aidl::android::aidl::tests::INewName>* _aidl_return) override; ::ndk::ScopedAStatus GetUnionTags(const std::vector<::aidl::android::aidl::tests::Union>& in_input, std::vector<::aidl::android::aidl::tests::Union::Tag>* _aidl_return) override; ::ndk::ScopedAStatus GetCppJavaTests(::ndk::SpAIBinder* _aidl_return) override; ::ndk::ScopedAStatus getBackendType(::aidl::android::aidl::tests::BackendType* _aidl_return) override; ::ndk::ScopedAStatus GetCircular(::aidl::android::aidl::tests::CircularParcelable* out_cp, std::shared_ptr<::aidl::android::aidl::tests::ICircular>* _aidl_return) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(ITestService::CompilerChecks::UsingHasDeprecated::Tag val) { switch(val) { case ITestService::CompilerChecks::UsingHasDeprecated::Tag::n: return "n"; case ITestService::CompilerChecks::UsingHasDeprecated::Tag::m: return "m"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::tests::ITestService::CompilerChecks::UsingHasDeprecated::Tag::n, aidl::android::aidl::tests::ITestService::CompilerChecks::UsingHasDeprecated::Tag::m, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000215 15172120304 033216 xustar000000000 0000000 113 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/IntEnum.h 28 mtime=1776853188.6520000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/IntEnu0100644 0000000 0000000 00000004376 15172120304 032770 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/IntEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl */ #pragma once #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { enum class IntEnum : int32_t { FOO = 1000, BAR = 2000, BAZ = 2001, QUX __attribute__((deprecated("do not use this"))) = 2002, }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" [[nodiscard]] static inline std::string toString(IntEnum val) { switch(val) { case IntEnum::FOO: return "FOO"; case IntEnum::BAR: return "BAR"; case IntEnum::BAZ: return "BAZ"; case IntEnum::QUX: return "QUX"; default: return std::to_string(static_cast(val)); } } #pragma clang diagnostic pop } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" #pragma clang diagnostic ignored "-Wdeprecated-declarations" template <> constexpr inline std::array enum_values = { aidl::android::aidl::tests::IntEnum::FOO, aidl::android::aidl::tests::IntEnum::BAR, aidl::android::aidl::tests::IntEnum::BAZ, aidl::android::aidl::tests::IntEnum::QUX, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000226 15172120304 033220 xustar000000000 0000000 122 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/ListOfInterfaces.h 28 mtime=1776853188.6520000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/ListOf0100644 0000000 0000000 00000037471 15172120304 032770 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ListOfInterfaces.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ListOfInterfaces.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace aidl { namespace android { namespace aidl { namespace tests { class ListOfInterfaces { public: typedef std::false_type fixed_size; static const char* descriptor; class IEmptyInterfaceDelegator; class IEmptyInterface : public ::ndk::ICInterface { public: typedef IEmptyInterfaceDelegator DefaultDelegator; static const char* descriptor; IEmptyInterface(); virtual ~IEmptyInterface(); static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); private: static std::shared_ptr default_impl; }; class IEmptyInterfaceDefault : public IEmptyInterface { public: ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; class BpEmptyInterface : public ::ndk::BpCInterface { public: explicit BpEmptyInterface(const ::ndk::SpAIBinder& binder); virtual ~BpEmptyInterface(); }; class BnEmptyInterface : public ::ndk::BnCInterface { public: BnEmptyInterface(); virtual ~BnEmptyInterface(); protected: ::ndk::SpAIBinder createBinder() override; private: }; class IMyInterfaceDelegator; class IMyInterface : public ::ndk::ICInterface { public: typedef IMyInterfaceDelegator DefaultDelegator; static const char* descriptor; IMyInterface(); virtual ~IMyInterface(); static constexpr uint32_t TRANSACTION_methodWithInterfaces = FIRST_CALL_TRANSACTION + 0; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus methodWithInterfaces(const std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& in_iface, const std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& in_nullable_iface, const std::vector>& in_iface_list_in, std::vector>* out_iface_list_out, std::vector>* in_iface_list_inout, const std::optional>>& in_nullable_iface_list_in, std::optional>>* out_nullable_iface_list_out, std::optional>>* in_nullable_iface_list_inout, std::optional>>* _aidl_return) = 0; private: static std::shared_ptr default_impl; }; class IMyInterfaceDefault : public IMyInterface { public: ::ndk::ScopedAStatus methodWithInterfaces(const std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& in_iface, const std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& in_nullable_iface, const std::vector>& in_iface_list_in, std::vector>* out_iface_list_out, std::vector>* in_iface_list_inout, const std::optional>>& in_nullable_iface_list_in, std::optional>>* out_nullable_iface_list_out, std::optional>>* in_nullable_iface_list_inout, std::optional>>* _aidl_return) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; class BpMyInterface : public ::ndk::BpCInterface { public: explicit BpMyInterface(const ::ndk::SpAIBinder& binder); virtual ~BpMyInterface(); ::ndk::ScopedAStatus methodWithInterfaces(const std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& in_iface, const std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface>& in_nullable_iface, const std::vector>& in_iface_list_in, std::vector>* out_iface_list_out, std::vector>* in_iface_list_inout, const std::optional>>& in_nullable_iface_list_in, std::optional>>* out_nullable_iface_list_out, std::optional>>* in_nullable_iface_list_inout, std::optional>>* _aidl_return) override; }; class BnMyInterface : public ::ndk::BnCInterface { public: BnMyInterface(); virtual ~BnMyInterface(); protected: ::ndk::SpAIBinder createBinder() override; private: }; class MyParcelable { public: typedef std::false_type fixed_size; static const char* descriptor; std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface> iface; std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface> nullable_iface; std::vector> iface_list; std::optional>> nullable_iface_list; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const MyParcelable& _rhs) const { return std::tie(iface, nullable_iface, iface_list, nullable_iface_list) == std::tie(_rhs.iface, _rhs.nullable_iface, _rhs.iface_list, _rhs.nullable_iface_list); } inline bool operator<(const MyParcelable& _rhs) const { return std::tie(iface, nullable_iface, iface_list, nullable_iface_list) < std::tie(_rhs.iface, _rhs.nullable_iface, _rhs.iface_list, _rhs.nullable_iface_list); } inline bool operator!=(const MyParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyParcelable& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "MyParcelable{"; _aidl_os << "iface: " << ::android::internal::ToString(iface); _aidl_os << ", nullable_iface: " << ::android::internal::ToString(nullable_iface); _aidl_os << ", iface_list: " << ::android::internal::ToString(iface_list); _aidl_os << ", nullable_iface_list: " << ::android::internal::ToString(nullable_iface_list); _aidl_os << "}"; return _aidl_os.str(); } }; class MyUnion { public: typedef std::false_type fixed_size; static const char* descriptor; enum class Tag : int32_t { iface = 0, nullable_iface = 1, iface_list = 2, nullable_iface_list = 3, }; // Expose tag symbols for legacy code static const inline Tag iface = Tag::iface; static const inline Tag nullable_iface = Tag::nullable_iface; static const inline Tag iface_list = Tag::iface_list; static const inline Tag nullable_iface_list = Tag::nullable_iface_list; template static constexpr bool _not_self = !std::is_same_v>, MyUnion>; MyUnion() : _value(std::in_place_index(iface)>, std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface>()) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr MyUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit MyUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static MyUnion make(_Tp&&... _args) { return MyUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static MyUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return MyUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } binder_status_t readFromParcel(const AParcel* _parcel); binder_status_t writeToParcel(AParcel* _parcel) const; inline bool operator==(const MyUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const MyUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const MyUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyUnion& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream os; os << "MyUnion{"; switch (getTag()) { case iface: os << "iface: " << ::android::internal::ToString(get()); break; case nullable_iface: os << "nullable_iface: " << ::android::internal::ToString(get()); break; case iface_list: os << "iface_list: " << ::android::internal::ToString(get()); break; case nullable_iface_list: os << "nullable_iface_list: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant, std::shared_ptr<::aidl::android::aidl::tests::ListOfInterfaces::IEmptyInterface>, std::vector>, std::optional>>> _value; }; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const ListOfInterfaces&) const { return std::tie() == std::tie(); } inline bool operator<(const ListOfInterfaces&) const { return std::tie() < std::tie(); } inline bool operator!=(const ListOfInterfaces& _rhs) const { return !(*this == _rhs); } inline bool operator>(const ListOfInterfaces& _rhs) const { return _rhs < *this; } inline bool operator>=(const ListOfInterfaces& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const ListOfInterfaces& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "ListOfInterfaces{"; _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(ListOfInterfaces::MyUnion::Tag val) { switch(val) { case ListOfInterfaces::MyUnion::Tag::iface: return "iface"; case ListOfInterfaces::MyUnion::Tag::nullable_iface: return "nullable_iface"; case ListOfInterfaces::MyUnion::Tag::iface_list: return "iface_list"; case ListOfInterfaces::MyUnion::Tag::nullable_iface_list: return "nullable_iface_list"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::tests::ListOfInterfaces::MyUnion::Tag::iface, aidl::android::aidl::tests::ListOfInterfaces::MyUnion::Tag::nullable_iface, aidl::android::aidl::tests::ListOfInterfaces::MyUnion::Tag::iface_list, aidl::android::aidl::tests::ListOfInterfaces::MyUnion::Tag::nullable_iface_list, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000216 15172120304 033217 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/LongEnum.h 28 mtime=1776853188.6530000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/LongEn0100644 0000000 0000000 00000003740 15172120304 032742 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/LongEnum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl */ #pragma once #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { enum class LongEnum : int64_t { FOO = 100000000000L, BAR = 200000000000L, BAZ = 200000000001L, }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(LongEnum val) { switch(val) { case LongEnum::FOO: return "FOO"; case LongEnum::BAR: return "BAR"; case LongEnum::BAZ: return "BAZ"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::tests::LongEnum::FOO, aidl::android::aidl::tests::LongEnum::BAR, aidl::android::aidl::tests::LongEnum::BAZ, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000240 15172120304 033214 xustar000000000 0000000 132 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/OtherParcelableForToString.h 28 mtime=1776853188.6530000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/OtherP0100644 0000000 0000000 00000004511 15172120304 032756 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/OtherParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl */ #pragma once #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { class OtherParcelableForToString { public: typedef std::false_type fixed_size; static const char* descriptor; std::string field; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const OtherParcelableForToString& _rhs) const { return std::tie(field) == std::tie(_rhs.field); } inline bool operator<(const OtherParcelableForToString& _rhs) const { return std::tie(field) < std::tie(_rhs.field); } inline bool operator!=(const OtherParcelableForToString& _rhs) const { return !(*this == _rhs); } inline bool operator>(const OtherParcelableForToString& _rhs) const { return _rhs < *this; } inline bool operator>=(const OtherParcelableForToString& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const OtherParcelableForToString& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "OtherParcelableForToString{"; _aidl_os << "field: " << ::android::internal::ToString(field); _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000233 15172120304 033216 xustar000000000 0000000 127 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/ParcelableForToString.h 28 mtime=1776853188.6530000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/Parcel0100644 0000000 0000000 00000015564 15172120304 032775 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/ParcelableForToString.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ParcelableForToString.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl::android::aidl::tests { template class GenericStructuredParcelable; class OtherParcelableForToString; class StructuredParcelable; } // namespace aidl::android::aidl::tests namespace aidl { namespace android { namespace aidl { namespace tests { class ParcelableForToString { public: typedef std::false_type fixed_size; static const char* descriptor; int32_t intValue = 0; std::vector intArray; int64_t longValue = 0L; std::vector longArray; double doubleValue = 0.000000; std::vector doubleArray; float floatValue = 0.000000f; std::vector floatArray; int8_t byteValue = 0; std::vector byteArray; bool booleanValue = false; std::vector booleanArray; std::string stringValue; std::vector stringArray; std::vector stringList; ::aidl::android::aidl::tests::OtherParcelableForToString parcelableValue; std::vector<::aidl::android::aidl::tests::OtherParcelableForToString> parcelableArray; ::aidl::android::aidl::tests::IntEnum enumValue = ::aidl::android::aidl::tests::IntEnum::FOO; std::vector<::aidl::android::aidl::tests::IntEnum> enumArray; std::vector nullArray; std::vector nullList; ::aidl::android::aidl::tests::GenericStructuredParcelable parcelableGeneric; ::aidl::android::aidl::tests::Union unionValue; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const ParcelableForToString& _rhs) const { return std::tie(intValue, intArray, longValue, longArray, doubleValue, doubleArray, floatValue, floatArray, byteValue, byteArray, booleanValue, booleanArray, stringValue, stringArray, stringList, parcelableValue, parcelableArray, enumValue, enumArray, nullArray, nullList, parcelableGeneric, unionValue) == std::tie(_rhs.intValue, _rhs.intArray, _rhs.longValue, _rhs.longArray, _rhs.doubleValue, _rhs.doubleArray, _rhs.floatValue, _rhs.floatArray, _rhs.byteValue, _rhs.byteArray, _rhs.booleanValue, _rhs.booleanArray, _rhs.stringValue, _rhs.stringArray, _rhs.stringList, _rhs.parcelableValue, _rhs.parcelableArray, _rhs.enumValue, _rhs.enumArray, _rhs.nullArray, _rhs.nullList, _rhs.parcelableGeneric, _rhs.unionValue); } inline bool operator<(const ParcelableForToString& _rhs) const { return std::tie(intValue, intArray, longValue, longArray, doubleValue, doubleArray, floatValue, floatArray, byteValue, byteArray, booleanValue, booleanArray, stringValue, stringArray, stringList, parcelableValue, parcelableArray, enumValue, enumArray, nullArray, nullList, parcelableGeneric, unionValue) < std::tie(_rhs.intValue, _rhs.intArray, _rhs.longValue, _rhs.longArray, _rhs.doubleValue, _rhs.doubleArray, _rhs.floatValue, _rhs.floatArray, _rhs.byteValue, _rhs.byteArray, _rhs.booleanValue, _rhs.booleanArray, _rhs.stringValue, _rhs.stringArray, _rhs.stringList, _rhs.parcelableValue, _rhs.parcelableArray, _rhs.enumValue, _rhs.enumArray, _rhs.nullArray, _rhs.nullList, _rhs.parcelableGeneric, _rhs.unionValue); } inline bool operator!=(const ParcelableForToString& _rhs) const { return !(*this == _rhs); } inline bool operator>(const ParcelableForToString& _rhs) const { return _rhs < *this; } inline bool operator>=(const ParcelableForToString& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const ParcelableForToString& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "ParcelableForToString{"; _aidl_os << "intValue: " << ::android::internal::ToString(intValue); _aidl_os << ", intArray: " << ::android::internal::ToString(intArray); _aidl_os << ", longValue: " << ::android::internal::ToString(longValue); _aidl_os << ", longArray: " << ::android::internal::ToString(longArray); _aidl_os << ", doubleValue: " << ::android::internal::ToString(doubleValue); _aidl_os << ", doubleArray: " << ::android::internal::ToString(doubleArray); _aidl_os << ", floatValue: " << ::android::internal::ToString(floatValue); _aidl_os << ", floatArray: " << ::android::internal::ToString(floatArray); _aidl_os << ", byteValue: " << ::android::internal::ToString(byteValue); _aidl_os << ", byteArray: " << ::android::internal::ToString(byteArray); _aidl_os << ", booleanValue: " << ::android::internal::ToString(booleanValue); _aidl_os << ", booleanArray: " << ::android::internal::ToString(booleanArray); _aidl_os << ", stringValue: " << ::android::internal::ToString(stringValue); _aidl_os << ", stringArray: " << ::android::internal::ToString(stringArray); _aidl_os << ", stringList: " << ::android::internal::ToString(stringList); _aidl_os << ", parcelableValue: " << ::android::internal::ToString(parcelableValue); _aidl_os << ", parcelableArray: " << ::android::internal::ToString(parcelableArray); _aidl_os << ", enumValue: " << ::android::internal::ToString(enumValue); _aidl_os << ", enumArray: " << ::android::internal::ToString(enumArray); _aidl_os << ", nullArray: " << ::android::internal::ToString(nullArray); _aidl_os << ", nullList: " << ::android::internal::ToString(nullList); _aidl_os << ", parcelableGeneric: " << ::android::internal::ToString(parcelableGeneric); _aidl_os << ", unionValue: " << ::android::internal::ToString(unionValue); _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000223 15172120304 033215 xustar000000000 0000000 119 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/RecursiveList.h 28 mtime=1776853188.6530000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/Recurs0100644 0000000 0000000 00000005013 15172120304 033016 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/RecursiveList.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl::android::aidl::tests { class RecursiveList; } // namespace aidl::android::aidl::tests namespace aidl { namespace android { namespace aidl { namespace tests { class RecursiveList { public: typedef std::false_type fixed_size; static const char* descriptor; int32_t value = 0; std::unique_ptr<::aidl::android::aidl::tests::RecursiveList> next; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const RecursiveList& _rhs) const { return std::tie(value, next) == std::tie(_rhs.value, _rhs.next); } inline bool operator<(const RecursiveList& _rhs) const { return std::tie(value, next) < std::tie(_rhs.value, _rhs.next); } inline bool operator!=(const RecursiveList& _rhs) const { return !(*this == _rhs); } inline bool operator>(const RecursiveList& _rhs) const { return _rhs < *this; } inline bool operator>=(const RecursiveList& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const RecursiveList& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "RecursiveList{"; _aidl_os << "value: " << ::android::internal::ToString(value); _aidl_os << ", next: " << ::android::internal::ToString(next); _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000232 15172120304 033215 xustar000000000 0000000 126 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/StructuredParcelable.h 28 mtime=1776853188.6530000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/Struct0100644 0000000 0000000 00000037422 15172120304 033050 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/StructuredParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { class StructuredParcelable { public: typedef std::false_type fixed_size; static const char* descriptor; class Empty { public: typedef std::false_type fixed_size; static const char* descriptor; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const Empty&) const { return std::tie() == std::tie(); } inline bool operator<(const Empty&) const { return std::tie() < std::tie(); } inline bool operator!=(const Empty& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Empty& _rhs) const { return _rhs < *this; } inline bool operator>=(const Empty& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Empty& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "Empty{"; _aidl_os << "}"; return _aidl_os.str(); } }; std::vector shouldContainThreeFs; int32_t f = 0; std::string shouldBeJerry; ::aidl::android::aidl::tests::ByteEnum shouldBeByteBar = ::aidl::android::aidl::tests::ByteEnum(0); ::aidl::android::aidl::tests::IntEnum shouldBeIntBar = ::aidl::android::aidl::tests::IntEnum(0); ::aidl::android::aidl::tests::LongEnum shouldBeLongBar = ::aidl::android::aidl::tests::LongEnum(0); std::vector<::aidl::android::aidl::tests::ByteEnum> shouldContainTwoByteFoos; std::vector<::aidl::android::aidl::tests::IntEnum> shouldContainTwoIntFoos; std::vector<::aidl::android::aidl::tests::LongEnum> shouldContainTwoLongFoos; std::string stringDefaultsToFoo = "foo"; int8_t byteDefaultsToFour = 4; int32_t intDefaultsToFive = 5; int64_t longDefaultsToNegativeSeven = -7L; bool booleanDefaultsToTrue = true; char16_t charDefaultsToC = 'C'; float floatDefaultsToPi = 3.140000f; double doubleWithDefault = -314000000000000000.000000; std::vector arrayDefaultsTo123 = {1, 2, 3}; std::vector arrayDefaultsToEmpty = {}; bool boolDefault = false; int8_t byteDefault = 0; int32_t intDefault = 0; int64_t longDefault = 0L; float floatDefault = 0.000000f; double doubleDefault = 0.000000; double checkDoubleFromFloat = 3.140000; std::vector checkStringArray1 = {"a", "b"}; std::vector checkStringArray2 = {"a", "b"}; int32_t int32_min = -2147483648; int32_t int32_max = 2147483647; int64_t int64_max = 9223372036854775807L; int32_t hexInt32_neg_1 = -1; ::ndk::SpAIBinder ibinder; ::aidl::android::aidl::tests::StructuredParcelable::Empty empty; std::vector int8_1 = {1, 1, 1, 1, 1}; std::vector int32_1 = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}; std::vector int64_1 = {1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L}; int32_t hexInt32_pos_1 = 1; int32_t hexInt64_pos_1 = 1; ::aidl::android::aidl::tests::ConstantExpressionEnum const_exprs_1 = ::aidl::android::aidl::tests::ConstantExpressionEnum(0); ::aidl::android::aidl::tests::ConstantExpressionEnum const_exprs_2 = ::aidl::android::aidl::tests::ConstantExpressionEnum(0); ::aidl::android::aidl::tests::ConstantExpressionEnum const_exprs_3 = ::aidl::android::aidl::tests::ConstantExpressionEnum(0); ::aidl::android::aidl::tests::ConstantExpressionEnum const_exprs_4 = ::aidl::android::aidl::tests::ConstantExpressionEnum(0); ::aidl::android::aidl::tests::ConstantExpressionEnum const_exprs_5 = ::aidl::android::aidl::tests::ConstantExpressionEnum(0); ::aidl::android::aidl::tests::ConstantExpressionEnum const_exprs_6 = ::aidl::android::aidl::tests::ConstantExpressionEnum(0); ::aidl::android::aidl::tests::ConstantExpressionEnum const_exprs_7 = ::aidl::android::aidl::tests::ConstantExpressionEnum(0); ::aidl::android::aidl::tests::ConstantExpressionEnum const_exprs_8 = ::aidl::android::aidl::tests::ConstantExpressionEnum(0); ::aidl::android::aidl::tests::ConstantExpressionEnum const_exprs_9 = ::aidl::android::aidl::tests::ConstantExpressionEnum(0); ::aidl::android::aidl::tests::ConstantExpressionEnum const_exprs_10 = ::aidl::android::aidl::tests::ConstantExpressionEnum(0); std::string addString1 = "hello world!"; std::string addString2 = "The quick brown fox jumps over the lazy dog."; int32_t shouldSetBit0AndBit2 = 0; std::optional<::aidl::android::aidl::tests::Union> u; std::optional<::aidl::android::aidl::tests::Union> shouldBeConstS1; ::aidl::android::aidl::tests::IntEnum defaultWithFoo = ::aidl::android::aidl::tests::IntEnum::FOO; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const StructuredParcelable& _rhs) const { return std::tie(shouldContainThreeFs, f, shouldBeJerry, shouldBeByteBar, shouldBeIntBar, shouldBeLongBar, shouldContainTwoByteFoos, shouldContainTwoIntFoos, shouldContainTwoLongFoos, stringDefaultsToFoo, byteDefaultsToFour, intDefaultsToFive, longDefaultsToNegativeSeven, booleanDefaultsToTrue, charDefaultsToC, floatDefaultsToPi, doubleWithDefault, arrayDefaultsTo123, arrayDefaultsToEmpty, boolDefault, byteDefault, intDefault, longDefault, floatDefault, doubleDefault, checkDoubleFromFloat, checkStringArray1, checkStringArray2, int32_min, int32_max, int64_max, hexInt32_neg_1, ibinder, empty, int8_1, int32_1, int64_1, hexInt32_pos_1, hexInt64_pos_1, const_exprs_1, const_exprs_2, const_exprs_3, const_exprs_4, const_exprs_5, const_exprs_6, const_exprs_7, const_exprs_8, const_exprs_9, const_exprs_10, addString1, addString2, shouldSetBit0AndBit2, u, shouldBeConstS1, defaultWithFoo) == std::tie(_rhs.shouldContainThreeFs, _rhs.f, _rhs.shouldBeJerry, _rhs.shouldBeByteBar, _rhs.shouldBeIntBar, _rhs.shouldBeLongBar, _rhs.shouldContainTwoByteFoos, _rhs.shouldContainTwoIntFoos, _rhs.shouldContainTwoLongFoos, _rhs.stringDefaultsToFoo, _rhs.byteDefaultsToFour, _rhs.intDefaultsToFive, _rhs.longDefaultsToNegativeSeven, _rhs.booleanDefaultsToTrue, _rhs.charDefaultsToC, _rhs.floatDefaultsToPi, _rhs.doubleWithDefault, _rhs.arrayDefaultsTo123, _rhs.arrayDefaultsToEmpty, _rhs.boolDefault, _rhs.byteDefault, _rhs.intDefault, _rhs.longDefault, _rhs.floatDefault, _rhs.doubleDefault, _rhs.checkDoubleFromFloat, _rhs.checkStringArray1, _rhs.checkStringArray2, _rhs.int32_min, _rhs.int32_max, _rhs.int64_max, _rhs.hexInt32_neg_1, _rhs.ibinder, _rhs.empty, _rhs.int8_1, _rhs.int32_1, _rhs.int64_1, _rhs.hexInt32_pos_1, _rhs.hexInt64_pos_1, _rhs.const_exprs_1, _rhs.const_exprs_2, _rhs.const_exprs_3, _rhs.const_exprs_4, _rhs.const_exprs_5, _rhs.const_exprs_6, _rhs.const_exprs_7, _rhs.const_exprs_8, _rhs.const_exprs_9, _rhs.const_exprs_10, _rhs.addString1, _rhs.addString2, _rhs.shouldSetBit0AndBit2, _rhs.u, _rhs.shouldBeConstS1, _rhs.defaultWithFoo); } inline bool operator<(const StructuredParcelable& _rhs) const { return std::tie(shouldContainThreeFs, f, shouldBeJerry, shouldBeByteBar, shouldBeIntBar, shouldBeLongBar, shouldContainTwoByteFoos, shouldContainTwoIntFoos, shouldContainTwoLongFoos, stringDefaultsToFoo, byteDefaultsToFour, intDefaultsToFive, longDefaultsToNegativeSeven, booleanDefaultsToTrue, charDefaultsToC, floatDefaultsToPi, doubleWithDefault, arrayDefaultsTo123, arrayDefaultsToEmpty, boolDefault, byteDefault, intDefault, longDefault, floatDefault, doubleDefault, checkDoubleFromFloat, checkStringArray1, checkStringArray2, int32_min, int32_max, int64_max, hexInt32_neg_1, ibinder, empty, int8_1, int32_1, int64_1, hexInt32_pos_1, hexInt64_pos_1, const_exprs_1, const_exprs_2, const_exprs_3, const_exprs_4, const_exprs_5, const_exprs_6, const_exprs_7, const_exprs_8, const_exprs_9, const_exprs_10, addString1, addString2, shouldSetBit0AndBit2, u, shouldBeConstS1, defaultWithFoo) < std::tie(_rhs.shouldContainThreeFs, _rhs.f, _rhs.shouldBeJerry, _rhs.shouldBeByteBar, _rhs.shouldBeIntBar, _rhs.shouldBeLongBar, _rhs.shouldContainTwoByteFoos, _rhs.shouldContainTwoIntFoos, _rhs.shouldContainTwoLongFoos, _rhs.stringDefaultsToFoo, _rhs.byteDefaultsToFour, _rhs.intDefaultsToFive, _rhs.longDefaultsToNegativeSeven, _rhs.booleanDefaultsToTrue, _rhs.charDefaultsToC, _rhs.floatDefaultsToPi, _rhs.doubleWithDefault, _rhs.arrayDefaultsTo123, _rhs.arrayDefaultsToEmpty, _rhs.boolDefault, _rhs.byteDefault, _rhs.intDefault, _rhs.longDefault, _rhs.floatDefault, _rhs.doubleDefault, _rhs.checkDoubleFromFloat, _rhs.checkStringArray1, _rhs.checkStringArray2, _rhs.int32_min, _rhs.int32_max, _rhs.int64_max, _rhs.hexInt32_neg_1, _rhs.ibinder, _rhs.empty, _rhs.int8_1, _rhs.int32_1, _rhs.int64_1, _rhs.hexInt32_pos_1, _rhs.hexInt64_pos_1, _rhs.const_exprs_1, _rhs.const_exprs_2, _rhs.const_exprs_3, _rhs.const_exprs_4, _rhs.const_exprs_5, _rhs.const_exprs_6, _rhs.const_exprs_7, _rhs.const_exprs_8, _rhs.const_exprs_9, _rhs.const_exprs_10, _rhs.addString1, _rhs.addString2, _rhs.shouldSetBit0AndBit2, _rhs.u, _rhs.shouldBeConstS1, _rhs.defaultWithFoo); } inline bool operator!=(const StructuredParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const StructuredParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const StructuredParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const StructuredParcelable& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; enum : int32_t { BIT0 = 1 }; enum : int32_t { BIT1 = 2 }; enum : int32_t { BIT2 = 4 }; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "StructuredParcelable{"; _aidl_os << "shouldContainThreeFs: " << ::android::internal::ToString(shouldContainThreeFs); _aidl_os << ", f: " << ::android::internal::ToString(f); _aidl_os << ", shouldBeJerry: " << ::android::internal::ToString(shouldBeJerry); _aidl_os << ", shouldBeByteBar: " << ::android::internal::ToString(shouldBeByteBar); _aidl_os << ", shouldBeIntBar: " << ::android::internal::ToString(shouldBeIntBar); _aidl_os << ", shouldBeLongBar: " << ::android::internal::ToString(shouldBeLongBar); _aidl_os << ", shouldContainTwoByteFoos: " << ::android::internal::ToString(shouldContainTwoByteFoos); _aidl_os << ", shouldContainTwoIntFoos: " << ::android::internal::ToString(shouldContainTwoIntFoos); _aidl_os << ", shouldContainTwoLongFoos: " << ::android::internal::ToString(shouldContainTwoLongFoos); _aidl_os << ", stringDefaultsToFoo: " << ::android::internal::ToString(stringDefaultsToFoo); _aidl_os << ", byteDefaultsToFour: " << ::android::internal::ToString(byteDefaultsToFour); _aidl_os << ", intDefaultsToFive: " << ::android::internal::ToString(intDefaultsToFive); _aidl_os << ", longDefaultsToNegativeSeven: " << ::android::internal::ToString(longDefaultsToNegativeSeven); _aidl_os << ", booleanDefaultsToTrue: " << ::android::internal::ToString(booleanDefaultsToTrue); _aidl_os << ", charDefaultsToC: " << ::android::internal::ToString(charDefaultsToC); _aidl_os << ", floatDefaultsToPi: " << ::android::internal::ToString(floatDefaultsToPi); _aidl_os << ", doubleWithDefault: " << ::android::internal::ToString(doubleWithDefault); _aidl_os << ", arrayDefaultsTo123: " << ::android::internal::ToString(arrayDefaultsTo123); _aidl_os << ", arrayDefaultsToEmpty: " << ::android::internal::ToString(arrayDefaultsToEmpty); _aidl_os << ", boolDefault: " << ::android::internal::ToString(boolDefault); _aidl_os << ", byteDefault: " << ::android::internal::ToString(byteDefault); _aidl_os << ", intDefault: " << ::android::internal::ToString(intDefault); _aidl_os << ", longDefault: " << ::android::internal::ToString(longDefault); _aidl_os << ", floatDefault: " << ::android::internal::ToString(floatDefault); _aidl_os << ", doubleDefault: " << ::android::internal::ToString(doubleDefault); _aidl_os << ", checkDoubleFromFloat: " << ::android::internal::ToString(checkDoubleFromFloat); _aidl_os << ", checkStringArray1: " << ::android::internal::ToString(checkStringArray1); _aidl_os << ", checkStringArray2: " << ::android::internal::ToString(checkStringArray2); _aidl_os << ", int32_min: " << ::android::internal::ToString(int32_min); _aidl_os << ", int32_max: " << ::android::internal::ToString(int32_max); _aidl_os << ", int64_max: " << ::android::internal::ToString(int64_max); _aidl_os << ", hexInt32_neg_1: " << ::android::internal::ToString(hexInt32_neg_1); _aidl_os << ", ibinder: " << ::android::internal::ToString(ibinder); _aidl_os << ", empty: " << ::android::internal::ToString(empty); _aidl_os << ", int8_1: " << ::android::internal::ToString(int8_1); _aidl_os << ", int32_1: " << ::android::internal::ToString(int32_1); _aidl_os << ", int64_1: " << ::android::internal::ToString(int64_1); _aidl_os << ", hexInt32_pos_1: " << ::android::internal::ToString(hexInt32_pos_1); _aidl_os << ", hexInt64_pos_1: " << ::android::internal::ToString(hexInt64_pos_1); _aidl_os << ", const_exprs_1: " << ::android::internal::ToString(const_exprs_1); _aidl_os << ", const_exprs_2: " << ::android::internal::ToString(const_exprs_2); _aidl_os << ", const_exprs_3: " << ::android::internal::ToString(const_exprs_3); _aidl_os << ", const_exprs_4: " << ::android::internal::ToString(const_exprs_4); _aidl_os << ", const_exprs_5: " << ::android::internal::ToString(const_exprs_5); _aidl_os << ", const_exprs_6: " << ::android::internal::ToString(const_exprs_6); _aidl_os << ", const_exprs_7: " << ::android::internal::ToString(const_exprs_7); _aidl_os << ", const_exprs_8: " << ::android::internal::ToString(const_exprs_8); _aidl_os << ", const_exprs_9: " << ::android::internal::ToString(const_exprs_9); _aidl_os << ", const_exprs_10: " << ::android::internal::ToString(const_exprs_10); _aidl_os << ", addString1: " << ::android::internal::ToString(addString1); _aidl_os << ", addString2: " << ::android::internal::ToString(addString2); _aidl_os << ", shouldSetBit0AndBit2: " << ::android::internal::ToString(shouldSetBit0AndBit2); _aidl_os << ", u: " << ::android::internal::ToString(u); _aidl_os << ", shouldBeConstS1: " << ::android::internal::ToString(shouldBeConstS1); _aidl_os << ", defaultWithFoo: " << ::android::internal::ToString(defaultWithFoo); _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000213 15172120304 033214 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/Union.h 28 mtime=1776853188.6540000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/Union.0100644 0000000 0000000 00000014423 15172120304 032726 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/Union.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/Union.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace aidl { namespace android { namespace aidl { namespace tests { class Union { public: typedef std::false_type fixed_size; static const char* descriptor; enum class Tag : int32_t { ns = 0, n = 1, m = 2, s = 3, ibinder = 4, ss = 5, be = 6, }; // Expose tag symbols for legacy code static const inline Tag ns = Tag::ns; static const inline Tag n = Tag::n; static const inline Tag m = Tag::m; static const inline Tag s = Tag::s; static const inline Tag ibinder = Tag::ibinder; static const inline Tag ss = Tag::ss; static const inline Tag be = Tag::be; template static constexpr bool _not_self = !std::is_same_v>, Union>; Union() : _value(std::in_place_index(ns)>, std::vector({})) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr Union(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit Union(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static Union make(_Tp&&... _args) { return Union(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static Union make(std::initializer_list<_Tp> _il, _Up&&... _args) { return Union(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } binder_status_t readFromParcel(const AParcel* _parcel); binder_status_t writeToParcel(AParcel* _parcel) const; inline bool operator==(const Union& _rhs) const { return _value == _rhs._value; } inline bool operator<(const Union& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const Union& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Union& _rhs) const { return _rhs < *this; } inline bool operator>=(const Union& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Union& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; static const char* S1; inline std::string toString() const { std::ostringstream os; os << "Union{"; switch (getTag()) { case ns: os << "ns: " << ::android::internal::ToString(get()); break; case n: os << "n: " << ::android::internal::ToString(get()); break; case m: os << "m: " << ::android::internal::ToString(get()); break; case s: os << "s: " << ::android::internal::ToString(get()); break; case ibinder: os << "ibinder: " << ::android::internal::ToString(get()); break; case ss: os << "ss: " << ::android::internal::ToString(get()); break; case be: os << "be: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant, int32_t, int32_t, std::string, ::ndk::SpAIBinder, std::vector, ::aidl::android::aidl::tests::ByteEnum> _value; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(Union::Tag val) { switch(val) { case Union::Tag::ns: return "ns"; case Union::Tag::n: return "n"; case Union::Tag::m: return "m"; case Union::Tag::s: return "s"; case Union::Tag::ibinder: return "ibinder"; case Union::Tag::ss: return "ss"; case Union::Tag::be: return "be"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::tests::Union::Tag::ns, aidl::android::aidl::tests::Union::Tag::n, aidl::android::aidl::tests::Union::Tag::m, aidl::android::aidl::tests::Union::Tag::s, aidl::android::aidl::tests::Union::Tag::ibinder, aidl::android::aidl::tests::Union::Tag::ss, aidl::android::aidl::tests::Union::Tag::be, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000221 15172120304 033213 xustar000000000 0000000 117 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/UnionWithFd.h 28 mtime=1776853188.6540000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/UnionW0100644 0000000 0000000 00000012271 15172120304 032776 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/UnionWithFd.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/UnionWithFd.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace aidl { namespace android { namespace aidl { namespace tests { class UnionWithFd { public: typedef std::false_type fixed_size; static const char* descriptor; enum class Tag : int32_t { num = 0, pfd = 1, }; // Expose tag symbols for legacy code static const inline Tag num = Tag::num; static const inline Tag pfd = Tag::pfd; template static constexpr bool _not_self = !std::is_same_v>, UnionWithFd>; UnionWithFd() : _value(std::in_place_index(num)>, int32_t(0)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr UnionWithFd(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit UnionWithFd(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static UnionWithFd make(_Tp&&... _args) { return UnionWithFd(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static UnionWithFd make(std::initializer_list<_Tp> _il, _Up&&... _args) { return UnionWithFd(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } binder_status_t readFromParcel(const AParcel* _parcel); binder_status_t writeToParcel(AParcel* _parcel) const; inline bool operator==(const UnionWithFd& _rhs) const { return _value == _rhs._value; } inline bool operator<(const UnionWithFd& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const UnionWithFd& _rhs) const { return !(*this == _rhs); } inline bool operator>(const UnionWithFd& _rhs) const { return _rhs < *this; } inline bool operator>=(const UnionWithFd& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const UnionWithFd& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream os; os << "UnionWithFd{"; switch (getTag()) { case num: os << "num: " << ::android::internal::ToString(get()); break; case pfd: os << "pfd: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant _value; }; } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { [[nodiscard]] static inline std::string toString(UnionWithFd::Tag val) { switch(val) { case UnionWithFd::Tag::num: return "num"; case UnionWithFd::Tag::pfd: return "pfd"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::tests::UnionWithFd::Tag::num, aidl::android::aidl::tests::UnionWithFd::Tag::pfd, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000216 15172120304 033217 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/ 28 mtime=1776853188.6550000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extens0040755 0000000 0000000 00000000000 15172120304 033063 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000246 15172120304 033222 xustar000000000 0000000 138 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/BnExtendableParcelable.h 28 mtime=1776853188.6550000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extens0100644 0000000 0000000 00000001264 15172120304 033065 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/extension/ExtendableParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000227 15172120304 033221 xustar000000000 0000000 123 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/BnMyExt.h 28 mtime=1776853188.6550000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extens0100644 0000000 0000000 00000001226 15172120304 033063 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/extension/MyExt.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000230 15172120304 033213 xustar000000000 0000000 124 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/BnMyExt2.h 28 mtime=1776853188.6550000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extens0100644 0000000 0000000 00000001230 15172120304 033056 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/extension/MyExt2.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt2.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000233 15172120304 033216 xustar000000000 0000000 127 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/BnMyExtLike.h 28 mtime=1776853188.6550000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extens0100644 0000000 0000000 00000001236 15172120304 033064 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/extension/MyExtLike.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExtLike.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000246 15172120304 033222 xustar000000000 0000000 138 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/BpExtendableParcelable.h 28 mtime=1776853188.6550000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extens0100644 0000000 0000000 00000001264 15172120304 033065 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/extension/ExtendableParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000227 15172120304 033221 xustar000000000 0000000 123 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/BpMyExt.h 28 mtime=1776853188.6550000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extens0100644 0000000 0000000 00000001226 15172120304 033063 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/extension/MyExt.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000230 15172120304 033213 xustar000000000 0000000 124 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/BpMyExt2.h 28 mtime=1776853188.6550000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extens0100644 0000000 0000000 00000001230 15172120304 033056 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/extension/MyExt2.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt2.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000233 15172120304 033216 xustar000000000 0000000 127 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/BpMyExtLike.h 28 mtime=1776853188.6550000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extens0100644 0000000 0000000 00000001236 15172120304 033064 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/extension/MyExtLike.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExtLike.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000244 15172120304 033220 xustar000000000 0000000 136 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/ExtendableParcelable.h 28 mtime=1776853188.6550000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extens0100644 0000000 0000000 00000005463 15172120304 033072 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/extension/ExtendableParcelable.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl */ #pragma once #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { namespace extension { class ExtendableParcelable { public: typedef std::false_type fixed_size; static const char* descriptor; int32_t a = 0; std::string b; ::ndk::AParcelableHolder ext{::ndk::STABILITY_LOCAL}; int64_t c = 0L; ::ndk::AParcelableHolder ext2{::ndk::STABILITY_LOCAL}; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const ExtendableParcelable& _rhs) const { return std::tie(a, b, ext, c, ext2) == std::tie(_rhs.a, _rhs.b, _rhs.ext, _rhs.c, _rhs.ext2); } inline bool operator<(const ExtendableParcelable& _rhs) const { return std::tie(a, b, ext, c, ext2) < std::tie(_rhs.a, _rhs.b, _rhs.ext, _rhs.c, _rhs.ext2); } inline bool operator!=(const ExtendableParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const ExtendableParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const ExtendableParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const ExtendableParcelable& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "ExtendableParcelable{"; _aidl_os << "a: " << ::android::internal::ToString(a); _aidl_os << ", b: " << ::android::internal::ToString(b); _aidl_os << ", ext: " << ::android::internal::ToString(ext); _aidl_os << ", c: " << ::android::internal::ToString(c); _aidl_os << ", ext2: " << ::android::internal::ToString(ext2); _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace extension } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000225 15172120304 033217 xustar000000000 0000000 121 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/MyExt.h 28 mtime=1776853188.6560000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extens0100644 0000000 0000000 00000004403 15172120304 033063 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/extension/MyExt.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl */ #pragma once #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { namespace extension { class MyExt { public: typedef std::false_type fixed_size; static const char* descriptor; int32_t a = 0; std::string b; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const MyExt& _rhs) const { return std::tie(a, b) == std::tie(_rhs.a, _rhs.b); } inline bool operator<(const MyExt& _rhs) const { return std::tie(a, b) < std::tie(_rhs.a, _rhs.b); } inline bool operator!=(const MyExt& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyExt& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyExt& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyExt& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "MyExt{"; _aidl_os << "a: " << ::android::internal::ToString(a); _aidl_os << ", b: " << ::android::internal::ToString(b); _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace extension } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000226 15172120304 033220 xustar000000000 0000000 122 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/MyExt2.h 28 mtime=1776853188.6560000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extens0100644 0000000 0000000 00000005076 15172120304 033072 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/extension/MyExt2.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt2.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl::android::aidl::tests::extension { class MyExt; } // namespace aidl::android::aidl::tests::extension namespace aidl { namespace android { namespace aidl { namespace tests { namespace extension { class MyExt2 { public: typedef std::false_type fixed_size; static const char* descriptor; int32_t a = 0; ::aidl::android::aidl::tests::extension::MyExt b; std::string c; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const MyExt2& _rhs) const { return std::tie(a, b, c) == std::tie(_rhs.a, _rhs.b, _rhs.c); } inline bool operator<(const MyExt2& _rhs) const { return std::tie(a, b, c) < std::tie(_rhs.a, _rhs.b, _rhs.c); } inline bool operator!=(const MyExt2& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyExt2& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyExt2& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyExt2& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "MyExt2{"; _aidl_os << "a: " << ::android::internal::ToString(a); _aidl_os << ", b: " << ::android::internal::ToString(b); _aidl_os << ", c: " << ::android::internal::ToString(c); _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace extension } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000231 15172120304 033214 xustar000000000 0000000 125 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extension/MyExtLike.h 28 mtime=1776853188.6560000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/extens0100644 0000000 0000000 00000004453 15172120304 033070 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/extension/MyExtLike.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExtLike.aidl */ #pragma once #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { namespace extension { class MyExtLike { public: typedef std::false_type fixed_size; static const char* descriptor; int32_t a = 0; std::string b; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const MyExtLike& _rhs) const { return std::tie(a, b) == std::tie(_rhs.a, _rhs.b); } inline bool operator<(const MyExtLike& _rhs) const { return std::tie(a, b) < std::tie(_rhs.a, _rhs.b); } inline bool operator!=(const MyExtLike& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyExtLike& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyExtLike& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyExtLike& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "MyExtLike{"; _aidl_os << "a: " << ::android::internal::ToString(a); _aidl_os << ", b: " << ::android::internal::ToString(b); _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace extension } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000213 15172120304 033214 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested/ 28 mtime=1776853188.6560000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested0040755 0000000 0000000 00000000000 15172120304 033037 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000233 15172120304 033216 xustar000000000 0000000 127 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested/BnDeeplyNested.h 28 mtime=1776853188.6560000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested0100644 0000000 0000000 00000001236 15172120304 033040 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/nested/DeeplyNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/DeeplyNested.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000234 15172120304 033217 xustar000000000 0000000 128 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested/BnNestedService.h 28 mtime=1776853188.6560000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested0100644 0000000 0000000 00000003721 15172120304 033041 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/nested/INestedService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/INestedService.aidl */ #pragma once #include "aidl/android/aidl/tests/nested/INestedService.h" #include #include #ifndef __BIONIC__ #ifndef __assert2 #define __assert2(a,b,c,d) ((void)0) #endif #endif namespace aidl { namespace android { namespace aidl { namespace tests { namespace nested { class BnNestedService : public ::ndk::BnCInterface { public: BnNestedService(); virtual ~BnNestedService(); protected: ::ndk::SpAIBinder createBinder() override; private: }; class INestedServiceDelegator : public BnNestedService { public: explicit INestedServiceDelegator(const std::shared_ptr &impl) : _impl(impl) { } ::ndk::ScopedAStatus flipStatus(const ::aidl::android::aidl::tests::nested::ParcelableWithNested& in_p, ::aidl::android::aidl::tests::nested::INestedService::Result* _aidl_return) override { return _impl->flipStatus(in_p, _aidl_return); } ::ndk::ScopedAStatus flipStatusWithCallback(::aidl::android::aidl::tests::nested::ParcelableWithNested::Status in_status, const std::shared_ptr<::aidl::android::aidl::tests::nested::INestedService::ICallback>& in_cb) override { return _impl->flipStatusWithCallback(in_status, in_cb); } protected: private: std::shared_ptr _impl; }; } // namespace nested } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000243 15172120304 033217 xustar000000000 0000000 135 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested/BnParcelableWithNested.h 28 mtime=1776853188.6560000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested0100644 0000000 0000000 00000001256 15172120304 033042 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/nested/ParcelableWithNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000233 15172120304 033216 xustar000000000 0000000 127 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested/BpDeeplyNested.h 28 mtime=1776853188.6560000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested0100644 0000000 0000000 00000001236 15172120304 033040 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/nested/DeeplyNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/DeeplyNested.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000234 15172120304 033217 xustar000000000 0000000 128 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested/BpNestedService.h 28 mtime=1776853188.6560000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested0100644 0000000 0000000 00000002756 15172120304 033050 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/nested/INestedService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/INestedService.aidl */ #pragma once #include "aidl/android/aidl/tests/nested/INestedService.h" #include namespace aidl { namespace android { namespace aidl { namespace tests { namespace nested { class BpNestedService : public ::ndk::BpCInterface { public: explicit BpNestedService(const ::ndk::SpAIBinder& binder); virtual ~BpNestedService(); ::ndk::ScopedAStatus flipStatus(const ::aidl::android::aidl::tests::nested::ParcelableWithNested& in_p, ::aidl::android::aidl::tests::nested::INestedService::Result* _aidl_return) override; ::ndk::ScopedAStatus flipStatusWithCallback(::aidl::android::aidl::tests::nested::ParcelableWithNested::Status in_status, const std::shared_ptr<::aidl::android::aidl::tests::nested::INestedService::ICallback>& in_cb) override; }; } // namespace nested } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000243 15172120304 033217 xustar000000000 0000000 135 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested/BpParcelableWithNested.h 28 mtime=1776853188.6560000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested0100644 0000000 0000000 00000001256 15172120304 033042 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/nested/ParcelableWithNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000231 15172120304 033214 xustar000000000 0000000 125 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested/DeeplyNested.h 28 mtime=1776853188.6570000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested0100644 0000000 0000000 00000016637 15172120304 033053 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/nested/DeeplyNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/DeeplyNested.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { namespace nested { class DeeplyNested { public: typedef std::false_type fixed_size; static const char* descriptor; class B { public: typedef std::false_type fixed_size; static const char* descriptor; class C { public: typedef std::false_type fixed_size; static const char* descriptor; class D { public: typedef std::false_type fixed_size; static const char* descriptor; enum class E : int8_t { OK = 0, }; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const D&) const { return std::tie() == std::tie(); } inline bool operator<(const D&) const { return std::tie() < std::tie(); } inline bool operator!=(const D& _rhs) const { return !(*this == _rhs); } inline bool operator>(const D& _rhs) const { return _rhs < *this; } inline bool operator>=(const D& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const D& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "D{"; _aidl_os << "}"; return _aidl_os.str(); } }; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const C&) const { return std::tie() == std::tie(); } inline bool operator<(const C&) const { return std::tie() < std::tie(); } inline bool operator!=(const C& _rhs) const { return !(*this == _rhs); } inline bool operator>(const C& _rhs) const { return _rhs < *this; } inline bool operator>=(const C& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const C& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "C{"; _aidl_os << "}"; return _aidl_os.str(); } }; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const B&) const { return std::tie() == std::tie(); } inline bool operator<(const B&) const { return std::tie() < std::tie(); } inline bool operator!=(const B& _rhs) const { return !(*this == _rhs); } inline bool operator>(const B& _rhs) const { return _rhs < *this; } inline bool operator>=(const B& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const B& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "B{"; _aidl_os << "}"; return _aidl_os.str(); } }; class A { public: typedef std::false_type fixed_size; static const char* descriptor; ::aidl::android::aidl::tests::nested::DeeplyNested::B::C::D::E e = ::aidl::android::aidl::tests::nested::DeeplyNested::B::C::D::E::OK; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const A& _rhs) const { return std::tie(e) == std::tie(_rhs.e); } inline bool operator<(const A& _rhs) const { return std::tie(e) < std::tie(_rhs.e); } inline bool operator!=(const A& _rhs) const { return !(*this == _rhs); } inline bool operator>(const A& _rhs) const { return _rhs < *this; } inline bool operator>=(const A& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const A& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "A{"; _aidl_os << "e: " << ::android::internal::ToString(e); _aidl_os << "}"; return _aidl_os.str(); } }; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const DeeplyNested&) const { return std::tie() == std::tie(); } inline bool operator<(const DeeplyNested&) const { return std::tie() < std::tie(); } inline bool operator!=(const DeeplyNested& _rhs) const { return !(*this == _rhs); } inline bool operator>(const DeeplyNested& _rhs) const { return _rhs < *this; } inline bool operator>=(const DeeplyNested& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const DeeplyNested& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "DeeplyNested{"; _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace nested } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { namespace nested { [[nodiscard]] static inline std::string toString(DeeplyNested::B::C::D::E val) { switch(val) { case DeeplyNested::B::C::D::E::OK: return "OK"; default: return std::to_string(static_cast(val)); } } } // namespace nested } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::tests::nested::DeeplyNested::B::C::D::E::OK, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000233 15172120304 033216 xustar000000000 0000000 127 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested/INestedService.h 28 mtime=1776853188.6570000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested0100644 0000000 0000000 00000014163 15172120304 033043 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/nested/INestedService.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/INestedService.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl::android::aidl::tests::nested { class ParcelableWithNested; } // namespace aidl::android::aidl::tests::nested namespace aidl { namespace android { namespace aidl { namespace tests { namespace nested { class INestedServiceDelegator; class INestedService : public ::ndk::ICInterface { public: typedef INestedServiceDelegator DefaultDelegator; static const char* descriptor; INestedService(); virtual ~INestedService(); class Result { public: typedef std::false_type fixed_size; static const char* descriptor; ::aidl::android::aidl::tests::nested::ParcelableWithNested::Status status = ::aidl::android::aidl::tests::nested::ParcelableWithNested::Status::OK; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const Result& _rhs) const { return std::tie(status) == std::tie(_rhs.status); } inline bool operator<(const Result& _rhs) const { return std::tie(status) < std::tie(_rhs.status); } inline bool operator!=(const Result& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Result& _rhs) const { return _rhs < *this; } inline bool operator>=(const Result& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Result& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "Result{"; _aidl_os << "status: " << ::android::internal::ToString(status); _aidl_os << "}"; return _aidl_os.str(); } }; class ICallbackDelegator; class ICallback : public ::ndk::ICInterface { public: typedef ICallbackDelegator DefaultDelegator; static const char* descriptor; ICallback(); virtual ~ICallback(); static constexpr uint32_t TRANSACTION_done = FIRST_CALL_TRANSACTION + 0; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus done(::aidl::android::aidl::tests::nested::ParcelableWithNested::Status in_status) = 0; private: static std::shared_ptr default_impl; }; class ICallbackDefault : public ICallback { public: ::ndk::ScopedAStatus done(::aidl::android::aidl::tests::nested::ParcelableWithNested::Status in_status) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; class BpCallback : public ::ndk::BpCInterface { public: explicit BpCallback(const ::ndk::SpAIBinder& binder); virtual ~BpCallback(); ::ndk::ScopedAStatus done(::aidl::android::aidl::tests::nested::ParcelableWithNested::Status in_status) override; }; class BnCallback : public ::ndk::BnCInterface { public: BnCallback(); virtual ~BnCallback(); protected: ::ndk::SpAIBinder createBinder() override; private: }; static constexpr uint32_t TRANSACTION_flipStatus = FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_flipStatusWithCallback = FIRST_CALL_TRANSACTION + 1; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus flipStatus(const ::aidl::android::aidl::tests::nested::ParcelableWithNested& in_p, ::aidl::android::aidl::tests::nested::INestedService::Result* _aidl_return) = 0; virtual ::ndk::ScopedAStatus flipStatusWithCallback(::aidl::android::aidl::tests::nested::ParcelableWithNested::Status in_status, const std::shared_ptr<::aidl::android::aidl::tests::nested::INestedService::ICallback>& in_cb) = 0; private: static std::shared_ptr default_impl; }; class INestedServiceDefault : public INestedService { public: ::ndk::ScopedAStatus flipStatus(const ::aidl::android::aidl::tests::nested::ParcelableWithNested& in_p, ::aidl::android::aidl::tests::nested::INestedService::Result* _aidl_return) override; ::ndk::ScopedAStatus flipStatusWithCallback(::aidl::android::aidl::tests::nested::ParcelableWithNested::Status in_status, const std::shared_ptr<::aidl::android::aidl::tests::nested::INestedService::ICallback>& in_cb) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; } // namespace nested } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000241 15172120304 033215 xustar000000000 0000000 133 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested/ParcelableWithNested.h 28 mtime=1776853188.6570000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/nested0100644 0000000 0000000 00000007213 15172120304 033041 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/nested/ParcelableWithNested.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace tests { namespace nested { class ParcelableWithNested { public: typedef std::false_type fixed_size; static const char* descriptor; enum class Status : int8_t { OK = 0, NOT_OK = 1, }; ::aidl::android::aidl::tests::nested::ParcelableWithNested::Status status = ::aidl::android::aidl::tests::nested::ParcelableWithNested::Status::OK; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const ParcelableWithNested& _rhs) const { return std::tie(status) == std::tie(_rhs.status); } inline bool operator<(const ParcelableWithNested& _rhs) const { return std::tie(status) < std::tie(_rhs.status); } inline bool operator!=(const ParcelableWithNested& _rhs) const { return !(*this == _rhs); } inline bool operator>(const ParcelableWithNested& _rhs) const { return _rhs < *this; } inline bool operator>=(const ParcelableWithNested& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const ParcelableWithNested& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "ParcelableWithNested{"; _aidl_os << "status: " << ::android::internal::ToString(status); _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace nested } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { namespace nested { [[nodiscard]] static inline std::string toString(ParcelableWithNested::Status val) { switch(val) { case ParcelableWithNested::Status::OK: return "OK"; case ParcelableWithNested::Status::NOT_OK: return "NOT_OK"; default: return std::to_string(static_cast(val)); } } } // namespace nested } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::tests::nested::ParcelableWithNested::Status::OK, aidl::android::aidl::tests::nested::ParcelableWithNested::Status::NOT_OK, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000213 15172120304 033214 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/unions/ 28 mtime=1776853188.6570000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/unions0040755 0000000 0000000 00000000000 15172120304 033070 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000230 15172120304 033213 xustar000000000 0000000 124 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/unions/BnEnumUnion.h 28 mtime=1776853188.6570000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/unions0100644 0000000 0000000 00000001230 15172120304 033063 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/unions/EnumUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000233 15172120304 033216 xustar000000000 0000000 127 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/unions/BnUnionInUnion.h 28 mtime=1776853188.6570000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/unions0100644 0000000 0000000 00000001236 15172120304 033071 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/unions/UnionInUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/UnionInUnion.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000230 15172120304 033213 xustar000000000 0000000 124 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/unions/BpEnumUnion.h 28 mtime=1776853188.6570000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/unions0100644 0000000 0000000 00000001230 15172120304 033063 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/unions/EnumUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000233 15172120304 033216 xustar000000000 0000000 127 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/unions/BpUnionInUnion.h 28 mtime=1776853188.6570000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/unions0100644 0000000 0000000 00000001236 15172120304 033071 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/unions/UnionInUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/UnionInUnion.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000226 15172120304 033220 xustar000000000 0000000 122 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/unions/EnumUnion.h 28 mtime=1776853188.6570000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/unions0100644 0000000 0000000 00000014432 15172120304 033073 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/unions/EnumUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace aidl { namespace android { namespace aidl { namespace tests { namespace unions { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" class EnumUnion { public: typedef std::false_type fixed_size; static const char* descriptor; enum class Tag : int32_t { intEnum = 0, longEnum = 1, deprecatedField __attribute__((deprecated("do not use this"))) = 2, }; // Expose tag symbols for legacy code static const inline Tag intEnum = Tag::intEnum; static const inline Tag longEnum = Tag::longEnum; static const inline Tag __attribute__((deprecated("do not use this"))) deprecatedField = Tag::deprecatedField; template static constexpr bool _not_self = !std::is_same_v>, EnumUnion>; EnumUnion() : _value(std::in_place_index(intEnum)>, ::aidl::android::aidl::tests::IntEnum(::aidl::android::aidl::tests::IntEnum::FOO)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr EnumUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit EnumUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static EnumUnion make(_Tp&&... _args) { return EnumUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static EnumUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return EnumUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } binder_status_t readFromParcel(const AParcel* _parcel); binder_status_t writeToParcel(AParcel* _parcel) const; inline bool operator==(const EnumUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const EnumUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const EnumUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const EnumUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const EnumUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const EnumUnion& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream os; os << "EnumUnion{"; switch (getTag()) { case intEnum: os << "intEnum: " << ::android::internal::ToString(get()); break; case longEnum: os << "longEnum: " << ::android::internal::ToString(get()); break; case deprecatedField: os << "deprecatedField: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant<::aidl::android::aidl::tests::IntEnum, ::aidl::android::aidl::tests::LongEnum, int32_t> _value; }; #pragma clang diagnostic pop } // namespace unions } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { namespace unions { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" [[nodiscard]] static inline std::string toString(EnumUnion::Tag val) { switch(val) { case EnumUnion::Tag::intEnum: return "intEnum"; case EnumUnion::Tag::longEnum: return "longEnum"; case EnumUnion::Tag::deprecatedField: return "deprecatedField"; default: return std::to_string(static_cast(val)); } } #pragma clang diagnostic pop } // namespace unions } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" #pragma clang diagnostic ignored "-Wdeprecated-declarations" template <> constexpr inline std::array enum_values = { aidl::android::aidl::tests::unions::EnumUnion::Tag::intEnum, aidl::android::aidl::tests::unions::EnumUnion::Tag::longEnum, aidl::android::aidl::tests::unions::EnumUnion::Tag::deprecatedField, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_include_aidl_android_a0100644 0000000 0000000 00000000231 15172120304 033214 xustar000000000 0000000 125 path=tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/unions/UnionInUnion.h 28 mtime=1776853188.6580000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/include/aidl/android/aidl/tests/unions0100644 0000000 0000000 00000012764 15172120304 033101 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging/android/aidl/tests/unions/UnionInUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/UnionInUnion.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace aidl { namespace android { namespace aidl { namespace tests { namespace unions { class UnionInUnion { public: typedef std::false_type fixed_size; static const char* descriptor; enum class Tag : int32_t { first = 0, second = 1, }; // Expose tag symbols for legacy code static const inline Tag first = Tag::first; static const inline Tag second = Tag::second; template static constexpr bool _not_self = !std::is_same_v>, UnionInUnion>; UnionInUnion() : _value(std::in_place_index(first)>, ::aidl::android::aidl::tests::unions::EnumUnion()) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr UnionInUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit UnionInUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static UnionInUnion make(_Tp&&... _args) { return UnionInUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static UnionInUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return UnionInUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } binder_status_t readFromParcel(const AParcel* _parcel); binder_status_t writeToParcel(AParcel* _parcel) const; inline bool operator==(const UnionInUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const UnionInUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const UnionInUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const UnionInUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const UnionInUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const UnionInUnion& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream os; os << "UnionInUnion{"; switch (getTag()) { case first: os << "first: " << ::android::internal::ToString(get()); break; case second: os << "second: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant<::aidl::android::aidl::tests::unions::EnumUnion, int32_t> _value; }; } // namespace unions } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace tests { namespace unions { [[nodiscard]] static inline std::string toString(UnionInUnion::Tag val) { switch(val) { case UnionInUnion::Tag::first: return "first"; case UnionInUnion::Tag::second: return "second"; default: return std::to_string(static_cast(val)); } } } // namespace unions } // namespace tests } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::tests::unions::UnionInUnion::Tag::first, aidl::android::aidl::tests::unions::UnionInUnion::Tag::second, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-ndk-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 030604 xustar000000000 0000000 28 mtime=1776853188.6580000 tests/golden_output/frozen/aidl-test-interface-ndk-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 025516 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-permission-java-source_0100644 0000000 0000000 00000000034 15172120304 030362 xustar000000000 0000000 28 mtime=1776853188.6580000 tests/golden_output/frozen/aidl-test-interface-permission-java-source/0040755 0000000 0000000 00000000000 15172120304 025367 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-permission-java-source_gen_0100644 0000000 0000000 00000000034 15172120304 031213 xustar000000000 0000000 28 mtime=1776853188.6590000 tests/golden_output/frozen/aidl-test-interface-permission-java-source/gen/0040755 0000000 0000000 00000000000 15172120304 026140 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-permission-java-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 032713 xustar000000000 0000000 28 mtime=1776853188.6590000 tests/golden_output/frozen/aidl-test-interface-permission-java-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 027560 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-permission-java-source_gen_android_ai0100644 0000000 0000000 00000000034 15172120304 033225 xustar000000000 0000000 28 mtime=1776853188.6590000 tests/golden_output/frozen/aidl-test-interface-permission-java-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 030471 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-permission-java-source_gen_android_ai0100644 0000000 0000000 00000000034 15172120304 033225 xustar000000000 0000000 28 mtime=1776853188.6590000 tests/golden_output/frozen/aidl-test-interface-permission-java-source/gen/android/aidl/tests/0040755 0000000 0000000 00000000000 15172120304 031633 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-permission-java-source_gen_android_ai0100644 0000000 0000000 00000000216 15172120304 033227 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/ 28 mtime=1776853188.6590000 tests/golden_output/frozen/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permiss0040755 0000000 0000000 00000000000 15172120304 033236 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-permission-java-source_gen_android_ai0100644 0000000 0000000 00000000240 15172120304 033224 xustar000000000 0000000 132 path=tests/golden_output/frozen/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/INoPermission.java 28 mtime=1776853188.6590000 tests/golden_output/frozen/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permiss0100644 0000000 0000000 00000010662 15172120304 033242 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/INoPermission.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-permission-java-source/gen -Iframeworks/base/core/java -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/permission/INoPermission.aidl */ package android.aidl.tests.permission; public interface INoPermission extends android.os.IInterface { /** Default implementation for INoPermission. */ public static class Default implements android.aidl.tests.permission.INoPermission { @Override public void foo() throws android.os.RemoteException { } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.permission.INoPermission { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.tests.permission.INoPermission interface, * generating a proxy if needed. */ public static android.aidl.tests.permission.INoPermission asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.permission.INoPermission))) { return ((android.aidl.tests.permission.INoPermission)iin); } return new android.aidl.tests.permission.INoPermission.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_foo: { return "foo"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_foo: { this.foo(); reply.writeNoException(); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.permission.INoPermission { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public void foo() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_foo, _data, _reply, 0); _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } } static final int TRANSACTION_foo = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.permission.INoPermission"; @android.annotation.RequiresNoPermission public void foo() throws android.os.RemoteException; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-permission-java-source_gen_android_ai0100644 0000000 0000000 00000000242 15172120304 033226 xustar000000000 0000000 134 path=tests/golden_output/frozen/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/INoPermission.java.d 28 mtime=1776853188.6600000 tests/golden_output/frozen/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permiss0100644 0000000 0000000 00000000332 15172120304 033233 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/INoPermission.java : \ system/tools/aidl/tests/android/aidl/tests/permission/INoPermission.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-permission-java-source_gen_android_ai0100644 0000000 0000000 00000000235 15172120304 033230 xustar000000000 0000000 129 path=tests/golden_output/frozen/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/IProtected.java 28 mtime=1776853188.6600000 tests/golden_output/frozen/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permiss0100644 0000000 0000000 00000033010 15172120304 033232 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/IProtected.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-permission-java-source/gen -Iframeworks/base/core/java -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/permission/IProtected.aidl */ package android.aidl.tests.permission; public interface IProtected extends android.os.IInterface { /** Default implementation for IProtected. */ public static class Default implements android.aidl.tests.permission.IProtected { @Override public void PermissionProtected() throws android.os.RemoteException { } @Override public void MultiplePermissionsAll() throws android.os.RemoteException { } @Override public void MultiplePermissionsAny() throws android.os.RemoteException { } @Override public void NonManifestPermission() throws android.os.RemoteException { } // Used by the integration tests to dynamically set permissions that are considered granted. @Override public void Grant(java.lang.String permission) throws android.os.RemoteException { } @Override public void Revoke(java.lang.String permission) throws android.os.RemoteException { } @Override public void RevokeAll() throws android.os.RemoteException { } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.permission.IProtected { private final android.os.PermissionEnforcer mEnforcer; /** Construct the stub using the Enforcer provided. */ public Stub(android.os.PermissionEnforcer enforcer) { this.attachInterface(this, DESCRIPTOR); if (enforcer == null) { throw new IllegalArgumentException("enforcer cannot be null"); } mEnforcer = enforcer; } @Deprecated /** Default constructor. */ public Stub() { this(android.os.PermissionEnforcer.fromContext( android.app.ActivityThread.currentActivityThread().getSystemContext())); } /** * Cast an IBinder object into an android.aidl.tests.permission.IProtected interface, * generating a proxy if needed. */ public static android.aidl.tests.permission.IProtected asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.permission.IProtected))) { return ((android.aidl.tests.permission.IProtected)iin); } return new android.aidl.tests.permission.IProtected.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_PermissionProtected: { return "PermissionProtected"; } case TRANSACTION_MultiplePermissionsAll: { return "MultiplePermissionsAll"; } case TRANSACTION_MultiplePermissionsAny: { return "MultiplePermissionsAny"; } case TRANSACTION_NonManifestPermission: { return "NonManifestPermission"; } case TRANSACTION_Grant: { return "Grant"; } case TRANSACTION_Revoke: { return "Revoke"; } case TRANSACTION_RevokeAll: { return "RevokeAll"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_PermissionProtected: { this.PermissionProtected(); reply.writeNoException(); break; } case TRANSACTION_MultiplePermissionsAll: { this.MultiplePermissionsAll(); reply.writeNoException(); break; } case TRANSACTION_MultiplePermissionsAny: { this.MultiplePermissionsAny(); reply.writeNoException(); break; } case TRANSACTION_NonManifestPermission: { this.NonManifestPermission(); reply.writeNoException(); break; } case TRANSACTION_Grant: { java.lang.String _arg0; _arg0 = data.readString(); data.enforceNoDataAvail(); this.Grant(_arg0); reply.writeNoException(); break; } case TRANSACTION_Revoke: { java.lang.String _arg0; _arg0 = data.readString(); data.enforceNoDataAvail(); this.Revoke(_arg0); reply.writeNoException(); break; } case TRANSACTION_RevokeAll: { this.RevokeAll(); reply.writeNoException(); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.permission.IProtected { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public void PermissionProtected() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_PermissionProtected, _data, _reply, 0); _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } @Override public void MultiplePermissionsAll() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_MultiplePermissionsAll, _data, _reply, 0); _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } @Override public void MultiplePermissionsAny() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_MultiplePermissionsAny, _data, _reply, 0); _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } @Override public void NonManifestPermission() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_NonManifestPermission, _data, _reply, 0); _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } // Used by the integration tests to dynamically set permissions that are considered granted. @Override public void Grant(java.lang.String permission) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeString(permission); boolean _status = mRemote.transact(Stub.TRANSACTION_Grant, _data, _reply, 0); _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } @Override public void Revoke(java.lang.String permission) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeString(permission); boolean _status = mRemote.transact(Stub.TRANSACTION_Revoke, _data, _reply, 0); _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } @Override public void RevokeAll() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_RevokeAll, _data, _reply, 0); _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } } static final int TRANSACTION_PermissionProtected = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); /** Helper method to enforce permissions for PermissionProtected */ protected void PermissionProtected_enforcePermission() throws SecurityException { mEnforcer.enforcePermission(android.Manifest.permission.READ_PHONE_STATE, getCallingPid(), getCallingUid()); } static final int TRANSACTION_MultiplePermissionsAll = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1); static final String[] PERMISSIONS_MultiplePermissionsAll = {android.Manifest.permission.INTERNET, android.Manifest.permission.VIBRATE}; /** Helper method to enforce permissions for MultiplePermissionsAll */ protected void MultiplePermissionsAll_enforcePermission() throws SecurityException { mEnforcer.enforcePermissionAllOf(PERMISSIONS_MultiplePermissionsAll, getCallingPid(), getCallingUid()); } static final int TRANSACTION_MultiplePermissionsAny = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2); static final String[] PERMISSIONS_MultiplePermissionsAny = {android.Manifest.permission.INTERNET, android.Manifest.permission.VIBRATE}; /** Helper method to enforce permissions for MultiplePermissionsAny */ protected void MultiplePermissionsAny_enforcePermission() throws SecurityException { mEnforcer.enforcePermissionAnyOf(PERMISSIONS_MultiplePermissionsAny, getCallingPid(), getCallingUid()); } static final int TRANSACTION_NonManifestPermission = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3); /** Helper method to enforce permissions for NonManifestPermission */ protected void NonManifestPermission_enforcePermission() throws SecurityException { mEnforcer.enforcePermission(android.net.NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK, getCallingPid(), getCallingUid()); } static final int TRANSACTION_Grant = (android.os.IBinder.FIRST_CALL_TRANSACTION + 4); static final int TRANSACTION_Revoke = (android.os.IBinder.FIRST_CALL_TRANSACTION + 5); static final int TRANSACTION_RevokeAll = (android.os.IBinder.FIRST_CALL_TRANSACTION + 6); /** @hide */ public int getMaxTransactionId() { return 6; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.permission.IProtected"; @android.annotation.EnforcePermission(android.Manifest.permission.READ_PHONE_STATE) public void PermissionProtected() throws android.os.RemoteException; @android.annotation.EnforcePermission(allOf = {android.Manifest.permission.INTERNET, android.Manifest.permission.VIBRATE}) public void MultiplePermissionsAll() throws android.os.RemoteException; @android.annotation.EnforcePermission(anyOf = {android.Manifest.permission.INTERNET, android.Manifest.permission.VIBRATE}) public void MultiplePermissionsAny() throws android.os.RemoteException; @android.annotation.EnforcePermission(android.net.NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK) public void NonManifestPermission() throws android.os.RemoteException; // Used by the integration tests to dynamically set permissions that are considered granted. @android.annotation.RequiresNoPermission public void Grant(java.lang.String permission) throws android.os.RemoteException; @android.annotation.RequiresNoPermission public void Revoke(java.lang.String permission) throws android.os.RemoteException; @android.annotation.RequiresNoPermission public void RevokeAll() throws android.os.RemoteException; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-permission-java-source_gen_android_ai0100644 0000000 0000000 00000000237 15172120304 033232 xustar000000000 0000000 131 path=tests/golden_output/frozen/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/IProtected.java.d 28 mtime=1776853188.6600000 tests/golden_output/frozen/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permiss0100644 0000000 0000000 00000000324 15172120304 033234 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/IProtected.java : \ system/tools/aidl/tests/android/aidl/tests/permission/IProtected.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-permission-java-source_gen_android_ai0100644 0000000 0000000 00000000246 15172120304 033232 xustar000000000 0000000 138 path=tests/golden_output/frozen/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/IProtectedInterface.java 28 mtime=1776853188.6600000 tests/golden_output/frozen/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permiss0100644 0000000 0000000 00000014777 15172120304 033255 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/IProtectedInterface.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-permission-java-source/gen -Iframeworks/base/core/java -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/permission/IProtectedInterface.aidl */ package android.aidl.tests.permission; public interface IProtectedInterface extends android.os.IInterface { /** Default implementation for IProtectedInterface. */ public static class Default implements android.aidl.tests.permission.IProtectedInterface { @Override public void Method1() throws android.os.RemoteException { } @Override public void Method2() throws android.os.RemoteException { } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.permission.IProtectedInterface { private final android.os.PermissionEnforcer mEnforcer; /** Construct the stub using the Enforcer provided. */ public Stub(android.os.PermissionEnforcer enforcer) { this.attachInterface(this, DESCRIPTOR); if (enforcer == null) { throw new IllegalArgumentException("enforcer cannot be null"); } mEnforcer = enforcer; } @Deprecated /** Default constructor. */ public Stub() { this(android.os.PermissionEnforcer.fromContext( android.app.ActivityThread.currentActivityThread().getSystemContext())); } /** * Cast an IBinder object into an android.aidl.tests.permission.IProtectedInterface interface, * generating a proxy if needed. */ public static android.aidl.tests.permission.IProtectedInterface asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.permission.IProtectedInterface))) { return ((android.aidl.tests.permission.IProtectedInterface)iin); } return new android.aidl.tests.permission.IProtectedInterface.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_Method1: { return "Method1"; } case TRANSACTION_Method2: { return "Method2"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_Method1: { this.Method1(); reply.writeNoException(); break; } case TRANSACTION_Method2: { this.Method2(); reply.writeNoException(); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.permission.IProtectedInterface { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public void Method1() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_Method1, _data, _reply, 0); _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } @Override public void Method2() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_Method2, _data, _reply, 0); _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } } static final int TRANSACTION_Method1 = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); /** Helper method to enforce permissions for Method1 */ protected void Method1_enforcePermission() throws SecurityException { mEnforcer.enforcePermission(android.Manifest.permission.ACCESS_FINE_LOCATION, getCallingPid(), getCallingUid()); } static final int TRANSACTION_Method2 = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1); /** Helper method to enforce permissions for Method2 */ protected void Method2_enforcePermission() throws SecurityException { mEnforcer.enforcePermission(android.Manifest.permission.ACCESS_FINE_LOCATION, getCallingPid(), getCallingUid()); } /** @hide */ public int getMaxTransactionId() { return 1; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.permission.IProtectedInterface"; @android.annotation.EnforcePermission(android.Manifest.permission.ACCESS_FINE_LOCATION) public void Method1() throws android.os.RemoteException; @android.annotation.EnforcePermission(android.Manifest.permission.ACCESS_FINE_LOCATION) public void Method2() throws android.os.RemoteException; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-permission-java-source_gen_android_ai0100644 0000000 0000000 00000000250 15172120304 033225 xustar000000000 0000000 140 path=tests/golden_output/frozen/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/IProtectedInterface.java.d 28 mtime=1776853188.6600000 tests/golden_output/frozen/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permiss0100644 0000000 0000000 00000000346 15172120304 033240 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/IProtectedInterface.java : \ system/tools/aidl/tests/android/aidl/tests/permission/IProtectedInterface.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-permission-java-source_gen_android_ai0100644 0000000 0000000 00000000227 15172120304 033231 xustar000000000 0000000 123 path=tests/golden_output/frozen/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/platform/ 28 mtime=1776853188.6610000 tests/golden_output/frozen/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permiss0040755 0000000 0000000 00000000000 15172120304 033236 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-permission-java-source_gen_android_ai0100644 0000000 0000000 00000000246 15172120304 033232 xustar000000000 0000000 138 path=tests/golden_output/frozen/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/platform/IProtected.java 28 mtime=1776853188.6610000 tests/golden_output/frozen/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permiss0100644 0000000 0000000 00000013752 15172120304 033245 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/platform/IProtected.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-permission-java-source/gen -Iframeworks/base/core/java -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/permission/platform/IProtected.aidl */ package android.aidl.tests.permission.platform; public interface IProtected extends android.os.IInterface { /** Default implementation for IProtected. */ public static class Default implements android.aidl.tests.permission.platform.IProtected { @Override public void ProtectedWithSourceAttribution(android.content.AttributionSource source) throws android.os.RemoteException { } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.tests.permission.platform.IProtected { private final android.os.PermissionEnforcer mEnforcer; /** Construct the stub using the Enforcer provided. */ public Stub(android.os.PermissionEnforcer enforcer) { this.attachInterface(this, DESCRIPTOR); if (enforcer == null) { throw new IllegalArgumentException("enforcer cannot be null"); } mEnforcer = enforcer; } @Deprecated /** Default constructor. */ public Stub() { this(android.os.PermissionEnforcer.fromContext( android.app.ActivityThread.currentActivityThread().getSystemContext())); } /** * Cast an IBinder object into an android.aidl.tests.permission.platform.IProtected interface, * generating a proxy if needed. */ public static android.aidl.tests.permission.platform.IProtected asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.tests.permission.platform.IProtected))) { return ((android.aidl.tests.permission.platform.IProtected)iin); } return new android.aidl.tests.permission.platform.IProtected.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_ProtectedWithSourceAttribution: { return "ProtectedWithSourceAttribution"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_ProtectedWithSourceAttribution: { android.content.AttributionSource _arg0; _arg0 = data.readTypedObject(android.content.AttributionSource.CREATOR); data.enforceNoDataAvail(); this.ProtectedWithSourceAttribution(_arg0); reply.writeNoException(); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.tests.permission.platform.IProtected { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public void ProtectedWithSourceAttribution(android.content.AttributionSource source) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(source, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_ProtectedWithSourceAttribution, _data, _reply, 0); _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } } static final int TRANSACTION_ProtectedWithSourceAttribution = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); static final String[] PERMISSIONS_ProtectedWithSourceAttribution = {android.Manifest.permission.INTERNET, android.Manifest.permission.VIBRATE}; /** Helper method to enforce permissions for ProtectedWithSourceAttribution */ protected void ProtectedWithSourceAttribution_enforcePermission() throws SecurityException { mEnforcer.enforcePermissionAllOf(PERMISSIONS_ProtectedWithSourceAttribution, getCallingPid(), getCallingUid()); } /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.tests.permission.platform.IProtected"; @android.annotation.EnforcePermission(allOf = {android.Manifest.permission.INTERNET, android.Manifest.permission.VIBRATE}) public void ProtectedWithSourceAttribution(android.content.AttributionSource source) throws android.os.RemoteException; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-permission-java-source_gen_android_ai0100644 0000000 0000000 00000000250 15172120304 033225 xustar000000000 0000000 140 path=tests/golden_output/frozen/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/platform/IProtected.java.d 28 mtime=1776853188.6610000 tests/golden_output/frozen/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permiss0100644 0000000 0000000 00000000453 15172120304 033237 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-permission-java-source/gen/android/aidl/tests/permission/platform/IProtected.java : \ system/tools/aidl/tests/android/aidl/tests/permission/platform/IProtected.aidl \ frameworks/base/core/java/android/content/AttributionSource.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-permission-java-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 033137 xustar000000000 0000000 28 mtime=1776853188.6610000 tests/golden_output/frozen/aidl-test-interface-permission-java-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 030051 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_0100644 0000000 0000000 00000000034 15172120304 026250 xustar000000000 0000000 28 mtime=1776853188.6610000 tests/golden_output/frozen/aidl-test-interface-rust-source/0040755 0000000 0000000 00000000000 15172120304 023255 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_0100644 0000000 0000000 00000000034 15172120304 027101 xustar000000000 0000000 28 mtime=1776853188.6610000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/0040755 0000000 0000000 00000000000 15172120304 024026 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 030601 xustar000000000 0000000 28 mtime=1776853188.6610000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 025446 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 031572 xustar000000000 0000000 28 mtime=1776853188.6610000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 026357 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_0100644 0000000 0000000 00000000034 15172120304 033014 xustar000000000 0000000 28 mtime=1776853188.6610000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/0040755 0000000 0000000 00000000000 15172120304 027521 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_Ar0100644 0000000 0000000 00000000214 15172120304 033277 xustar000000000 0000000 112 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/ArrayOfInterfaces.rs 28 mtime=1776853188.6610000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/ArrayOfInterfaces.0100644 0000000 0000000 00000101403 15172120304 033065 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/ArrayOfInterfaces.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ArrayOfInterfaces.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub struct r#ArrayOfInterfaces { } impl Default for r#ArrayOfInterfaces { fn default() -> Self { Self { } } } impl binder::Parcelable for r#ArrayOfInterfaces { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#ArrayOfInterfaces); binder::impl_deserialize_for_parcelable!(r#ArrayOfInterfaces); impl binder::binder_impl::ParcelableMetadata for r#ArrayOfInterfaces { fn get_descriptor() -> &'static str { "android.aidl.tests.ArrayOfInterfaces" } } pub mod r#IEmptyInterface { #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { IEmptyInterface["android.aidl.tests.ArrayOfInterfaces.IEmptyInterface"] { native: BnEmptyInterface(on_transact), proxy: BpEmptyInterface { }, async: IEmptyInterfaceAsync, } } pub trait IEmptyInterface: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ArrayOfInterfaces.IEmptyInterface" } fn getDefaultImpl() -> IEmptyInterfaceDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: IEmptyInterfaceDefaultRef) -> IEmptyInterfaceDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait IEmptyInterfaceAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ArrayOfInterfaces.IEmptyInterface" } } #[::async_trait::async_trait] pub trait IEmptyInterfaceAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ArrayOfInterfaces.IEmptyInterface" } } impl BnEmptyInterface { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: IEmptyInterfaceAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl IEmptyInterface for Wrapper where T: IEmptyInterfaceAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait IEmptyInterfaceDefault: Send + Sync { } pub mod transactions { } pub type IEmptyInterfaceDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); impl BpEmptyInterface { } impl IEmptyInterface for BpEmptyInterface { } impl IEmptyInterfaceAsync

for BpEmptyInterface { } impl IEmptyInterface for binder::binder_impl::Binder { } fn on_transact(_aidl_service: &dyn IEmptyInterface, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } } pub mod r#IMyInterface { #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { IMyInterface["android.aidl.tests.ArrayOfInterfaces.IMyInterface"] { native: BnMyInterface(on_transact), proxy: BpMyInterface { }, async: IMyInterfaceAsync, } } pub trait IMyInterface: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ArrayOfInterfaces.IMyInterface" } fn r#methodWithInterfaces(&self, _arg_iface: &binder::Strong, _arg_nullable_iface: Option<&binder::Strong>, _arg_iface_array_in: &[binder::Strong], _arg_iface_array_out: &mut Vec>>, _arg_iface_array_inout: &mut Vec>, _arg_nullable_iface_array_in: Option<&[Option>]>, _arg_nullable_iface_array_out: &mut Option>>>, _arg_nullable_iface_array_inout: &mut Option>>>) -> binder::Result>>>>; fn getDefaultImpl() -> IMyInterfaceDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: IMyInterfaceDefaultRef) -> IMyInterfaceDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait IMyInterfaceAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ArrayOfInterfaces.IMyInterface" } fn r#methodWithInterfaces<'a>(&'a self, _arg_iface: &'a binder::Strong, _arg_nullable_iface: Option<&'a binder::Strong>, _arg_iface_array_in: &'a [binder::Strong], _arg_iface_array_out: &'a mut Vec>>, _arg_iface_array_inout: &'a mut Vec>, _arg_nullable_iface_array_in: Option<&'a [Option>]>, _arg_nullable_iface_array_out: &'a mut Option>>>, _arg_nullable_iface_array_inout: &'a mut Option>>>) -> binder::BoxFuture<'a, binder::Result>>>>>; } #[::async_trait::async_trait] pub trait IMyInterfaceAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ArrayOfInterfaces.IMyInterface" } async fn r#methodWithInterfaces(&self, _arg_iface: &binder::Strong, _arg_nullable_iface: Option<&binder::Strong>, _arg_iface_array_in: &[binder::Strong], _arg_iface_array_out: &mut Vec>>, _arg_iface_array_inout: &mut Vec>, _arg_nullable_iface_array_in: Option<&[Option>]>, _arg_nullable_iface_array_out: &mut Option>>>, _arg_nullable_iface_array_inout: &mut Option>>>) -> binder::Result>>>>; } impl BnMyInterface { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: IMyInterfaceAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl IMyInterface for Wrapper where T: IMyInterfaceAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#methodWithInterfaces(&self, _arg_iface: &binder::Strong, _arg_nullable_iface: Option<&binder::Strong>, _arg_iface_array_in: &[binder::Strong], _arg_iface_array_out: &mut Vec>>, _arg_iface_array_inout: &mut Vec>, _arg_nullable_iface_array_in: Option<&[Option>]>, _arg_nullable_iface_array_out: &mut Option>>>, _arg_nullable_iface_array_inout: &mut Option>>>) -> binder::Result>>>> { self._rt.block_on(self._inner.r#methodWithInterfaces(_arg_iface, _arg_nullable_iface, _arg_iface_array_in, _arg_iface_array_out, _arg_iface_array_inout, _arg_nullable_iface_array_in, _arg_nullable_iface_array_out, _arg_nullable_iface_array_inout)) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait IMyInterfaceDefault: Send + Sync { fn r#methodWithInterfaces(&self, _arg_iface: &binder::Strong, _arg_nullable_iface: Option<&binder::Strong>, _arg_iface_array_in: &[binder::Strong], _arg_iface_array_out: &mut Vec>>, _arg_iface_array_inout: &mut Vec>, _arg_nullable_iface_array_in: Option<&[Option>]>, _arg_nullable_iface_array_out: &mut Option>>>, _arg_nullable_iface_array_inout: &mut Option>>>) -> binder::Result>>>> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#methodWithInterfaces: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; } pub type IMyInterfaceDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); impl BpMyInterface { fn build_parcel_methodWithInterfaces(&self, _arg_iface: &binder::Strong, _arg_nullable_iface: Option<&binder::Strong>, _arg_iface_array_in: &[binder::Strong], _arg_iface_array_out: &mut Vec>>, _arg_iface_array_inout: &mut Vec>, _arg_nullable_iface_array_in: Option<&[Option>]>, _arg_nullable_iface_array_out: &mut Option>>>, _arg_nullable_iface_array_inout: &mut Option>>>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_iface)?; aidl_data.write(&_arg_nullable_iface)?; aidl_data.write(_arg_iface_array_in)?; aidl_data.write_slice_size(Some(_arg_iface_array_out))?; aidl_data.write(_arg_iface_array_inout)?; aidl_data.write(&_arg_nullable_iface_array_in)?; aidl_data.write_slice_size(_arg_nullable_iface_array_out.as_deref())?; aidl_data.write(_arg_nullable_iface_array_inout)?; Ok(aidl_data) } fn read_response_methodWithInterfaces(&self, _arg_iface: &binder::Strong, _arg_nullable_iface: Option<&binder::Strong>, _arg_iface_array_in: &[binder::Strong], _arg_iface_array_out: &mut Vec>>, _arg_iface_array_inout: &mut Vec>, _arg_nullable_iface_array_in: Option<&[Option>]>, _arg_nullable_iface_array_out: &mut Option>>>, _arg_nullable_iface_array_inout: &mut Option>>>, _aidl_reply: std::result::Result) -> binder::Result>>>> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#methodWithInterfaces(_arg_iface, _arg_nullable_iface, _arg_iface_array_in, _arg_iface_array_out, _arg_iface_array_inout, _arg_nullable_iface_array_in, _arg_nullable_iface_array_out, _arg_nullable_iface_array_inout); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option>>> = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_iface_array_out)?; _aidl_reply.read_onto(_arg_iface_array_inout)?; _aidl_reply.read_onto(_arg_nullable_iface_array_out)?; _aidl_reply.read_onto(_arg_nullable_iface_array_inout)?; Ok(_aidl_return) } } impl IMyInterface for BpMyInterface { fn r#methodWithInterfaces(&self, _arg_iface: &binder::Strong, _arg_nullable_iface: Option<&binder::Strong>, _arg_iface_array_in: &[binder::Strong], _arg_iface_array_out: &mut Vec>>, _arg_iface_array_inout: &mut Vec>, _arg_nullable_iface_array_in: Option<&[Option>]>, _arg_nullable_iface_array_out: &mut Option>>>, _arg_nullable_iface_array_inout: &mut Option>>>) -> binder::Result>>>> { let _aidl_data = self.build_parcel_methodWithInterfaces(_arg_iface, _arg_nullable_iface, _arg_iface_array_in, _arg_iface_array_out, _arg_iface_array_inout, _arg_nullable_iface_array_in, _arg_nullable_iface_array_out, _arg_nullable_iface_array_inout)?; let _aidl_reply = self.binder.submit_transact(transactions::r#methodWithInterfaces, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_methodWithInterfaces(_arg_iface, _arg_nullable_iface, _arg_iface_array_in, _arg_iface_array_out, _arg_iface_array_inout, _arg_nullable_iface_array_in, _arg_nullable_iface_array_out, _arg_nullable_iface_array_inout, _aidl_reply) } } impl IMyInterfaceAsync

for BpMyInterface { fn r#methodWithInterfaces<'a>(&'a self, _arg_iface: &'a binder::Strong, _arg_nullable_iface: Option<&'a binder::Strong>, _arg_iface_array_in: &'a [binder::Strong], _arg_iface_array_out: &'a mut Vec>>, _arg_iface_array_inout: &'a mut Vec>, _arg_nullable_iface_array_in: Option<&'a [Option>]>, _arg_nullable_iface_array_out: &'a mut Option>>>, _arg_nullable_iface_array_inout: &'a mut Option>>>) -> binder::BoxFuture<'a, binder::Result>>>>> { let _aidl_data = match self.build_parcel_methodWithInterfaces(_arg_iface, _arg_nullable_iface, _arg_iface_array_in, _arg_iface_array_out, _arg_iface_array_inout, _arg_nullable_iface_array_in, _arg_nullable_iface_array_out, _arg_nullable_iface_array_inout) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#methodWithInterfaces, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_methodWithInterfaces(_arg_iface, _arg_nullable_iface, _arg_iface_array_in, _arg_iface_array_out, _arg_iface_array_inout, _arg_nullable_iface_array_in, _arg_nullable_iface_array_out, _arg_nullable_iface_array_inout, _aidl_reply) } ) } } impl IMyInterface for binder::binder_impl::Binder { fn r#methodWithInterfaces(&self, _arg_iface: &binder::Strong, _arg_nullable_iface: Option<&binder::Strong>, _arg_iface_array_in: &[binder::Strong], _arg_iface_array_out: &mut Vec>>, _arg_iface_array_inout: &mut Vec>, _arg_nullable_iface_array_in: Option<&[Option>]>, _arg_nullable_iface_array_out: &mut Option>>>, _arg_nullable_iface_array_inout: &mut Option>>>) -> binder::Result>>>> { self.0.r#methodWithInterfaces(_arg_iface, _arg_nullable_iface, _arg_iface_array_in, _arg_iface_array_out, _arg_iface_array_inout, _arg_nullable_iface_array_in, _arg_nullable_iface_array_out, _arg_nullable_iface_array_inout) } } fn on_transact(_aidl_service: &dyn IMyInterface, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#methodWithInterfaces => { let _arg_iface: binder::Strong = _aidl_data.read()?; let _arg_nullable_iface: Option> = _aidl_data.read()?; let _arg_iface_array_in: Vec> = _aidl_data.read()?; let mut _arg_iface_array_out: Vec>> = Default::default(); _aidl_data.resize_out_vec(&mut _arg_iface_array_out)?; let mut _arg_iface_array_inout: Vec> = _aidl_data.read()?; let _arg_nullable_iface_array_in: Option>>> = _aidl_data.read()?; let mut _arg_nullable_iface_array_out: Option>>> = Default::default(); _aidl_data.resize_nullable_out_vec(&mut _arg_nullable_iface_array_out)?; let mut _arg_nullable_iface_array_inout: Option>>> = _aidl_data.read()?; let _aidl_return = _aidl_service.r#methodWithInterfaces(&_arg_iface, _arg_nullable_iface.as_ref(), &_arg_iface_array_in, &mut _arg_iface_array_out, &mut _arg_iface_array_inout, _arg_nullable_iface_array_in.as_deref(), &mut _arg_nullable_iface_array_out, &mut _arg_nullable_iface_array_inout); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_iface_array_out)?; _aidl_reply.write(&_arg_iface_array_inout)?; _aidl_reply.write(&_arg_nullable_iface_array_out)?; _aidl_reply.write(&_arg_nullable_iface_array_inout)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } } pub mod r#MyParcelable { #[derive(Debug)] pub struct r#MyParcelable { pub r#iface: Option>, pub r#nullable_iface: Option>, pub r#iface_array: Vec>, pub r#nullable_iface_array: Option>>>, } impl Default for r#MyParcelable { fn default() -> Self { Self { r#iface: Default::default(), r#nullable_iface: Default::default(), r#iface_array: Default::default(), r#nullable_iface_array: Default::default(), } } } impl binder::Parcelable for r#MyParcelable { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { let __field_ref = self.r#iface.as_ref().ok_or(binder::StatusCode::UNEXPECTED_NULL)?; subparcel.write(__field_ref)?; subparcel.write(&self.r#nullable_iface)?; subparcel.write(&self.r#iface_array)?; subparcel.write(&self.r#nullable_iface_array)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#iface = Some(subparcel.read()?); } if subparcel.has_more_data() { self.r#nullable_iface = subparcel.read()?; } if subparcel.has_more_data() { self.r#iface_array = subparcel.read()?; } if subparcel.has_more_data() { self.r#nullable_iface_array = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#MyParcelable); binder::impl_deserialize_for_parcelable!(r#MyParcelable); impl binder::binder_impl::ParcelableMetadata for r#MyParcelable { fn get_descriptor() -> &'static str { "android.aidl.tests.ArrayOfInterfaces.MyParcelable" } } } pub mod r#MyUnion { #[derive(Debug)] pub enum r#MyUnion { Iface(Option>), Nullable_iface(Option>), Iface_array(Vec>), Nullable_iface_array(Option>>>), } impl Default for r#MyUnion { fn default() -> Self { Self::Iface(Default::default()) } } impl binder::Parcelable for r#MyUnion { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { match self { Self::Iface(v) => { parcel.write(&0i32)?; let __field_ref = v.as_ref().ok_or(binder::StatusCode::UNEXPECTED_NULL)?; parcel.write(__field_ref) } Self::Nullable_iface(v) => { parcel.write(&1i32)?; parcel.write(v) } Self::Iface_array(v) => { parcel.write(&2i32)?; parcel.write(v) } Self::Nullable_iface_array(v) => { parcel.write(&3i32)?; parcel.write(v) } } } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { let tag: i32 = parcel.read()?; match tag { 0 => { let value: Option> = Some(parcel.read()?); *self = Self::Iface(value); Ok(()) } 1 => { let value: Option> = parcel.read()?; *self = Self::Nullable_iface(value); Ok(()) } 2 => { let value: Vec> = parcel.read()?; *self = Self::Iface_array(value); Ok(()) } 3 => { let value: Option>>> = parcel.read()?; *self = Self::Nullable_iface_array(value); Ok(()) } _ => { Err(binder::StatusCode::BAD_VALUE) } } } } binder::impl_serialize_for_parcelable!(r#MyUnion); binder::impl_deserialize_for_parcelable!(r#MyUnion); impl binder::binder_impl::ParcelableMetadata for r#MyUnion { fn get_descriptor() -> &'static str { "android.aidl.tests.ArrayOfInterfaces.MyUnion" } } pub mod r#Tag { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#Tag : [i32; 4] { r#iface = 0, r#nullable_iface = 1, r#iface_array = 2, r#nullable_iface_array = 3, } } } } pub(crate) mod mangled { pub use super::r#ArrayOfInterfaces as _7_android_4_aidl_5_tests_17_ArrayOfInterfaces; pub use super::r#IEmptyInterface::r#IEmptyInterface as _7_android_4_aidl_5_tests_17_ArrayOfInterfaces_15_IEmptyInterface; pub use super::r#IMyInterface::r#IMyInterface as _7_android_4_aidl_5_tests_17_ArrayOfInterfaces_12_IMyInterface; pub use super::r#MyParcelable::r#MyParcelable as _7_android_4_aidl_5_tests_17_ArrayOfInterfaces_12_MyParcelable; pub use super::r#MyUnion::r#MyUnion as _7_android_4_aidl_5_tests_17_ArrayOfInterfaces_7_MyUnion; pub use super::r#MyUnion::r#Tag::r#Tag as _7_android_4_aidl_5_tests_17_ArrayOfInterfaces_7_MyUnion_3_Tag; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_Ar0100644 0000000 0000000 00000000216 15172120304 033301 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/ArrayOfInterfaces.rs.d 28 mtime=1776853188.6620000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/ArrayOfInterfaces.0100644 0000000 0000000 00000000277 15172120304 033074 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/ArrayOfInterfaces.rs : \ system/tools/aidl/tests/android/aidl/tests/ArrayOfInterfaces.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_Ba0100644 0000000 0000000 00000000034 15172120304 033257 xustar000000000 0000000 28 mtime=1776853188.6620000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/BackendType.rs0100644 0000000 0000000 00000001475 15172120304 032264 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/BackendType.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/BackendType.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#BackendType : [i8; 4] { r#CPP = 0, r#JAVA = 1, r#NDK = 2, r#RUST = 3, } } pub(crate) mod mangled { pub use super::r#BackendType as _7_android_4_aidl_5_tests_11_BackendType; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_Ba0100644 0000000 0000000 00000000034 15172120304 033257 xustar000000000 0000000 28 mtime=1776853188.6620000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/BackendType.rs.d0100644 0000000 0000000 00000000263 15172120304 032500 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/BackendType.rs : \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_By0100644 0000000 0000000 00000000034 15172120304 033307 xustar000000000 0000000 28 mtime=1776853188.6620000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/ByteEnum.rs0100644 0000000 0000000 00000001434 15172120304 031616 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/ByteEnum.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#ByteEnum : [i8; 3] { r#FOO = 1, r#BAR = 2, r#BAZ = 3, } } pub(crate) mod mangled { pub use super::r#ByteEnum as _7_android_4_aidl_5_tests_8_ByteEnum; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_By0100644 0000000 0000000 00000000034 15172120304 033307 xustar000000000 0000000 28 mtime=1776853188.6620000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/ByteEnum.rs.d0100644 0000000 0000000 00000000255 15172120304 032040 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/ByteEnum.rs : \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_Ci0100644 0000000 0000000 00000000215 15172120304 033271 xustar000000000 0000000 113 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/CircularParcelable.rs 28 mtime=1776853188.6620000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/CircularParcelable0100644 0000000 0000000 00000003422 15172120304 033161 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/CircularParcelable.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub struct r#CircularParcelable { pub r#testService: Option>, } impl Default for r#CircularParcelable { fn default() -> Self { Self { r#testService: Default::default(), } } } impl binder::Parcelable for r#CircularParcelable { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#testService)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#testService = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#CircularParcelable); binder::impl_deserialize_for_parcelable!(r#CircularParcelable); impl binder::binder_impl::ParcelableMetadata for r#CircularParcelable { fn get_descriptor() -> &'static str { "android.aidl.tests.CircularParcelable" } } pub(crate) mod mangled { pub use super::r#CircularParcelable as _7_android_4_aidl_5_tests_18_CircularParcelable; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_Ci0100644 0000000 0000000 00000000217 15172120304 033273 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/CircularParcelable.rs.d 28 mtime=1776853188.6620000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/CircularParcelable0100644 0000000 0000000 00000002233 15172120304 033160 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/CircularParcelable.rs : \ system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ITestService.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl \ system/tools/aidl/tests/android/aidl/tests/SimpleParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl \ system/tools/aidl/tests/android/aidl/tests/ICircular.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_Co0100644 0000000 0000000 00000000221 15172120304 033274 xustar000000000 0000000 117 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/ConstantExpressionEnum.rs 28 mtime=1776853188.6620000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/ConstantExpression0100644 0000000 0000000 00000002024 15172120304 033310 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/ConstantExpressionEnum.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#ConstantExpressionEnum : [i32; 10] { r#decInt32_1 = 1, r#decInt32_2 = 1, r#decInt64_1 = 1, r#decInt64_2 = 1, r#decInt64_3 = 1, r#decInt64_4 = 1, r#hexInt32_1 = 1, r#hexInt32_2 = 1, r#hexInt32_3 = 1, r#hexInt64_1 = 1, } } pub(crate) mod mangled { pub use super::r#ConstantExpressionEnum as _7_android_4_aidl_5_tests_22_ConstantExpressionEnum; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_Co0100644 0000000 0000000 00000000223 15172120304 033276 xustar000000000 0000000 119 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/ConstantExpressionEnum.rs.d 28 mtime=1776853188.6620000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/ConstantExpression0100644 0000000 0000000 00000000311 15172120304 033305 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/ConstantExpressionEnum.rs : \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_De0100644 0000000 0000000 00000000034 15172120304 033265 xustar000000000 0000000 28 mtime=1776853188.6620000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/DeprecatedEnum.rs0100644 0000000 0000000 00000001517 15172120304 032755 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/DeprecatedEnum.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedEnum.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { #[deprecated = "test"] r#DeprecatedEnum : [i32; 3] { r#A = 0, r#B = 1, r#C = 2, } } pub(crate) mod mangled { pub use super::r#DeprecatedEnum as _7_android_4_aidl_5_tests_14_DeprecatedEnum; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_De0100644 0000000 0000000 00000000213 15172120304 033264 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/DeprecatedEnum.rs.d 28 mtime=1776853188.6620000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/DeprecatedEnum.rs.0100644 0000000 0000000 00000000271 15172120304 033027 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/DeprecatedEnum.rs : \ system/tools/aidl/tests/android/aidl/tests/DeprecatedEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_De0100644 0000000 0000000 00000000217 15172120304 033270 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/DeprecatedParcelable.rs 28 mtime=1776853188.6620000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/DeprecatedParcelab0100644 0000000 0000000 00000003040 15172120304 033130 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/DeprecatedParcelable.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/DeprecatedParcelable.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] #[deprecated = "test"] pub struct r#DeprecatedParcelable { } impl Default for r#DeprecatedParcelable { fn default() -> Self { Self { } } } impl binder::Parcelable for r#DeprecatedParcelable { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#DeprecatedParcelable); binder::impl_deserialize_for_parcelable!(r#DeprecatedParcelable); impl binder::binder_impl::ParcelableMetadata for r#DeprecatedParcelable { fn get_descriptor() -> &'static str { "android.aidl.tests.DeprecatedParcelable" } } pub(crate) mod mangled { pub use super::r#DeprecatedParcelable as _7_android_4_aidl_5_tests_20_DeprecatedParcelable; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_De0100644 0000000 0000000 00000000221 15172120304 033263 xustar000000000 0000000 117 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/DeprecatedParcelable.rs.d 28 mtime=1776853188.6630000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/DeprecatedParcelab0100644 0000000 0000000 00000000305 15172120304 033131 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/DeprecatedParcelable.rs : \ system/tools/aidl/tests/android/aidl/tests/DeprecatedParcelable.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_Fi0100644 0000000 0000000 00000000034 15172120304 033273 xustar000000000 0000000 28 mtime=1776853188.6630000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/FixedSize.rs0100644 0000000 0000000 00000017547 15172120304 031774 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/FixedSize.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/FixedSize.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub struct r#FixedSize { } impl Default for r#FixedSize { fn default() -> Self { Self { } } } impl binder::Parcelable for r#FixedSize { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#FixedSize); binder::impl_deserialize_for_parcelable!(r#FixedSize); impl binder::binder_impl::ParcelableMetadata for r#FixedSize { fn get_descriptor() -> &'static str { "android.aidl.tests.FixedSize" } } pub mod r#FixedParcelable { #[derive(Debug)] pub struct r#FixedParcelable { pub r#booleanValue: bool, pub r#byteValue: i8, pub r#charValue: u16, pub r#intValue: i32, pub r#longValue: i64, pub r#floatValue: f32, pub r#doubleValue: f64, pub r#enumValue: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum, pub r#parcelableValue: crate::mangled::_7_android_4_aidl_5_tests_9_FixedSize_10_FixedUnion, } impl Default for r#FixedParcelable { fn default() -> Self { Self { r#booleanValue: false, r#byteValue: 0, r#charValue: '\0' as u16, r#intValue: 0, r#longValue: 0, r#floatValue: 0.000000f32, r#doubleValue: 0.000000f64, r#enumValue: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum::FOO, r#parcelableValue: Default::default(), } } } impl binder::Parcelable for r#FixedParcelable { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#booleanValue)?; subparcel.write(&self.r#byteValue)?; subparcel.write(&self.r#charValue)?; subparcel.write(&self.r#intValue)?; subparcel.write(&self.r#longValue)?; subparcel.write(&self.r#floatValue)?; subparcel.write(&self.r#doubleValue)?; subparcel.write(&self.r#enumValue)?; subparcel.write(&self.r#parcelableValue)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#booleanValue = subparcel.read()?; } if subparcel.has_more_data() { self.r#byteValue = subparcel.read()?; } if subparcel.has_more_data() { self.r#charValue = subparcel.read()?; } if subparcel.has_more_data() { self.r#intValue = subparcel.read()?; } if subparcel.has_more_data() { self.r#longValue = subparcel.read()?; } if subparcel.has_more_data() { self.r#floatValue = subparcel.read()?; } if subparcel.has_more_data() { self.r#doubleValue = subparcel.read()?; } if subparcel.has_more_data() { self.r#enumValue = subparcel.read()?; } if subparcel.has_more_data() { self.r#parcelableValue = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#FixedParcelable); binder::impl_deserialize_for_parcelable!(r#FixedParcelable); impl binder::binder_impl::ParcelableMetadata for r#FixedParcelable { fn get_descriptor() -> &'static str { "android.aidl.tests.FixedSize.FixedParcelable" } } } pub mod r#FixedUnion { #[derive(Debug)] pub enum r#FixedUnion { BooleanValue(bool), ByteValue(i8), CharValue(u16), IntValue(i32), LongValue(i64), FloatValue(f32), DoubleValue(f64), EnumValue(crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum), } impl Default for r#FixedUnion { fn default() -> Self { Self::BooleanValue(false) } } impl binder::Parcelable for r#FixedUnion { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { match self { Self::BooleanValue(v) => { parcel.write(&0i32)?; parcel.write(v) } Self::ByteValue(v) => { parcel.write(&1i32)?; parcel.write(v) } Self::CharValue(v) => { parcel.write(&2i32)?; parcel.write(v) } Self::IntValue(v) => { parcel.write(&3i32)?; parcel.write(v) } Self::LongValue(v) => { parcel.write(&4i32)?; parcel.write(v) } Self::FloatValue(v) => { parcel.write(&5i32)?; parcel.write(v) } Self::DoubleValue(v) => { parcel.write(&6i32)?; parcel.write(v) } Self::EnumValue(v) => { parcel.write(&7i32)?; parcel.write(v) } } } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { let tag: i32 = parcel.read()?; match tag { 0 => { let value: bool = parcel.read()?; *self = Self::BooleanValue(value); Ok(()) } 1 => { let value: i8 = parcel.read()?; *self = Self::ByteValue(value); Ok(()) } 2 => { let value: u16 = parcel.read()?; *self = Self::CharValue(value); Ok(()) } 3 => { let value: i32 = parcel.read()?; *self = Self::IntValue(value); Ok(()) } 4 => { let value: i64 = parcel.read()?; *self = Self::LongValue(value); Ok(()) } 5 => { let value: f32 = parcel.read()?; *self = Self::FloatValue(value); Ok(()) } 6 => { let value: f64 = parcel.read()?; *self = Self::DoubleValue(value); Ok(()) } 7 => { let value: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum = parcel.read()?; *self = Self::EnumValue(value); Ok(()) } _ => { Err(binder::StatusCode::BAD_VALUE) } } } } binder::impl_serialize_for_parcelable!(r#FixedUnion); binder::impl_deserialize_for_parcelable!(r#FixedUnion); impl binder::binder_impl::ParcelableMetadata for r#FixedUnion { fn get_descriptor() -> &'static str { "android.aidl.tests.FixedSize.FixedUnion" } } pub mod r#Tag { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#Tag : [i8; 8] { r#booleanValue = 0, r#byteValue = 1, r#charValue = 2, r#intValue = 3, r#longValue = 4, r#floatValue = 5, r#doubleValue = 6, r#enumValue = 7, } } } } pub(crate) mod mangled { pub use super::r#FixedSize as _7_android_4_aidl_5_tests_9_FixedSize; pub use super::r#FixedParcelable::r#FixedParcelable as _7_android_4_aidl_5_tests_9_FixedSize_15_FixedParcelable; pub use super::r#FixedUnion::r#FixedUnion as _7_android_4_aidl_5_tests_9_FixedSize_10_FixedUnion; pub use super::r#FixedUnion::r#Tag::r#Tag as _7_android_4_aidl_5_tests_9_FixedSize_10_FixedUnion_3_Tag; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_Fi0100644 0000000 0000000 00000000034 15172120304 033273 xustar000000000 0000000 28 mtime=1776853188.6630000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/FixedSize.rs.d0100644 0000000 0000000 00000000354 15172120304 032202 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/FixedSize.rs : \ system/tools/aidl/tests/android/aidl/tests/FixedSize.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_Ge0100644 0000000 0000000 00000000226 15172120304 033273 xustar000000000 0000000 122 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/GenericStructuredParcelable.rs 28 mtime=1776853188.6630000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/GenericStructuredP0100644 0000000 0000000 00000004366 15172120304 033233 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/GenericStructuredParcelable.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug, Clone, Copy, Eq, PartialEq)] pub struct r#GenericStructuredParcelable { pub r#a: i32, pub r#b: i32, _phantom_B: std::marker::PhantomData, _phantom_T: std::marker::PhantomData, _phantom_U: std::marker::PhantomData, } impl Default for r#GenericStructuredParcelable { fn default() -> Self { Self { r#a: 0, r#b: 0, r#_phantom_B: Default::default(), r#_phantom_T: Default::default(), r#_phantom_U: Default::default(), } } } impl binder::Parcelable for r#GenericStructuredParcelable { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#a)?; subparcel.write(&self.r#b)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#a = subparcel.read()?; } if subparcel.has_more_data() { self.r#b = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#GenericStructuredParcelable); binder::impl_deserialize_for_parcelable!(r#GenericStructuredParcelable); impl binder::binder_impl::ParcelableMetadata for r#GenericStructuredParcelable { fn get_descriptor() -> &'static str { "android.aidl.tests.GenericStructuredParcelable" } } pub(crate) mod mangled { pub use super::r#GenericStructuredParcelable as _7_android_4_aidl_5_tests_27_GenericStructuredParcelable; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_Ge0100644 0000000 0000000 00000000230 15172120304 033266 xustar000000000 0000000 124 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/GenericStructuredParcelable.rs.d 28 mtime=1776853188.6640000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/GenericStructuredP0100644 0000000 0000000 00000000323 15172120304 033220 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/GenericStructuredParcelable.rs : \ system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_IC0100644 0000000 0000000 00000000034 15172120304 033230 xustar000000000 0000000 28 mtime=1776853188.6640000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/ICircular.rs0100644 0000000 0000000 00000015452 15172120304 031750 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/ICircular.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ICircular.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { ICircular["android.aidl.tests.ICircular"] { native: BnCircular(on_transact), proxy: BpCircular { }, async: ICircularAsync, } } pub trait ICircular: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ICircular" } fn r#GetTestService(&self) -> binder::Result>>; fn getDefaultImpl() -> ICircularDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: ICircularDefaultRef) -> ICircularDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait ICircularAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ICircular" } fn r#GetTestService<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result>>>; } #[::async_trait::async_trait] pub trait ICircularAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ICircular" } async fn r#GetTestService(&self) -> binder::Result>>; } impl BnCircular { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: ICircularAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl ICircular for Wrapper where T: ICircularAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#GetTestService(&self) -> binder::Result>> { self._rt.block_on(self._inner.r#GetTestService()) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait ICircularDefault: Send + Sync { fn r#GetTestService(&self) -> binder::Result>> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#GetTestService: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; } pub type ICircularDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); impl BpCircular { fn build_parcel_GetTestService(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_GetTestService(&self, _aidl_reply: std::result::Result) -> binder::Result>> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#GetTestService(); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option> = _aidl_reply.read()?; Ok(_aidl_return) } } impl ICircular for BpCircular { fn r#GetTestService(&self) -> binder::Result>> { let _aidl_data = self.build_parcel_GetTestService()?; let _aidl_reply = self.binder.submit_transact(transactions::r#GetTestService, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_GetTestService(_aidl_reply) } } impl ICircularAsync

for BpCircular { fn r#GetTestService<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result>>> { let _aidl_data = match self.build_parcel_GetTestService() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#GetTestService, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_GetTestService(_aidl_reply) } ) } } impl ICircular for binder::binder_impl::Binder { fn r#GetTestService(&self) -> binder::Result>> { self.0.r#GetTestService() } } fn on_transact(_aidl_service: &dyn ICircular, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#GetTestService => { let _aidl_return = _aidl_service.r#GetTestService(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } pub(crate) mod mangled { pub use super::r#ICircular as _7_android_4_aidl_5_tests_9_ICircular; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_IC0100644 0000000 0000000 00000000034 15172120304 033230 xustar000000000 0000000 28 mtime=1776853188.6640000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/ICircular.rs.d0100644 0000000 0000000 00000002222 15172120304 032161 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/ICircular.rs : \ system/tools/aidl/tests/android/aidl/tests/ICircular.aidl \ system/tools/aidl/tests/android/aidl/tests/ITestService.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl \ system/tools/aidl/tests/android/aidl/tests/SimpleParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl \ system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_ID0100644 0000000 0000000 00000000034 15172120304 033231 xustar000000000 0000000 28 mtime=1776853188.6640000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/IDeprecated.rs0100644 0000000 0000000 00000007105 15172120304 032240 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/IDeprecated.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IDeprecated.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { IDeprecated["android.aidl.tests.IDeprecated"] { native: BnDeprecated(on_transact), proxy: BpDeprecated { }, async: IDeprecatedAsync, } } #[deprecated = "test"] pub trait IDeprecated: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.IDeprecated" } fn getDefaultImpl() -> IDeprecatedDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: IDeprecatedDefaultRef) -> IDeprecatedDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } #[deprecated = "test"] pub trait IDeprecatedAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.IDeprecated" } } #[deprecated = "test"] #[::async_trait::async_trait] pub trait IDeprecatedAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.IDeprecated" } } impl BnDeprecated { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: IDeprecatedAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl IDeprecated for Wrapper where T: IDeprecatedAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait IDeprecatedDefault: Send + Sync { } pub mod transactions { } pub type IDeprecatedDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); impl BpDeprecated { } impl IDeprecated for BpDeprecated { } impl IDeprecatedAsync

for BpDeprecated { } impl IDeprecated for binder::binder_impl::Binder { } fn on_transact(_aidl_service: &dyn IDeprecated, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } pub(crate) mod mangled { pub use super::r#IDeprecated as _7_android_4_aidl_5_tests_11_IDeprecated; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_ID0100644 0000000 0000000 00000000034 15172120304 033231 xustar000000000 0000000 28 mtime=1776853188.6640000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/IDeprecated.rs.d0100644 0000000 0000000 00000000263 15172120304 032460 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/IDeprecated.rs : \ system/tools/aidl/tests/android/aidl/tests/IDeprecated.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_IN0100644 0000000 0000000 00000000034 15172120304 033243 xustar000000000 0000000 28 mtime=1776853188.6640000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/INamedCallback.rs0100644 0000000 0000000 00000014057 15172120304 032645 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/INamedCallback.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { INamedCallback["android.aidl.tests.INamedCallback"] { native: BnNamedCallback(on_transact), proxy: BpNamedCallback { }, async: INamedCallbackAsync, } } pub trait INamedCallback: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.INamedCallback" } fn r#GetName(&self) -> binder::Result; fn getDefaultImpl() -> INamedCallbackDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: INamedCallbackDefaultRef) -> INamedCallbackDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait INamedCallbackAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.INamedCallback" } fn r#GetName<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result>; } #[::async_trait::async_trait] pub trait INamedCallbackAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.INamedCallback" } async fn r#GetName(&self) -> binder::Result; } impl BnNamedCallback { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: INamedCallbackAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl INamedCallback for Wrapper where T: INamedCallbackAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#GetName(&self) -> binder::Result { self._rt.block_on(self._inner.r#GetName()) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait INamedCallbackDefault: Send + Sync { fn r#GetName(&self) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#GetName: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; } pub type INamedCallbackDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); impl BpNamedCallback { fn build_parcel_GetName(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_GetName(&self, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#GetName(); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: String = _aidl_reply.read()?; Ok(_aidl_return) } } impl INamedCallback for BpNamedCallback { fn r#GetName(&self) -> binder::Result { let _aidl_data = self.build_parcel_GetName()?; let _aidl_reply = self.binder.submit_transact(transactions::r#GetName, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_GetName(_aidl_reply) } } impl INamedCallbackAsync

for BpNamedCallback { fn r#GetName<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_GetName() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#GetName, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_GetName(_aidl_reply) } ) } } impl INamedCallback for binder::binder_impl::Binder { fn r#GetName(&self) -> binder::Result { self.0.r#GetName() } } fn on_transact(_aidl_service: &dyn INamedCallback, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#GetName => { let _aidl_return = _aidl_service.r#GetName(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } pub(crate) mod mangled { pub use super::r#INamedCallback as _7_android_4_aidl_5_tests_14_INamedCallback; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_IN0100644 0000000 0000000 00000000213 15172120304 033242 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/INamedCallback.rs.d 28 mtime=1776853188.6640000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/INamedCallback.rs.0100644 0000000 0000000 00000000271 15172120304 032714 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/INamedCallback.rs : \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_IN0100644 0000000 0000000 00000000034 15172120304 033243 xustar000000000 0000000 28 mtime=1776853188.6640000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/INewName.rs0100644 0000000 0000000 00000013554 15172120304 031537 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/INewName.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/INewName.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { INewName["android.aidl.tests.IOldName"] { native: BnNewName(on_transact), proxy: BpNewName { }, async: INewNameAsync, } } pub trait INewName: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.IOldName" } fn r#RealName(&self) -> binder::Result; fn getDefaultImpl() -> INewNameDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: INewNameDefaultRef) -> INewNameDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait INewNameAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.IOldName" } fn r#RealName<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result>; } #[::async_trait::async_trait] pub trait INewNameAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.IOldName" } async fn r#RealName(&self) -> binder::Result; } impl BnNewName { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: INewNameAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl INewName for Wrapper where T: INewNameAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#RealName(&self) -> binder::Result { self._rt.block_on(self._inner.r#RealName()) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait INewNameDefault: Send + Sync { fn r#RealName(&self) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#RealName: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; } pub type INewNameDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); impl BpNewName { fn build_parcel_RealName(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_RealName(&self, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RealName(); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: String = _aidl_reply.read()?; Ok(_aidl_return) } } impl INewName for BpNewName { fn r#RealName(&self) -> binder::Result { let _aidl_data = self.build_parcel_RealName()?; let _aidl_reply = self.binder.submit_transact(transactions::r#RealName, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RealName(_aidl_reply) } } impl INewNameAsync

for BpNewName { fn r#RealName<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_RealName() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RealName, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RealName(_aidl_reply) } ) } } impl INewName for binder::binder_impl::Binder { fn r#RealName(&self) -> binder::Result { self.0.r#RealName() } } fn on_transact(_aidl_service: &dyn INewName, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#RealName => { let _aidl_return = _aidl_service.r#RealName(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } pub(crate) mod mangled { pub use super::r#INewName as _7_android_4_aidl_5_tests_8_INewName; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_IN0100644 0000000 0000000 00000000034 15172120304 033243 xustar000000000 0000000 28 mtime=1776853188.6640000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/INewName.rs.d0100644 0000000 0000000 00000000255 15172120304 031753 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/INewName.rs : \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_IO0100644 0000000 0000000 00000000034 15172120304 033244 xustar000000000 0000000 28 mtime=1776853188.6640000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/IOldName.rs0100644 0000000 0000000 00000013554 15172120304 031524 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/IOldName.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IOldName.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { IOldName["android.aidl.tests.IOldName"] { native: BnOldName(on_transact), proxy: BpOldName { }, async: IOldNameAsync, } } pub trait IOldName: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.IOldName" } fn r#RealName(&self) -> binder::Result; fn getDefaultImpl() -> IOldNameDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: IOldNameDefaultRef) -> IOldNameDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait IOldNameAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.IOldName" } fn r#RealName<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result>; } #[::async_trait::async_trait] pub trait IOldNameAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.IOldName" } async fn r#RealName(&self) -> binder::Result; } impl BnOldName { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: IOldNameAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl IOldName for Wrapper where T: IOldNameAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#RealName(&self) -> binder::Result { self._rt.block_on(self._inner.r#RealName()) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait IOldNameDefault: Send + Sync { fn r#RealName(&self) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#RealName: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; } pub type IOldNameDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); impl BpOldName { fn build_parcel_RealName(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_RealName(&self, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RealName(); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: String = _aidl_reply.read()?; Ok(_aidl_return) } } impl IOldName for BpOldName { fn r#RealName(&self) -> binder::Result { let _aidl_data = self.build_parcel_RealName()?; let _aidl_reply = self.binder.submit_transact(transactions::r#RealName, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RealName(_aidl_reply) } } impl IOldNameAsync

for BpOldName { fn r#RealName<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_RealName() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RealName, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RealName(_aidl_reply) } ) } } impl IOldName for binder::binder_impl::Binder { fn r#RealName(&self) -> binder::Result { self.0.r#RealName() } } fn on_transact(_aidl_service: &dyn IOldName, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#RealName => { let _aidl_return = _aidl_service.r#RealName(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } pub(crate) mod mangled { pub use super::r#IOldName as _7_android_4_aidl_5_tests_8_IOldName; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_IO0100644 0000000 0000000 00000000034 15172120304 033244 xustar000000000 0000000 28 mtime=1776853188.6640000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/IOldName.rs.d0100644 0000000 0000000 00000000255 15172120304 031740 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/IOldName.rs : \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_IT0100644 0000000 0000000 00000000034 15172120304 033251 xustar000000000 0000000 28 mtime=1776853188.6650000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/ITestService.rs0100644 0000000 0000000 00001147065 15172120304 032453 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/ITestService.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ITestService.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { ITestService["android.aidl.tests.ITestService"] { native: BnTestService(on_transact), proxy: BpTestService { }, async: ITestServiceAsync, } } pub trait ITestService: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ITestService" } fn r#UnimplementedMethod(&self, _arg_arg: i32) -> binder::Result; #[deprecated = "to make sure we have something in system/tools/aidl which does a compile check of deprecated and make sure this is reflected in goldens"] fn r#Deprecated(&self) -> binder::Result<()>; fn r#TestOneway(&self) -> binder::Result<()>; fn r#RepeatBoolean(&self, _arg_token: bool) -> binder::Result; fn r#RepeatByte(&self, _arg_token: i8) -> binder::Result; fn r#RepeatChar(&self, _arg_token: u16) -> binder::Result; fn r#RepeatInt(&self, _arg_token: i32) -> binder::Result; fn r#RepeatLong(&self, _arg_token: i64) -> binder::Result; fn r#RepeatFloat(&self, _arg_token: f32) -> binder::Result; fn r#RepeatDouble(&self, _arg_token: f64) -> binder::Result; fn r#RepeatString(&self, _arg_token: &str) -> binder::Result; fn r#RepeatByteEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum) -> binder::Result; fn r#RepeatIntEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum) -> binder::Result; fn r#RepeatLongEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum) -> binder::Result; fn r#ReverseBoolean(&self, _arg_input: &[bool], _arg_repeated: &mut Vec) -> binder::Result>; fn r#ReverseByte(&self, _arg_input: &[u8], _arg_repeated: &mut Vec) -> binder::Result>; fn r#ReverseChar(&self, _arg_input: &[u16], _arg_repeated: &mut Vec) -> binder::Result>; fn r#ReverseInt(&self, _arg_input: &[i32], _arg_repeated: &mut Vec) -> binder::Result>; fn r#ReverseLong(&self, _arg_input: &[i64], _arg_repeated: &mut Vec) -> binder::Result>; fn r#ReverseFloat(&self, _arg_input: &[f32], _arg_repeated: &mut Vec) -> binder::Result>; fn r#ReverseDouble(&self, _arg_input: &[f64], _arg_repeated: &mut Vec) -> binder::Result>; fn r#ReverseString(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result>; fn r#ReverseByteEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum], _arg_repeated: &mut Vec) -> binder::Result>; fn r#ReverseIntEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum], _arg_repeated: &mut Vec) -> binder::Result>; fn r#ReverseLongEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum], _arg_repeated: &mut Vec) -> binder::Result>; fn r#GetOtherTestService(&self, _arg_name: &str) -> binder::Result>; fn r#SetOtherTestService(&self, _arg_name: &str, _arg_service: &binder::Strong) -> binder::Result; fn r#VerifyName(&self, _arg_service: &binder::Strong, _arg_name: &str) -> binder::Result; fn r#GetInterfaceArray(&self, _arg_names: &[String]) -> binder::Result>>; fn r#VerifyNamesWithInterfaceArray(&self, _arg_services: &[binder::Strong], _arg_names: &[String]) -> binder::Result; fn r#GetNullableInterfaceArray(&self, _arg_names: Option<&[Option]>) -> binder::Result>>>>; fn r#VerifyNamesWithNullableInterfaceArray(&self, _arg_services: Option<&[Option>]>, _arg_names: Option<&[Option]>) -> binder::Result; fn r#GetInterfaceList(&self, _arg_names: Option<&[Option]>) -> binder::Result>>>>; fn r#VerifyNamesWithInterfaceList(&self, _arg_services: Option<&[Option>]>, _arg_names: Option<&[Option]>) -> binder::Result; fn r#ReverseStringList(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result>; fn r#RepeatParcelFileDescriptor(&self, _arg_read: &binder::ParcelFileDescriptor) -> binder::Result; fn r#ReverseParcelFileDescriptorArray(&self, _arg_input: &[binder::ParcelFileDescriptor], _arg_repeated: &mut Vec>) -> binder::Result>; fn r#ThrowServiceException(&self, _arg_code: i32) -> binder::Result<()>; fn r#RepeatNullableIntArray(&self, _arg_input: Option<&[i32]>) -> binder::Result>>; fn r#RepeatNullableByteEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum]>) -> binder::Result>>; fn r#RepeatNullableIntEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum]>) -> binder::Result>>; fn r#RepeatNullableLongEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum]>) -> binder::Result>>; fn r#RepeatNullableString(&self, _arg_input: Option<&str>) -> binder::Result>; fn r#RepeatNullableStringList(&self, _arg_input: Option<&[Option]>) -> binder::Result>>>; fn r#RepeatNullableParcelable(&self, _arg_input: Option<&crate::mangled::_7_android_4_aidl_5_tests_12_ITestService_5_Empty>) -> binder::Result>; fn r#RepeatNullableParcelableArray(&self, _arg_input: Option<&[Option]>) -> binder::Result>>>; fn r#RepeatNullableParcelableList(&self, _arg_input: Option<&[Option]>) -> binder::Result>>>; fn r#TakesAnIBinder(&self, _arg_input: &binder::SpIBinder) -> binder::Result<()>; fn r#TakesANullableIBinder(&self, _arg_input: Option<&binder::SpIBinder>) -> binder::Result<()>; fn r#TakesAnIBinderList(&self, _arg_input: &[binder::SpIBinder]) -> binder::Result<()>; fn r#TakesANullableIBinderList(&self, _arg_input: Option<&[Option]>) -> binder::Result<()>; fn r#RepeatUtf8CppString(&self, _arg_token: &str) -> binder::Result; fn r#RepeatNullableUtf8CppString(&self, _arg_token: Option<&str>) -> binder::Result>; fn r#ReverseUtf8CppString(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result>; fn r#ReverseNullableUtf8CppString(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>>; fn r#ReverseUtf8CppStringList(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>>; fn r#GetCallback(&self, _arg_return_null: bool) -> binder::Result>>; fn r#FillOutStructuredParcelable(&self, _arg_parcel: &mut crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable) -> binder::Result<()>; fn r#RepeatExtendableParcelable(&self, _arg_ep: &crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable, _arg_ep2: &mut crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable) -> binder::Result<()>; fn r#ReverseList(&self, _arg_list: &crate::mangled::_7_android_4_aidl_5_tests_13_RecursiveList) -> binder::Result; fn r#ReverseIBinderArray(&self, _arg_input: &[binder::SpIBinder], _arg_repeated: &mut Vec>) -> binder::Result>; fn r#ReverseNullableIBinderArray(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>>; fn r#RepeatSimpleParcelable(&self, _arg_input: &simple_parcelable::SimpleParcelable, _arg_repeat: &mut simple_parcelable::SimpleParcelable) -> binder::Result; fn r#ReverseSimpleParcelables(&self, _arg_input: &[simple_parcelable::SimpleParcelable], _arg_repeated: &mut Vec) -> binder::Result>; fn r#GetOldNameInterface(&self) -> binder::Result>; fn r#GetNewNameInterface(&self) -> binder::Result>; fn r#GetUnionTags(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_5_Union]) -> binder::Result>; fn r#GetCppJavaTests(&self) -> binder::Result>; fn r#getBackendType(&self) -> binder::Result; fn r#GetCircular(&self, _arg_cp: &mut crate::mangled::_7_android_4_aidl_5_tests_18_CircularParcelable) -> binder::Result>; fn getDefaultImpl() -> ITestServiceDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: ITestServiceDefaultRef) -> ITestServiceDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait ITestServiceAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ITestService" } fn r#UnimplementedMethod<'a>(&'a self, _arg_arg: i32) -> binder::BoxFuture<'a, binder::Result>; #[deprecated = "to make sure we have something in system/tools/aidl which does a compile check of deprecated and make sure this is reflected in goldens"] fn r#Deprecated<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result<()>>; fn r#TestOneway(&self) -> std::future::Ready>; fn r#RepeatBoolean<'a>(&'a self, _arg_token: bool) -> binder::BoxFuture<'a, binder::Result>; fn r#RepeatByte<'a>(&'a self, _arg_token: i8) -> binder::BoxFuture<'a, binder::Result>; fn r#RepeatChar<'a>(&'a self, _arg_token: u16) -> binder::BoxFuture<'a, binder::Result>; fn r#RepeatInt<'a>(&'a self, _arg_token: i32) -> binder::BoxFuture<'a, binder::Result>; fn r#RepeatLong<'a>(&'a self, _arg_token: i64) -> binder::BoxFuture<'a, binder::Result>; fn r#RepeatFloat<'a>(&'a self, _arg_token: f32) -> binder::BoxFuture<'a, binder::Result>; fn r#RepeatDouble<'a>(&'a self, _arg_token: f64) -> binder::BoxFuture<'a, binder::Result>; fn r#RepeatString<'a>(&'a self, _arg_token: &'a str) -> binder::BoxFuture<'a, binder::Result>; fn r#RepeatByteEnum<'a>(&'a self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum) -> binder::BoxFuture<'a, binder::Result>; fn r#RepeatIntEnum<'a>(&'a self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum) -> binder::BoxFuture<'a, binder::Result>; fn r#RepeatLongEnum<'a>(&'a self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum) -> binder::BoxFuture<'a, binder::Result>; fn r#ReverseBoolean<'a>(&'a self, _arg_input: &'a [bool], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>>; fn r#ReverseByte<'a>(&'a self, _arg_input: &'a [u8], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>>; fn r#ReverseChar<'a>(&'a self, _arg_input: &'a [u16], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>>; fn r#ReverseInt<'a>(&'a self, _arg_input: &'a [i32], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>>; fn r#ReverseLong<'a>(&'a self, _arg_input: &'a [i64], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>>; fn r#ReverseFloat<'a>(&'a self, _arg_input: &'a [f32], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>>; fn r#ReverseDouble<'a>(&'a self, _arg_input: &'a [f64], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>>; fn r#ReverseString<'a>(&'a self, _arg_input: &'a [String], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>>; fn r#ReverseByteEnum<'a>(&'a self, _arg_input: &'a [crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>>; fn r#ReverseIntEnum<'a>(&'a self, _arg_input: &'a [crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>>; fn r#ReverseLongEnum<'a>(&'a self, _arg_input: &'a [crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>>; fn r#GetOtherTestService<'a>(&'a self, _arg_name: &'a str) -> binder::BoxFuture<'a, binder::Result>>; fn r#SetOtherTestService<'a>(&'a self, _arg_name: &'a str, _arg_service: &'a binder::Strong) -> binder::BoxFuture<'a, binder::Result>; fn r#VerifyName<'a>(&'a self, _arg_service: &'a binder::Strong, _arg_name: &'a str) -> binder::BoxFuture<'a, binder::Result>; fn r#GetInterfaceArray<'a>(&'a self, _arg_names: &'a [String]) -> binder::BoxFuture<'a, binder::Result>>>; fn r#VerifyNamesWithInterfaceArray<'a>(&'a self, _arg_services: &'a [binder::Strong], _arg_names: &'a [String]) -> binder::BoxFuture<'a, binder::Result>; fn r#GetNullableInterfaceArray<'a>(&'a self, _arg_names: Option<&'a [Option]>) -> binder::BoxFuture<'a, binder::Result>>>>>; fn r#VerifyNamesWithNullableInterfaceArray<'a>(&'a self, _arg_services: Option<&'a [Option>]>, _arg_names: Option<&'a [Option]>) -> binder::BoxFuture<'a, binder::Result>; fn r#GetInterfaceList<'a>(&'a self, _arg_names: Option<&'a [Option]>) -> binder::BoxFuture<'a, binder::Result>>>>>; fn r#VerifyNamesWithInterfaceList<'a>(&'a self, _arg_services: Option<&'a [Option>]>, _arg_names: Option<&'a [Option]>) -> binder::BoxFuture<'a, binder::Result>; fn r#ReverseStringList<'a>(&'a self, _arg_input: &'a [String], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>>; fn r#RepeatParcelFileDescriptor<'a>(&'a self, _arg_read: &'a binder::ParcelFileDescriptor) -> binder::BoxFuture<'a, binder::Result>; fn r#ReverseParcelFileDescriptorArray<'a>(&'a self, _arg_input: &'a [binder::ParcelFileDescriptor], _arg_repeated: &'a mut Vec>) -> binder::BoxFuture<'a, binder::Result>>; fn r#ThrowServiceException<'a>(&'a self, _arg_code: i32) -> binder::BoxFuture<'a, binder::Result<()>>; fn r#RepeatNullableIntArray<'a>(&'a self, _arg_input: Option<&'a [i32]>) -> binder::BoxFuture<'a, binder::Result>>>; fn r#RepeatNullableByteEnumArray<'a>(&'a self, _arg_input: Option<&'a [crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum]>) -> binder::BoxFuture<'a, binder::Result>>>; fn r#RepeatNullableIntEnumArray<'a>(&'a self, _arg_input: Option<&'a [crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum]>) -> binder::BoxFuture<'a, binder::Result>>>; fn r#RepeatNullableLongEnumArray<'a>(&'a self, _arg_input: Option<&'a [crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum]>) -> binder::BoxFuture<'a, binder::Result>>>; fn r#RepeatNullableString<'a>(&'a self, _arg_input: Option<&'a str>) -> binder::BoxFuture<'a, binder::Result>>; fn r#RepeatNullableStringList<'a>(&'a self, _arg_input: Option<&'a [Option]>) -> binder::BoxFuture<'a, binder::Result>>>>; fn r#RepeatNullableParcelable<'a>(&'a self, _arg_input: Option<&'a crate::mangled::_7_android_4_aidl_5_tests_12_ITestService_5_Empty>) -> binder::BoxFuture<'a, binder::Result>>; fn r#RepeatNullableParcelableArray<'a>(&'a self, _arg_input: Option<&'a [Option]>) -> binder::BoxFuture<'a, binder::Result>>>>; fn r#RepeatNullableParcelableList<'a>(&'a self, _arg_input: Option<&'a [Option]>) -> binder::BoxFuture<'a, binder::Result>>>>; fn r#TakesAnIBinder<'a>(&'a self, _arg_input: &'a binder::SpIBinder) -> binder::BoxFuture<'a, binder::Result<()>>; fn r#TakesANullableIBinder<'a>(&'a self, _arg_input: Option<&'a binder::SpIBinder>) -> binder::BoxFuture<'a, binder::Result<()>>; fn r#TakesAnIBinderList<'a>(&'a self, _arg_input: &'a [binder::SpIBinder]) -> binder::BoxFuture<'a, binder::Result<()>>; fn r#TakesANullableIBinderList<'a>(&'a self, _arg_input: Option<&'a [Option]>) -> binder::BoxFuture<'a, binder::Result<()>>; fn r#RepeatUtf8CppString<'a>(&'a self, _arg_token: &'a str) -> binder::BoxFuture<'a, binder::Result>; fn r#RepeatNullableUtf8CppString<'a>(&'a self, _arg_token: Option<&'a str>) -> binder::BoxFuture<'a, binder::Result>>; fn r#ReverseUtf8CppString<'a>(&'a self, _arg_input: &'a [String], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>>; fn r#ReverseNullableUtf8CppString<'a>(&'a self, _arg_input: Option<&'a [Option]>, _arg_repeated: &'a mut Option>>) -> binder::BoxFuture<'a, binder::Result>>>>; fn r#ReverseUtf8CppStringList<'a>(&'a self, _arg_input: Option<&'a [Option]>, _arg_repeated: &'a mut Option>>) -> binder::BoxFuture<'a, binder::Result>>>>; fn r#GetCallback<'a>(&'a self, _arg_return_null: bool) -> binder::BoxFuture<'a, binder::Result>>>; fn r#FillOutStructuredParcelable<'a>(&'a self, _arg_parcel: &'a mut crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable) -> binder::BoxFuture<'a, binder::Result<()>>; fn r#RepeatExtendableParcelable<'a>(&'a self, _arg_ep: &'a crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable, _arg_ep2: &'a mut crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable) -> binder::BoxFuture<'a, binder::Result<()>>; fn r#ReverseList<'a>(&'a self, _arg_list: &'a crate::mangled::_7_android_4_aidl_5_tests_13_RecursiveList) -> binder::BoxFuture<'a, binder::Result>; fn r#ReverseIBinderArray<'a>(&'a self, _arg_input: &'a [binder::SpIBinder], _arg_repeated: &'a mut Vec>) -> binder::BoxFuture<'a, binder::Result>>; fn r#ReverseNullableIBinderArray<'a>(&'a self, _arg_input: Option<&'a [Option]>, _arg_repeated: &'a mut Option>>) -> binder::BoxFuture<'a, binder::Result>>>>; fn r#RepeatSimpleParcelable<'a>(&'a self, _arg_input: &'a simple_parcelable::SimpleParcelable, _arg_repeat: &'a mut simple_parcelable::SimpleParcelable) -> binder::BoxFuture<'a, binder::Result>; fn r#ReverseSimpleParcelables<'a>(&'a self, _arg_input: &'a [simple_parcelable::SimpleParcelable], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>>; fn r#GetOldNameInterface<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result>>; fn r#GetNewNameInterface<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result>>; fn r#GetUnionTags<'a>(&'a self, _arg_input: &'a [crate::mangled::_7_android_4_aidl_5_tests_5_Union]) -> binder::BoxFuture<'a, binder::Result>>; fn r#GetCppJavaTests<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result>>; fn r#getBackendType<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result>; fn r#GetCircular<'a>(&'a self, _arg_cp: &'a mut crate::mangled::_7_android_4_aidl_5_tests_18_CircularParcelable) -> binder::BoxFuture<'a, binder::Result>>; } #[::async_trait::async_trait] pub trait ITestServiceAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ITestService" } async fn r#UnimplementedMethod(&self, _arg_arg: i32) -> binder::Result; #[deprecated = "to make sure we have something in system/tools/aidl which does a compile check of deprecated and make sure this is reflected in goldens"] async fn r#Deprecated(&self) -> binder::Result<()>; async fn r#TestOneway(&self) -> binder::Result<()>; async fn r#RepeatBoolean(&self, _arg_token: bool) -> binder::Result; async fn r#RepeatByte(&self, _arg_token: i8) -> binder::Result; async fn r#RepeatChar(&self, _arg_token: u16) -> binder::Result; async fn r#RepeatInt(&self, _arg_token: i32) -> binder::Result; async fn r#RepeatLong(&self, _arg_token: i64) -> binder::Result; async fn r#RepeatFloat(&self, _arg_token: f32) -> binder::Result; async fn r#RepeatDouble(&self, _arg_token: f64) -> binder::Result; async fn r#RepeatString(&self, _arg_token: &str) -> binder::Result; async fn r#RepeatByteEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum) -> binder::Result; async fn r#RepeatIntEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum) -> binder::Result; async fn r#RepeatLongEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum) -> binder::Result; async fn r#ReverseBoolean(&self, _arg_input: &[bool], _arg_repeated: &mut Vec) -> binder::Result>; async fn r#ReverseByte(&self, _arg_input: &[u8], _arg_repeated: &mut Vec) -> binder::Result>; async fn r#ReverseChar(&self, _arg_input: &[u16], _arg_repeated: &mut Vec) -> binder::Result>; async fn r#ReverseInt(&self, _arg_input: &[i32], _arg_repeated: &mut Vec) -> binder::Result>; async fn r#ReverseLong(&self, _arg_input: &[i64], _arg_repeated: &mut Vec) -> binder::Result>; async fn r#ReverseFloat(&self, _arg_input: &[f32], _arg_repeated: &mut Vec) -> binder::Result>; async fn r#ReverseDouble(&self, _arg_input: &[f64], _arg_repeated: &mut Vec) -> binder::Result>; async fn r#ReverseString(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result>; async fn r#ReverseByteEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum], _arg_repeated: &mut Vec) -> binder::Result>; async fn r#ReverseIntEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum], _arg_repeated: &mut Vec) -> binder::Result>; async fn r#ReverseLongEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum], _arg_repeated: &mut Vec) -> binder::Result>; async fn r#GetOtherTestService(&self, _arg_name: &str) -> binder::Result>; async fn r#SetOtherTestService(&self, _arg_name: &str, _arg_service: &binder::Strong) -> binder::Result; async fn r#VerifyName(&self, _arg_service: &binder::Strong, _arg_name: &str) -> binder::Result; async fn r#GetInterfaceArray(&self, _arg_names: &[String]) -> binder::Result>>; async fn r#VerifyNamesWithInterfaceArray(&self, _arg_services: &[binder::Strong], _arg_names: &[String]) -> binder::Result; async fn r#GetNullableInterfaceArray(&self, _arg_names: Option<&[Option]>) -> binder::Result>>>>; async fn r#VerifyNamesWithNullableInterfaceArray(&self, _arg_services: Option<&[Option>]>, _arg_names: Option<&[Option]>) -> binder::Result; async fn r#GetInterfaceList(&self, _arg_names: Option<&[Option]>) -> binder::Result>>>>; async fn r#VerifyNamesWithInterfaceList(&self, _arg_services: Option<&[Option>]>, _arg_names: Option<&[Option]>) -> binder::Result; async fn r#ReverseStringList(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result>; async fn r#RepeatParcelFileDescriptor(&self, _arg_read: &binder::ParcelFileDescriptor) -> binder::Result; async fn r#ReverseParcelFileDescriptorArray(&self, _arg_input: &[binder::ParcelFileDescriptor], _arg_repeated: &mut Vec>) -> binder::Result>; async fn r#ThrowServiceException(&self, _arg_code: i32) -> binder::Result<()>; async fn r#RepeatNullableIntArray(&self, _arg_input: Option<&[i32]>) -> binder::Result>>; async fn r#RepeatNullableByteEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum]>) -> binder::Result>>; async fn r#RepeatNullableIntEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum]>) -> binder::Result>>; async fn r#RepeatNullableLongEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum]>) -> binder::Result>>; async fn r#RepeatNullableString(&self, _arg_input: Option<&str>) -> binder::Result>; async fn r#RepeatNullableStringList(&self, _arg_input: Option<&[Option]>) -> binder::Result>>>; async fn r#RepeatNullableParcelable(&self, _arg_input: Option<&crate::mangled::_7_android_4_aidl_5_tests_12_ITestService_5_Empty>) -> binder::Result>; async fn r#RepeatNullableParcelableArray(&self, _arg_input: Option<&[Option]>) -> binder::Result>>>; async fn r#RepeatNullableParcelableList(&self, _arg_input: Option<&[Option]>) -> binder::Result>>>; async fn r#TakesAnIBinder(&self, _arg_input: &binder::SpIBinder) -> binder::Result<()>; async fn r#TakesANullableIBinder(&self, _arg_input: Option<&binder::SpIBinder>) -> binder::Result<()>; async fn r#TakesAnIBinderList(&self, _arg_input: &[binder::SpIBinder]) -> binder::Result<()>; async fn r#TakesANullableIBinderList(&self, _arg_input: Option<&[Option]>) -> binder::Result<()>; async fn r#RepeatUtf8CppString(&self, _arg_token: &str) -> binder::Result; async fn r#RepeatNullableUtf8CppString(&self, _arg_token: Option<&str>) -> binder::Result>; async fn r#ReverseUtf8CppString(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result>; async fn r#ReverseNullableUtf8CppString(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>>; async fn r#ReverseUtf8CppStringList(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>>; async fn r#GetCallback(&self, _arg_return_null: bool) -> binder::Result>>; async fn r#FillOutStructuredParcelable(&self, _arg_parcel: &mut crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable) -> binder::Result<()>; async fn r#RepeatExtendableParcelable(&self, _arg_ep: &crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable, _arg_ep2: &mut crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable) -> binder::Result<()>; async fn r#ReverseList(&self, _arg_list: &crate::mangled::_7_android_4_aidl_5_tests_13_RecursiveList) -> binder::Result; async fn r#ReverseIBinderArray(&self, _arg_input: &[binder::SpIBinder], _arg_repeated: &mut Vec>) -> binder::Result>; async fn r#ReverseNullableIBinderArray(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>>; async fn r#RepeatSimpleParcelable(&self, _arg_input: &simple_parcelable::SimpleParcelable, _arg_repeat: &mut simple_parcelable::SimpleParcelable) -> binder::Result; async fn r#ReverseSimpleParcelables(&self, _arg_input: &[simple_parcelable::SimpleParcelable], _arg_repeated: &mut Vec) -> binder::Result>; async fn r#GetOldNameInterface(&self) -> binder::Result>; async fn r#GetNewNameInterface(&self) -> binder::Result>; async fn r#GetUnionTags(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_5_Union]) -> binder::Result>; async fn r#GetCppJavaTests(&self) -> binder::Result>; async fn r#getBackendType(&self) -> binder::Result; async fn r#GetCircular(&self, _arg_cp: &mut crate::mangled::_7_android_4_aidl_5_tests_18_CircularParcelable) -> binder::Result>; } impl BnTestService { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: ITestServiceAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl ITestService for Wrapper where T: ITestServiceAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#UnimplementedMethod(&self, _arg_arg: i32) -> binder::Result { self._rt.block_on(self._inner.r#UnimplementedMethod(_arg_arg)) } fn r#Deprecated(&self) -> binder::Result<()> { self._rt.block_on(self._inner.r#Deprecated()) } fn r#TestOneway(&self) -> binder::Result<()> { self._rt.block_on(self._inner.r#TestOneway()) } fn r#RepeatBoolean(&self, _arg_token: bool) -> binder::Result { self._rt.block_on(self._inner.r#RepeatBoolean(_arg_token)) } fn r#RepeatByte(&self, _arg_token: i8) -> binder::Result { self._rt.block_on(self._inner.r#RepeatByte(_arg_token)) } fn r#RepeatChar(&self, _arg_token: u16) -> binder::Result { self._rt.block_on(self._inner.r#RepeatChar(_arg_token)) } fn r#RepeatInt(&self, _arg_token: i32) -> binder::Result { self._rt.block_on(self._inner.r#RepeatInt(_arg_token)) } fn r#RepeatLong(&self, _arg_token: i64) -> binder::Result { self._rt.block_on(self._inner.r#RepeatLong(_arg_token)) } fn r#RepeatFloat(&self, _arg_token: f32) -> binder::Result { self._rt.block_on(self._inner.r#RepeatFloat(_arg_token)) } fn r#RepeatDouble(&self, _arg_token: f64) -> binder::Result { self._rt.block_on(self._inner.r#RepeatDouble(_arg_token)) } fn r#RepeatString(&self, _arg_token: &str) -> binder::Result { self._rt.block_on(self._inner.r#RepeatString(_arg_token)) } fn r#RepeatByteEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum) -> binder::Result { self._rt.block_on(self._inner.r#RepeatByteEnum(_arg_token)) } fn r#RepeatIntEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum) -> binder::Result { self._rt.block_on(self._inner.r#RepeatIntEnum(_arg_token)) } fn r#RepeatLongEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum) -> binder::Result { self._rt.block_on(self._inner.r#RepeatLongEnum(_arg_token)) } fn r#ReverseBoolean(&self, _arg_input: &[bool], _arg_repeated: &mut Vec) -> binder::Result> { self._rt.block_on(self._inner.r#ReverseBoolean(_arg_input, _arg_repeated)) } fn r#ReverseByte(&self, _arg_input: &[u8], _arg_repeated: &mut Vec) -> binder::Result> { self._rt.block_on(self._inner.r#ReverseByte(_arg_input, _arg_repeated)) } fn r#ReverseChar(&self, _arg_input: &[u16], _arg_repeated: &mut Vec) -> binder::Result> { self._rt.block_on(self._inner.r#ReverseChar(_arg_input, _arg_repeated)) } fn r#ReverseInt(&self, _arg_input: &[i32], _arg_repeated: &mut Vec) -> binder::Result> { self._rt.block_on(self._inner.r#ReverseInt(_arg_input, _arg_repeated)) } fn r#ReverseLong(&self, _arg_input: &[i64], _arg_repeated: &mut Vec) -> binder::Result> { self._rt.block_on(self._inner.r#ReverseLong(_arg_input, _arg_repeated)) } fn r#ReverseFloat(&self, _arg_input: &[f32], _arg_repeated: &mut Vec) -> binder::Result> { self._rt.block_on(self._inner.r#ReverseFloat(_arg_input, _arg_repeated)) } fn r#ReverseDouble(&self, _arg_input: &[f64], _arg_repeated: &mut Vec) -> binder::Result> { self._rt.block_on(self._inner.r#ReverseDouble(_arg_input, _arg_repeated)) } fn r#ReverseString(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result> { self._rt.block_on(self._inner.r#ReverseString(_arg_input, _arg_repeated)) } fn r#ReverseByteEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum], _arg_repeated: &mut Vec) -> binder::Result> { self._rt.block_on(self._inner.r#ReverseByteEnum(_arg_input, _arg_repeated)) } fn r#ReverseIntEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum], _arg_repeated: &mut Vec) -> binder::Result> { self._rt.block_on(self._inner.r#ReverseIntEnum(_arg_input, _arg_repeated)) } fn r#ReverseLongEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum], _arg_repeated: &mut Vec) -> binder::Result> { self._rt.block_on(self._inner.r#ReverseLongEnum(_arg_input, _arg_repeated)) } fn r#GetOtherTestService(&self, _arg_name: &str) -> binder::Result> { self._rt.block_on(self._inner.r#GetOtherTestService(_arg_name)) } fn r#SetOtherTestService(&self, _arg_name: &str, _arg_service: &binder::Strong) -> binder::Result { self._rt.block_on(self._inner.r#SetOtherTestService(_arg_name, _arg_service)) } fn r#VerifyName(&self, _arg_service: &binder::Strong, _arg_name: &str) -> binder::Result { self._rt.block_on(self._inner.r#VerifyName(_arg_service, _arg_name)) } fn r#GetInterfaceArray(&self, _arg_names: &[String]) -> binder::Result>> { self._rt.block_on(self._inner.r#GetInterfaceArray(_arg_names)) } fn r#VerifyNamesWithInterfaceArray(&self, _arg_services: &[binder::Strong], _arg_names: &[String]) -> binder::Result { self._rt.block_on(self._inner.r#VerifyNamesWithInterfaceArray(_arg_services, _arg_names)) } fn r#GetNullableInterfaceArray(&self, _arg_names: Option<&[Option]>) -> binder::Result>>>> { self._rt.block_on(self._inner.r#GetNullableInterfaceArray(_arg_names)) } fn r#VerifyNamesWithNullableInterfaceArray(&self, _arg_services: Option<&[Option>]>, _arg_names: Option<&[Option]>) -> binder::Result { self._rt.block_on(self._inner.r#VerifyNamesWithNullableInterfaceArray(_arg_services, _arg_names)) } fn r#GetInterfaceList(&self, _arg_names: Option<&[Option]>) -> binder::Result>>>> { self._rt.block_on(self._inner.r#GetInterfaceList(_arg_names)) } fn r#VerifyNamesWithInterfaceList(&self, _arg_services: Option<&[Option>]>, _arg_names: Option<&[Option]>) -> binder::Result { self._rt.block_on(self._inner.r#VerifyNamesWithInterfaceList(_arg_services, _arg_names)) } fn r#ReverseStringList(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result> { self._rt.block_on(self._inner.r#ReverseStringList(_arg_input, _arg_repeated)) } fn r#RepeatParcelFileDescriptor(&self, _arg_read: &binder::ParcelFileDescriptor) -> binder::Result { self._rt.block_on(self._inner.r#RepeatParcelFileDescriptor(_arg_read)) } fn r#ReverseParcelFileDescriptorArray(&self, _arg_input: &[binder::ParcelFileDescriptor], _arg_repeated: &mut Vec>) -> binder::Result> { self._rt.block_on(self._inner.r#ReverseParcelFileDescriptorArray(_arg_input, _arg_repeated)) } fn r#ThrowServiceException(&self, _arg_code: i32) -> binder::Result<()> { self._rt.block_on(self._inner.r#ThrowServiceException(_arg_code)) } fn r#RepeatNullableIntArray(&self, _arg_input: Option<&[i32]>) -> binder::Result>> { self._rt.block_on(self._inner.r#RepeatNullableIntArray(_arg_input)) } fn r#RepeatNullableByteEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum]>) -> binder::Result>> { self._rt.block_on(self._inner.r#RepeatNullableByteEnumArray(_arg_input)) } fn r#RepeatNullableIntEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum]>) -> binder::Result>> { self._rt.block_on(self._inner.r#RepeatNullableIntEnumArray(_arg_input)) } fn r#RepeatNullableLongEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum]>) -> binder::Result>> { self._rt.block_on(self._inner.r#RepeatNullableLongEnumArray(_arg_input)) } fn r#RepeatNullableString(&self, _arg_input: Option<&str>) -> binder::Result> { self._rt.block_on(self._inner.r#RepeatNullableString(_arg_input)) } fn r#RepeatNullableStringList(&self, _arg_input: Option<&[Option]>) -> binder::Result>>> { self._rt.block_on(self._inner.r#RepeatNullableStringList(_arg_input)) } fn r#RepeatNullableParcelable(&self, _arg_input: Option<&crate::mangled::_7_android_4_aidl_5_tests_12_ITestService_5_Empty>) -> binder::Result> { self._rt.block_on(self._inner.r#RepeatNullableParcelable(_arg_input)) } fn r#RepeatNullableParcelableArray(&self, _arg_input: Option<&[Option]>) -> binder::Result>>> { self._rt.block_on(self._inner.r#RepeatNullableParcelableArray(_arg_input)) } fn r#RepeatNullableParcelableList(&self, _arg_input: Option<&[Option]>) -> binder::Result>>> { self._rt.block_on(self._inner.r#RepeatNullableParcelableList(_arg_input)) } fn r#TakesAnIBinder(&self, _arg_input: &binder::SpIBinder) -> binder::Result<()> { self._rt.block_on(self._inner.r#TakesAnIBinder(_arg_input)) } fn r#TakesANullableIBinder(&self, _arg_input: Option<&binder::SpIBinder>) -> binder::Result<()> { self._rt.block_on(self._inner.r#TakesANullableIBinder(_arg_input)) } fn r#TakesAnIBinderList(&self, _arg_input: &[binder::SpIBinder]) -> binder::Result<()> { self._rt.block_on(self._inner.r#TakesAnIBinderList(_arg_input)) } fn r#TakesANullableIBinderList(&self, _arg_input: Option<&[Option]>) -> binder::Result<()> { self._rt.block_on(self._inner.r#TakesANullableIBinderList(_arg_input)) } fn r#RepeatUtf8CppString(&self, _arg_token: &str) -> binder::Result { self._rt.block_on(self._inner.r#RepeatUtf8CppString(_arg_token)) } fn r#RepeatNullableUtf8CppString(&self, _arg_token: Option<&str>) -> binder::Result> { self._rt.block_on(self._inner.r#RepeatNullableUtf8CppString(_arg_token)) } fn r#ReverseUtf8CppString(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result> { self._rt.block_on(self._inner.r#ReverseUtf8CppString(_arg_input, _arg_repeated)) } fn r#ReverseNullableUtf8CppString(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>> { self._rt.block_on(self._inner.r#ReverseNullableUtf8CppString(_arg_input, _arg_repeated)) } fn r#ReverseUtf8CppStringList(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>> { self._rt.block_on(self._inner.r#ReverseUtf8CppStringList(_arg_input, _arg_repeated)) } fn r#GetCallback(&self, _arg_return_null: bool) -> binder::Result>> { self._rt.block_on(self._inner.r#GetCallback(_arg_return_null)) } fn r#FillOutStructuredParcelable(&self, _arg_parcel: &mut crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable) -> binder::Result<()> { self._rt.block_on(self._inner.r#FillOutStructuredParcelable(_arg_parcel)) } fn r#RepeatExtendableParcelable(&self, _arg_ep: &crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable, _arg_ep2: &mut crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable) -> binder::Result<()> { self._rt.block_on(self._inner.r#RepeatExtendableParcelable(_arg_ep, _arg_ep2)) } fn r#ReverseList(&self, _arg_list: &crate::mangled::_7_android_4_aidl_5_tests_13_RecursiveList) -> binder::Result { self._rt.block_on(self._inner.r#ReverseList(_arg_list)) } fn r#ReverseIBinderArray(&self, _arg_input: &[binder::SpIBinder], _arg_repeated: &mut Vec>) -> binder::Result> { self._rt.block_on(self._inner.r#ReverseIBinderArray(_arg_input, _arg_repeated)) } fn r#ReverseNullableIBinderArray(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>> { self._rt.block_on(self._inner.r#ReverseNullableIBinderArray(_arg_input, _arg_repeated)) } fn r#RepeatSimpleParcelable(&self, _arg_input: &simple_parcelable::SimpleParcelable, _arg_repeat: &mut simple_parcelable::SimpleParcelable) -> binder::Result { self._rt.block_on(self._inner.r#RepeatSimpleParcelable(_arg_input, _arg_repeat)) } fn r#ReverseSimpleParcelables(&self, _arg_input: &[simple_parcelable::SimpleParcelable], _arg_repeated: &mut Vec) -> binder::Result> { self._rt.block_on(self._inner.r#ReverseSimpleParcelables(_arg_input, _arg_repeated)) } fn r#GetOldNameInterface(&self) -> binder::Result> { self._rt.block_on(self._inner.r#GetOldNameInterface()) } fn r#GetNewNameInterface(&self) -> binder::Result> { self._rt.block_on(self._inner.r#GetNewNameInterface()) } fn r#GetUnionTags(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_5_Union]) -> binder::Result> { self._rt.block_on(self._inner.r#GetUnionTags(_arg_input)) } fn r#GetCppJavaTests(&self) -> binder::Result> { self._rt.block_on(self._inner.r#GetCppJavaTests()) } fn r#getBackendType(&self) -> binder::Result { self._rt.block_on(self._inner.r#getBackendType()) } fn r#GetCircular(&self, _arg_cp: &mut crate::mangled::_7_android_4_aidl_5_tests_18_CircularParcelable) -> binder::Result> { self._rt.block_on(self._inner.r#GetCircular(_arg_cp)) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait ITestServiceDefault: Send + Sync { fn r#UnimplementedMethod(&self, _arg_arg: i32) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#Deprecated(&self) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#TestOneway(&self) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatBoolean(&self, _arg_token: bool) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatByte(&self, _arg_token: i8) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatChar(&self, _arg_token: u16) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatInt(&self, _arg_token: i32) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatLong(&self, _arg_token: i64) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatFloat(&self, _arg_token: f32) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatDouble(&self, _arg_token: f64) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatString(&self, _arg_token: &str) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatByteEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatIntEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatLongEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseBoolean(&self, _arg_input: &[bool], _arg_repeated: &mut Vec) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseByte(&self, _arg_input: &[u8], _arg_repeated: &mut Vec) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseChar(&self, _arg_input: &[u16], _arg_repeated: &mut Vec) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseInt(&self, _arg_input: &[i32], _arg_repeated: &mut Vec) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseLong(&self, _arg_input: &[i64], _arg_repeated: &mut Vec) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseFloat(&self, _arg_input: &[f32], _arg_repeated: &mut Vec) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseDouble(&self, _arg_input: &[f64], _arg_repeated: &mut Vec) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseString(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseByteEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum], _arg_repeated: &mut Vec) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseIntEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum], _arg_repeated: &mut Vec) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseLongEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum], _arg_repeated: &mut Vec) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#GetOtherTestService(&self, _arg_name: &str) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#SetOtherTestService(&self, _arg_name: &str, _arg_service: &binder::Strong) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#VerifyName(&self, _arg_service: &binder::Strong, _arg_name: &str) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#GetInterfaceArray(&self, _arg_names: &[String]) -> binder::Result>> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#VerifyNamesWithInterfaceArray(&self, _arg_services: &[binder::Strong], _arg_names: &[String]) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#GetNullableInterfaceArray(&self, _arg_names: Option<&[Option]>) -> binder::Result>>>> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#VerifyNamesWithNullableInterfaceArray(&self, _arg_services: Option<&[Option>]>, _arg_names: Option<&[Option]>) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#GetInterfaceList(&self, _arg_names: Option<&[Option]>) -> binder::Result>>>> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#VerifyNamesWithInterfaceList(&self, _arg_services: Option<&[Option>]>, _arg_names: Option<&[Option]>) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseStringList(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatParcelFileDescriptor(&self, _arg_read: &binder::ParcelFileDescriptor) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseParcelFileDescriptorArray(&self, _arg_input: &[binder::ParcelFileDescriptor], _arg_repeated: &mut Vec>) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ThrowServiceException(&self, _arg_code: i32) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatNullableIntArray(&self, _arg_input: Option<&[i32]>) -> binder::Result>> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatNullableByteEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum]>) -> binder::Result>> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatNullableIntEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum]>) -> binder::Result>> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatNullableLongEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum]>) -> binder::Result>> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatNullableString(&self, _arg_input: Option<&str>) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatNullableStringList(&self, _arg_input: Option<&[Option]>) -> binder::Result>>> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatNullableParcelable(&self, _arg_input: Option<&crate::mangled::_7_android_4_aidl_5_tests_12_ITestService_5_Empty>) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatNullableParcelableArray(&self, _arg_input: Option<&[Option]>) -> binder::Result>>> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatNullableParcelableList(&self, _arg_input: Option<&[Option]>) -> binder::Result>>> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#TakesAnIBinder(&self, _arg_input: &binder::SpIBinder) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#TakesANullableIBinder(&self, _arg_input: Option<&binder::SpIBinder>) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#TakesAnIBinderList(&self, _arg_input: &[binder::SpIBinder]) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#TakesANullableIBinderList(&self, _arg_input: Option<&[Option]>) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatUtf8CppString(&self, _arg_token: &str) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatNullableUtf8CppString(&self, _arg_token: Option<&str>) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseUtf8CppString(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseNullableUtf8CppString(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseUtf8CppStringList(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#GetCallback(&self, _arg_return_null: bool) -> binder::Result>> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#FillOutStructuredParcelable(&self, _arg_parcel: &mut crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatExtendableParcelable(&self, _arg_ep: &crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable, _arg_ep2: &mut crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseList(&self, _arg_list: &crate::mangled::_7_android_4_aidl_5_tests_13_RecursiveList) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseIBinderArray(&self, _arg_input: &[binder::SpIBinder], _arg_repeated: &mut Vec>) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseNullableIBinderArray(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#RepeatSimpleParcelable(&self, _arg_input: &simple_parcelable::SimpleParcelable, _arg_repeat: &mut simple_parcelable::SimpleParcelable) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ReverseSimpleParcelables(&self, _arg_input: &[simple_parcelable::SimpleParcelable], _arg_repeated: &mut Vec) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#GetOldNameInterface(&self) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#GetNewNameInterface(&self) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#GetUnionTags(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_5_Union]) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#GetCppJavaTests(&self) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#getBackendType(&self) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#GetCircular(&self, _arg_cp: &mut crate::mangled::_7_android_4_aidl_5_tests_18_CircularParcelable) -> binder::Result> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#UnimplementedMethod: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; pub const r#Deprecated: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 1; pub const r#TestOneway: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 2; pub const r#RepeatBoolean: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 3; pub const r#RepeatByte: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 4; pub const r#RepeatChar: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 5; pub const r#RepeatInt: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 6; pub const r#RepeatLong: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 7; pub const r#RepeatFloat: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 8; pub const r#RepeatDouble: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 9; pub const r#RepeatString: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 10; pub const r#RepeatByteEnum: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 11; pub const r#RepeatIntEnum: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 12; pub const r#RepeatLongEnum: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 13; pub const r#ReverseBoolean: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 14; pub const r#ReverseByte: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 15; pub const r#ReverseChar: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 16; pub const r#ReverseInt: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 17; pub const r#ReverseLong: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 18; pub const r#ReverseFloat: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 19; pub const r#ReverseDouble: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 20; pub const r#ReverseString: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 21; pub const r#ReverseByteEnum: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 22; pub const r#ReverseIntEnum: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 23; pub const r#ReverseLongEnum: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 24; pub const r#GetOtherTestService: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 25; pub const r#SetOtherTestService: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 26; pub const r#VerifyName: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 27; pub const r#GetInterfaceArray: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 28; pub const r#VerifyNamesWithInterfaceArray: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 29; pub const r#GetNullableInterfaceArray: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 30; pub const r#VerifyNamesWithNullableInterfaceArray: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 31; pub const r#GetInterfaceList: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 32; pub const r#VerifyNamesWithInterfaceList: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 33; pub const r#ReverseStringList: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 34; pub const r#RepeatParcelFileDescriptor: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 35; pub const r#ReverseParcelFileDescriptorArray: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 36; pub const r#ThrowServiceException: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 37; pub const r#RepeatNullableIntArray: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 38; pub const r#RepeatNullableByteEnumArray: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 39; pub const r#RepeatNullableIntEnumArray: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 40; pub const r#RepeatNullableLongEnumArray: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 41; pub const r#RepeatNullableString: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 42; pub const r#RepeatNullableStringList: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 43; pub const r#RepeatNullableParcelable: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 44; pub const r#RepeatNullableParcelableArray: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 45; pub const r#RepeatNullableParcelableList: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 46; pub const r#TakesAnIBinder: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 47; pub const r#TakesANullableIBinder: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 48; pub const r#TakesAnIBinderList: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 49; pub const r#TakesANullableIBinderList: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 50; pub const r#RepeatUtf8CppString: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 51; pub const r#RepeatNullableUtf8CppString: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 52; pub const r#ReverseUtf8CppString: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 53; pub const r#ReverseNullableUtf8CppString: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 54; pub const r#ReverseUtf8CppStringList: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 55; pub const r#GetCallback: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 56; pub const r#FillOutStructuredParcelable: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 57; pub const r#RepeatExtendableParcelable: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 58; pub const r#ReverseList: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 59; pub const r#ReverseIBinderArray: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 60; pub const r#ReverseNullableIBinderArray: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 61; pub const r#RepeatSimpleParcelable: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 62; pub const r#ReverseSimpleParcelables: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 63; pub const r#GetOldNameInterface: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 64; pub const r#GetNewNameInterface: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 65; pub const r#GetUnionTags: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 66; pub const r#GetCppJavaTests: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 67; pub const r#getBackendType: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 68; pub const r#GetCircular: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 69; } pub type ITestServiceDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); pub const r#CONSTANT: i32 = 42; pub const r#CONSTANT2: i32 = -42; pub const r#CONSTANT3: i32 = 42; pub const r#CONSTANT4: i32 = 4; pub const r#CONSTANT5: i32 = -4; pub const r#CONSTANT6: i32 = 0; pub const r#CONSTANT7: i32 = 0; pub const r#CONSTANT8: i32 = 0; pub const r#CONSTANT9: i32 = 86; pub const r#CONSTANT10: i32 = 165; pub const r#CONSTANT11: i32 = 250; pub const r#CONSTANT12: i32 = -1; pub const r#BYTE_CONSTANT: i8 = 17; pub const r#LONG_CONSTANT: i64 = 1099511627776; pub const r#STRING_CONSTANT: &str = "foo"; pub const r#STRING_CONSTANT2: &str = "bar"; pub const r#FLOAT_CONSTANT: f32 = 1.000000f32; pub const r#FLOAT_CONSTANT2: f32 = -1.000000f32; pub const r#FLOAT_CONSTANT3: f32 = 1.000000f32; pub const r#FLOAT_CONSTANT4: f32 = 2.200000f32; pub const r#FLOAT_CONSTANT5: f32 = -2.200000f32; pub const r#FLOAT_CONSTANT6: f32 = -0.000000f32; pub const r#FLOAT_CONSTANT7: f32 = 0.000000f32; pub const r#DOUBLE_CONSTANT: f64 = 1.000000f64; pub const r#DOUBLE_CONSTANT2: f64 = -1.000000f64; pub const r#DOUBLE_CONSTANT3: f64 = 1.000000f64; pub const r#DOUBLE_CONSTANT4: f64 = 2.200000f64; pub const r#DOUBLE_CONSTANT5: f64 = -2.200000f64; pub const r#DOUBLE_CONSTANT6: f64 = -0.000000f64; pub const r#DOUBLE_CONSTANT7: f64 = 0.000000f64; pub const r#DOUBLE_CONSTANT8: f64 = 1.100000f64; pub const r#DOUBLE_CONSTANT9: f64 = -1.100000f64; pub const r#STRING_CONSTANT_UTF8: &str = "baz"; pub const r#A1: i32 = 1; pub const r#A2: i32 = 1; pub const r#A3: i32 = 1; pub const r#A4: i32 = 1; pub const r#A5: i32 = 1; pub const r#A6: i32 = 1; pub const r#A7: i32 = 1; pub const r#A8: i32 = 1; pub const r#A9: i32 = 1; pub const r#A10: i32 = 1; pub const r#A11: i32 = 1; pub const r#A12: i32 = 1; pub const r#A13: i32 = 1; pub const r#A14: i32 = 1; pub const r#A15: i32 = 1; pub const r#A16: i32 = 1; pub const r#A17: i32 = 1; pub const r#A18: i32 = 1; pub const r#A19: i32 = 1; pub const r#A20: i32 = 1; pub const r#A21: i32 = 1; pub const r#A22: i32 = 1; pub const r#A23: i32 = 1; pub const r#A24: i32 = 1; pub const r#A25: i32 = 1; pub const r#A26: i32 = 1; pub const r#A27: i32 = 1; pub const r#A28: i32 = 1; pub const r#A29: i32 = 1; pub const r#A30: i32 = 1; pub const r#A31: i32 = 1; pub const r#A32: i32 = 1; pub const r#A33: i32 = 1; pub const r#A34: i32 = 1; pub const r#A35: i32 = 1; pub const r#A36: i32 = 1; pub const r#A37: i32 = 1; pub const r#A38: i32 = 1; pub const r#A39: i32 = 1; pub const r#A40: i32 = 1; pub const r#A41: i32 = 1; pub const r#A42: i32 = 1; pub const r#A43: i32 = 1; pub const r#A44: i32 = 1; pub const r#A45: i32 = 1; pub const r#A46: i32 = 1; pub const r#A47: i32 = 1; pub const r#A48: i32 = 1; pub const r#A49: i32 = 1; pub const r#A50: i32 = 1; pub const r#A51: i32 = 1; pub const r#A52: i32 = 1; pub const r#A53: i32 = 1; pub const r#A54: i32 = 1; pub const r#A55: i32 = 1; pub const r#A56: i32 = 1; pub const r#A57: i32 = 1; impl BpTestService { fn build_parcel_UnimplementedMethod(&self, _arg_arg: i32) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_arg)?; Ok(aidl_data) } fn read_response_UnimplementedMethod(&self, _arg_arg: i32, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#UnimplementedMethod(_arg_arg); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: i32 = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_Deprecated(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); Ok(aidl_data) } fn read_response_Deprecated(&self, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#Deprecated(); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } Ok(()) } fn build_parcel_TestOneway(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); Ok(aidl_data) } fn read_response_TestOneway(&self, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#TestOneway(); } } let _aidl_reply = _aidl_reply?; Ok(()) } fn build_parcel_RepeatBoolean(&self, _arg_token: bool) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_token)?; Ok(aidl_data) } fn read_response_RepeatBoolean(&self, _arg_token: bool, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatBoolean(_arg_token); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: bool = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatByte(&self, _arg_token: i8) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_token)?; Ok(aidl_data) } fn read_response_RepeatByte(&self, _arg_token: i8, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatByte(_arg_token); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: i8 = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatChar(&self, _arg_token: u16) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_token)?; Ok(aidl_data) } fn read_response_RepeatChar(&self, _arg_token: u16, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatChar(_arg_token); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: u16 = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatInt(&self, _arg_token: i32) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_token)?; Ok(aidl_data) } fn read_response_RepeatInt(&self, _arg_token: i32, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatInt(_arg_token); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: i32 = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatLong(&self, _arg_token: i64) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_token)?; Ok(aidl_data) } fn read_response_RepeatLong(&self, _arg_token: i64, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatLong(_arg_token); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: i64 = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatFloat(&self, _arg_token: f32) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_token)?; Ok(aidl_data) } fn read_response_RepeatFloat(&self, _arg_token: f32, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatFloat(_arg_token); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: f32 = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatDouble(&self, _arg_token: f64) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_token)?; Ok(aidl_data) } fn read_response_RepeatDouble(&self, _arg_token: f64, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatDouble(_arg_token); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: f64 = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatString(&self, _arg_token: &str) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_token)?; Ok(aidl_data) } fn read_response_RepeatString(&self, _arg_token: &str, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatString(_arg_token); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: String = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatByteEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_token)?; Ok(aidl_data) } fn read_response_RepeatByteEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatByteEnum(_arg_token); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatIntEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_token)?; Ok(aidl_data) } fn read_response_RepeatIntEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatIntEnum(_arg_token); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatLongEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_token)?; Ok(aidl_data) } fn read_response_RepeatLongEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatLongEnum(_arg_token); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_ReverseBoolean(&self, _arg_input: &[bool], _arg_repeated: &mut Vec) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; aidl_data.write_slice_size(Some(_arg_repeated))?; Ok(aidl_data) } fn read_response_ReverseBoolean(&self, _arg_input: &[bool], _arg_repeated: &mut Vec, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseBoolean(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_ReverseByte(&self, _arg_input: &[u8], _arg_repeated: &mut Vec) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; aidl_data.write_slice_size(Some(_arg_repeated))?; Ok(aidl_data) } fn read_response_ReverseByte(&self, _arg_input: &[u8], _arg_repeated: &mut Vec, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseByte(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_ReverseChar(&self, _arg_input: &[u16], _arg_repeated: &mut Vec) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; aidl_data.write_slice_size(Some(_arg_repeated))?; Ok(aidl_data) } fn read_response_ReverseChar(&self, _arg_input: &[u16], _arg_repeated: &mut Vec, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseChar(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_ReverseInt(&self, _arg_input: &[i32], _arg_repeated: &mut Vec) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; aidl_data.write_slice_size(Some(_arg_repeated))?; Ok(aidl_data) } fn read_response_ReverseInt(&self, _arg_input: &[i32], _arg_repeated: &mut Vec, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseInt(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_ReverseLong(&self, _arg_input: &[i64], _arg_repeated: &mut Vec) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; aidl_data.write_slice_size(Some(_arg_repeated))?; Ok(aidl_data) } fn read_response_ReverseLong(&self, _arg_input: &[i64], _arg_repeated: &mut Vec, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseLong(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_ReverseFloat(&self, _arg_input: &[f32], _arg_repeated: &mut Vec) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; aidl_data.write_slice_size(Some(_arg_repeated))?; Ok(aidl_data) } fn read_response_ReverseFloat(&self, _arg_input: &[f32], _arg_repeated: &mut Vec, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseFloat(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_ReverseDouble(&self, _arg_input: &[f64], _arg_repeated: &mut Vec) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; aidl_data.write_slice_size(Some(_arg_repeated))?; Ok(aidl_data) } fn read_response_ReverseDouble(&self, _arg_input: &[f64], _arg_repeated: &mut Vec, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseDouble(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_ReverseString(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; aidl_data.write_slice_size(Some(_arg_repeated))?; Ok(aidl_data) } fn read_response_ReverseString(&self, _arg_input: &[String], _arg_repeated: &mut Vec, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseString(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_ReverseByteEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum], _arg_repeated: &mut Vec) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; aidl_data.write_slice_size(Some(_arg_repeated))?; Ok(aidl_data) } fn read_response_ReverseByteEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum], _arg_repeated: &mut Vec, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseByteEnum(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_ReverseIntEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum], _arg_repeated: &mut Vec) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; aidl_data.write_slice_size(Some(_arg_repeated))?; Ok(aidl_data) } fn read_response_ReverseIntEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum], _arg_repeated: &mut Vec, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseIntEnum(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_ReverseLongEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum], _arg_repeated: &mut Vec) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; aidl_data.write_slice_size(Some(_arg_repeated))?; Ok(aidl_data) } fn read_response_ReverseLongEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum], _arg_repeated: &mut Vec, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseLongEnum(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_GetOtherTestService(&self, _arg_name: &str) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_name)?; Ok(aidl_data) } fn read_response_GetOtherTestService(&self, _arg_name: &str, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#GetOtherTestService(_arg_name); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: binder::Strong = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_SetOtherTestService(&self, _arg_name: &str, _arg_service: &binder::Strong) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_name)?; aidl_data.write(_arg_service)?; Ok(aidl_data) } fn read_response_SetOtherTestService(&self, _arg_name: &str, _arg_service: &binder::Strong, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#SetOtherTestService(_arg_name, _arg_service); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: bool = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_VerifyName(&self, _arg_service: &binder::Strong, _arg_name: &str) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_service)?; aidl_data.write(_arg_name)?; Ok(aidl_data) } fn read_response_VerifyName(&self, _arg_service: &binder::Strong, _arg_name: &str, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#VerifyName(_arg_service, _arg_name); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: bool = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_GetInterfaceArray(&self, _arg_names: &[String]) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_names)?; Ok(aidl_data) } fn read_response_GetInterfaceArray(&self, _arg_names: &[String], _aidl_reply: std::result::Result) -> binder::Result>> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#GetInterfaceArray(_arg_names); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec> = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_VerifyNamesWithInterfaceArray(&self, _arg_services: &[binder::Strong], _arg_names: &[String]) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_services)?; aidl_data.write(_arg_names)?; Ok(aidl_data) } fn read_response_VerifyNamesWithInterfaceArray(&self, _arg_services: &[binder::Strong], _arg_names: &[String], _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#VerifyNamesWithInterfaceArray(_arg_services, _arg_names); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: bool = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_GetNullableInterfaceArray(&self, _arg_names: Option<&[Option]>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_names)?; Ok(aidl_data) } fn read_response_GetNullableInterfaceArray(&self, _arg_names: Option<&[Option]>, _aidl_reply: std::result::Result) -> binder::Result>>>> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#GetNullableInterfaceArray(_arg_names); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option>>> = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_VerifyNamesWithNullableInterfaceArray(&self, _arg_services: Option<&[Option>]>, _arg_names: Option<&[Option]>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_services)?; aidl_data.write(&_arg_names)?; Ok(aidl_data) } fn read_response_VerifyNamesWithNullableInterfaceArray(&self, _arg_services: Option<&[Option>]>, _arg_names: Option<&[Option]>, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#VerifyNamesWithNullableInterfaceArray(_arg_services, _arg_names); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: bool = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_GetInterfaceList(&self, _arg_names: Option<&[Option]>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_names)?; Ok(aidl_data) } fn read_response_GetInterfaceList(&self, _arg_names: Option<&[Option]>, _aidl_reply: std::result::Result) -> binder::Result>>>> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#GetInterfaceList(_arg_names); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option>>> = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_VerifyNamesWithInterfaceList(&self, _arg_services: Option<&[Option>]>, _arg_names: Option<&[Option]>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_services)?; aidl_data.write(&_arg_names)?; Ok(aidl_data) } fn read_response_VerifyNamesWithInterfaceList(&self, _arg_services: Option<&[Option>]>, _arg_names: Option<&[Option]>, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#VerifyNamesWithInterfaceList(_arg_services, _arg_names); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: bool = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_ReverseStringList(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_ReverseStringList(&self, _arg_input: &[String], _arg_repeated: &mut Vec, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseStringList(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_RepeatParcelFileDescriptor(&self, _arg_read: &binder::ParcelFileDescriptor) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_read)?; Ok(aidl_data) } fn read_response_RepeatParcelFileDescriptor(&self, _arg_read: &binder::ParcelFileDescriptor, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatParcelFileDescriptor(_arg_read); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: binder::ParcelFileDescriptor = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_ReverseParcelFileDescriptorArray(&self, _arg_input: &[binder::ParcelFileDescriptor], _arg_repeated: &mut Vec>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; aidl_data.write_slice_size(Some(_arg_repeated))?; Ok(aidl_data) } fn read_response_ReverseParcelFileDescriptorArray(&self, _arg_input: &[binder::ParcelFileDescriptor], _arg_repeated: &mut Vec>, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseParcelFileDescriptorArray(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_ThrowServiceException(&self, _arg_code: i32) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_code)?; Ok(aidl_data) } fn read_response_ThrowServiceException(&self, _arg_code: i32, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ThrowServiceException(_arg_code); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } Ok(()) } fn build_parcel_RepeatNullableIntArray(&self, _arg_input: Option<&[i32]>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_input)?; Ok(aidl_data) } fn read_response_RepeatNullableIntArray(&self, _arg_input: Option<&[i32]>, _aidl_reply: std::result::Result) -> binder::Result>> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatNullableIntArray(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option> = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatNullableByteEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum]>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_input)?; Ok(aidl_data) } fn read_response_RepeatNullableByteEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum]>, _aidl_reply: std::result::Result) -> binder::Result>> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatNullableByteEnumArray(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option> = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatNullableIntEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum]>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_input)?; Ok(aidl_data) } fn read_response_RepeatNullableIntEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum]>, _aidl_reply: std::result::Result) -> binder::Result>> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatNullableIntEnumArray(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option> = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatNullableLongEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum]>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_input)?; Ok(aidl_data) } fn read_response_RepeatNullableLongEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum]>, _aidl_reply: std::result::Result) -> binder::Result>> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatNullableLongEnumArray(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option> = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatNullableString(&self, _arg_input: Option<&str>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_input)?; Ok(aidl_data) } fn read_response_RepeatNullableString(&self, _arg_input: Option<&str>, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatNullableString(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatNullableStringList(&self, _arg_input: Option<&[Option]>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_input)?; Ok(aidl_data) } fn read_response_RepeatNullableStringList(&self, _arg_input: Option<&[Option]>, _aidl_reply: std::result::Result) -> binder::Result>>> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatNullableStringList(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option>> = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatNullableParcelable(&self, _arg_input: Option<&crate::mangled::_7_android_4_aidl_5_tests_12_ITestService_5_Empty>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_input)?; Ok(aidl_data) } fn read_response_RepeatNullableParcelable(&self, _arg_input: Option<&crate::mangled::_7_android_4_aidl_5_tests_12_ITestService_5_Empty>, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatNullableParcelable(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatNullableParcelableArray(&self, _arg_input: Option<&[Option]>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_input)?; Ok(aidl_data) } fn read_response_RepeatNullableParcelableArray(&self, _arg_input: Option<&[Option]>, _aidl_reply: std::result::Result) -> binder::Result>>> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatNullableParcelableArray(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option>> = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatNullableParcelableList(&self, _arg_input: Option<&[Option]>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_input)?; Ok(aidl_data) } fn read_response_RepeatNullableParcelableList(&self, _arg_input: Option<&[Option]>, _aidl_reply: std::result::Result) -> binder::Result>>> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatNullableParcelableList(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option>> = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_TakesAnIBinder(&self, _arg_input: &binder::SpIBinder) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_TakesAnIBinder(&self, _arg_input: &binder::SpIBinder, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#TakesAnIBinder(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } Ok(()) } fn build_parcel_TakesANullableIBinder(&self, _arg_input: Option<&binder::SpIBinder>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_input)?; Ok(aidl_data) } fn read_response_TakesANullableIBinder(&self, _arg_input: Option<&binder::SpIBinder>, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#TakesANullableIBinder(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } Ok(()) } fn build_parcel_TakesAnIBinderList(&self, _arg_input: &[binder::SpIBinder]) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_TakesAnIBinderList(&self, _arg_input: &[binder::SpIBinder], _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#TakesAnIBinderList(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } Ok(()) } fn build_parcel_TakesANullableIBinderList(&self, _arg_input: Option<&[Option]>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_input)?; Ok(aidl_data) } fn read_response_TakesANullableIBinderList(&self, _arg_input: Option<&[Option]>, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#TakesANullableIBinderList(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } Ok(()) } fn build_parcel_RepeatUtf8CppString(&self, _arg_token: &str) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_token)?; Ok(aidl_data) } fn read_response_RepeatUtf8CppString(&self, _arg_token: &str, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatUtf8CppString(_arg_token); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: String = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_RepeatNullableUtf8CppString(&self, _arg_token: Option<&str>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_token)?; Ok(aidl_data) } fn read_response_RepeatNullableUtf8CppString(&self, _arg_token: Option<&str>, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatNullableUtf8CppString(_arg_token); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_ReverseUtf8CppString(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; aidl_data.write_slice_size(Some(_arg_repeated))?; Ok(aidl_data) } fn read_response_ReverseUtf8CppString(&self, _arg_input: &[String], _arg_repeated: &mut Vec, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseUtf8CppString(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_ReverseNullableUtf8CppString(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_input)?; aidl_data.write_slice_size(_arg_repeated.as_deref())?; Ok(aidl_data) } fn read_response_ReverseNullableUtf8CppString(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>, _aidl_reply: std::result::Result) -> binder::Result>>> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseNullableUtf8CppString(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option>> = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_ReverseUtf8CppStringList(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_input)?; Ok(aidl_data) } fn read_response_ReverseUtf8CppStringList(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>, _aidl_reply: std::result::Result) -> binder::Result>>> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseUtf8CppStringList(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option>> = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_GetCallback(&self, _arg_return_null: bool) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_return_null)?; Ok(aidl_data) } fn read_response_GetCallback(&self, _arg_return_null: bool, _aidl_reply: std::result::Result) -> binder::Result>> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#GetCallback(_arg_return_null); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option> = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_FillOutStructuredParcelable(&self, _arg_parcel: &mut crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_parcel)?; Ok(aidl_data) } fn read_response_FillOutStructuredParcelable(&self, _arg_parcel: &mut crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#FillOutStructuredParcelable(_arg_parcel); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } _aidl_reply.read_onto(_arg_parcel)?; Ok(()) } fn build_parcel_RepeatExtendableParcelable(&self, _arg_ep: &crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable, _arg_ep2: &mut crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_ep)?; Ok(aidl_data) } fn read_response_RepeatExtendableParcelable(&self, _arg_ep: &crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable, _arg_ep2: &mut crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatExtendableParcelable(_arg_ep, _arg_ep2); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } _aidl_reply.read_onto(_arg_ep2)?; Ok(()) } fn build_parcel_ReverseList(&self, _arg_list: &crate::mangled::_7_android_4_aidl_5_tests_13_RecursiveList) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_list)?; Ok(aidl_data) } fn read_response_ReverseList(&self, _arg_list: &crate::mangled::_7_android_4_aidl_5_tests_13_RecursiveList, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseList(_arg_list); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_5_tests_13_RecursiveList = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_ReverseIBinderArray(&self, _arg_input: &[binder::SpIBinder], _arg_repeated: &mut Vec>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; aidl_data.write_slice_size(Some(_arg_repeated))?; Ok(aidl_data) } fn read_response_ReverseIBinderArray(&self, _arg_input: &[binder::SpIBinder], _arg_repeated: &mut Vec>, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseIBinderArray(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_ReverseNullableIBinderArray(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(&_arg_input)?; aidl_data.write_slice_size(_arg_repeated.as_deref())?; Ok(aidl_data) } fn read_response_ReverseNullableIBinderArray(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>, _aidl_reply: std::result::Result) -> binder::Result>>> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseNullableIBinderArray(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option>> = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_RepeatSimpleParcelable(&self, _arg_input: &simple_parcelable::SimpleParcelable, _arg_repeat: &mut simple_parcelable::SimpleParcelable) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_RepeatSimpleParcelable(&self, _arg_input: &simple_parcelable::SimpleParcelable, _arg_repeat: &mut simple_parcelable::SimpleParcelable, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#RepeatSimpleParcelable(_arg_input, _arg_repeat); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: simple_parcelable::SimpleParcelable = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeat)?; Ok(_aidl_return) } fn build_parcel_ReverseSimpleParcelables(&self, _arg_input: &[simple_parcelable::SimpleParcelable], _arg_repeated: &mut Vec) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; aidl_data.write_slice_size(Some(_arg_repeated))?; Ok(aidl_data) } fn read_response_ReverseSimpleParcelables(&self, _arg_input: &[simple_parcelable::SimpleParcelable], _arg_repeated: &mut Vec, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ReverseSimpleParcelables(_arg_input, _arg_repeated); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_repeated)?; Ok(_aidl_return) } fn build_parcel_GetOldNameInterface(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); Ok(aidl_data) } fn read_response_GetOldNameInterface(&self, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#GetOldNameInterface(); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: binder::Strong = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_GetNewNameInterface(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); Ok(aidl_data) } fn read_response_GetNewNameInterface(&self, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#GetNewNameInterface(); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: binder::Strong = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_GetUnionTags(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_5_Union]) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_GetUnionTags(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_5_Union], _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#GetUnionTags(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Vec = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_GetCppJavaTests(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); Ok(aidl_data) } fn read_response_GetCppJavaTests(&self, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#GetCppJavaTests(); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_getBackendType(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); Ok(aidl_data) } fn read_response_getBackendType(&self, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#getBackendType(); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_5_tests_11_BackendType = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_GetCircular(&self, _arg_cp: &mut crate::mangled::_7_android_4_aidl_5_tests_18_CircularParcelable) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.mark_sensitive(); Ok(aidl_data) } fn read_response_GetCircular(&self, _arg_cp: &mut crate::mangled::_7_android_4_aidl_5_tests_18_CircularParcelable, _aidl_reply: std::result::Result) -> binder::Result> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#GetCircular(_arg_cp); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: binder::Strong = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_cp)?; Ok(_aidl_return) } } impl ITestService for BpTestService { fn r#UnimplementedMethod(&self, _arg_arg: i32) -> binder::Result { let _aidl_data = self.build_parcel_UnimplementedMethod(_arg_arg)?; let _aidl_reply = self.binder.submit_transact(transactions::r#UnimplementedMethod, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_UnimplementedMethod(_arg_arg, _aidl_reply) } fn r#Deprecated(&self) -> binder::Result<()> { let _aidl_data = self.build_parcel_Deprecated()?; let _aidl_reply = self.binder.submit_transact(transactions::r#Deprecated, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_Deprecated(_aidl_reply) } fn r#TestOneway(&self) -> binder::Result<()> { let _aidl_data = self.build_parcel_TestOneway()?; let _aidl_reply = self.binder.submit_transact(transactions::r#TestOneway, _aidl_data, binder::binder_impl::FLAG_ONEWAY | binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_TestOneway(_aidl_reply) } fn r#RepeatBoolean(&self, _arg_token: bool) -> binder::Result { let _aidl_data = self.build_parcel_RepeatBoolean(_arg_token)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatBoolean, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatBoolean(_arg_token, _aidl_reply) } fn r#RepeatByte(&self, _arg_token: i8) -> binder::Result { let _aidl_data = self.build_parcel_RepeatByte(_arg_token)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatByte, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatByte(_arg_token, _aidl_reply) } fn r#RepeatChar(&self, _arg_token: u16) -> binder::Result { let _aidl_data = self.build_parcel_RepeatChar(_arg_token)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatChar, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatChar(_arg_token, _aidl_reply) } fn r#RepeatInt(&self, _arg_token: i32) -> binder::Result { let _aidl_data = self.build_parcel_RepeatInt(_arg_token)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatInt, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatInt(_arg_token, _aidl_reply) } fn r#RepeatLong(&self, _arg_token: i64) -> binder::Result { let _aidl_data = self.build_parcel_RepeatLong(_arg_token)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatLong, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatLong(_arg_token, _aidl_reply) } fn r#RepeatFloat(&self, _arg_token: f32) -> binder::Result { let _aidl_data = self.build_parcel_RepeatFloat(_arg_token)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatFloat, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatFloat(_arg_token, _aidl_reply) } fn r#RepeatDouble(&self, _arg_token: f64) -> binder::Result { let _aidl_data = self.build_parcel_RepeatDouble(_arg_token)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatDouble, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatDouble(_arg_token, _aidl_reply) } fn r#RepeatString(&self, _arg_token: &str) -> binder::Result { let _aidl_data = self.build_parcel_RepeatString(_arg_token)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatString, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatString(_arg_token, _aidl_reply) } fn r#RepeatByteEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum) -> binder::Result { let _aidl_data = self.build_parcel_RepeatByteEnum(_arg_token)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatByteEnum, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatByteEnum(_arg_token, _aidl_reply) } fn r#RepeatIntEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum) -> binder::Result { let _aidl_data = self.build_parcel_RepeatIntEnum(_arg_token)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatIntEnum, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatIntEnum(_arg_token, _aidl_reply) } fn r#RepeatLongEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum) -> binder::Result { let _aidl_data = self.build_parcel_RepeatLongEnum(_arg_token)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatLongEnum, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatLongEnum(_arg_token, _aidl_reply) } fn r#ReverseBoolean(&self, _arg_input: &[bool], _arg_repeated: &mut Vec) -> binder::Result> { let _aidl_data = self.build_parcel_ReverseBoolean(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseBoolean, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseBoolean(_arg_input, _arg_repeated, _aidl_reply) } fn r#ReverseByte(&self, _arg_input: &[u8], _arg_repeated: &mut Vec) -> binder::Result> { let _aidl_data = self.build_parcel_ReverseByte(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseByte, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseByte(_arg_input, _arg_repeated, _aidl_reply) } fn r#ReverseChar(&self, _arg_input: &[u16], _arg_repeated: &mut Vec) -> binder::Result> { let _aidl_data = self.build_parcel_ReverseChar(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseChar, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseChar(_arg_input, _arg_repeated, _aidl_reply) } fn r#ReverseInt(&self, _arg_input: &[i32], _arg_repeated: &mut Vec) -> binder::Result> { let _aidl_data = self.build_parcel_ReverseInt(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseInt, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseInt(_arg_input, _arg_repeated, _aidl_reply) } fn r#ReverseLong(&self, _arg_input: &[i64], _arg_repeated: &mut Vec) -> binder::Result> { let _aidl_data = self.build_parcel_ReverseLong(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseLong, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseLong(_arg_input, _arg_repeated, _aidl_reply) } fn r#ReverseFloat(&self, _arg_input: &[f32], _arg_repeated: &mut Vec) -> binder::Result> { let _aidl_data = self.build_parcel_ReverseFloat(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseFloat, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseFloat(_arg_input, _arg_repeated, _aidl_reply) } fn r#ReverseDouble(&self, _arg_input: &[f64], _arg_repeated: &mut Vec) -> binder::Result> { let _aidl_data = self.build_parcel_ReverseDouble(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseDouble, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseDouble(_arg_input, _arg_repeated, _aidl_reply) } fn r#ReverseString(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result> { let _aidl_data = self.build_parcel_ReverseString(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseString, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseString(_arg_input, _arg_repeated, _aidl_reply) } fn r#ReverseByteEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum], _arg_repeated: &mut Vec) -> binder::Result> { let _aidl_data = self.build_parcel_ReverseByteEnum(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseByteEnum, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseByteEnum(_arg_input, _arg_repeated, _aidl_reply) } fn r#ReverseIntEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum], _arg_repeated: &mut Vec) -> binder::Result> { let _aidl_data = self.build_parcel_ReverseIntEnum(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseIntEnum, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseIntEnum(_arg_input, _arg_repeated, _aidl_reply) } fn r#ReverseLongEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum], _arg_repeated: &mut Vec) -> binder::Result> { let _aidl_data = self.build_parcel_ReverseLongEnum(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseLongEnum, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseLongEnum(_arg_input, _arg_repeated, _aidl_reply) } fn r#GetOtherTestService(&self, _arg_name: &str) -> binder::Result> { let _aidl_data = self.build_parcel_GetOtherTestService(_arg_name)?; let _aidl_reply = self.binder.submit_transact(transactions::r#GetOtherTestService, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_GetOtherTestService(_arg_name, _aidl_reply) } fn r#SetOtherTestService(&self, _arg_name: &str, _arg_service: &binder::Strong) -> binder::Result { let _aidl_data = self.build_parcel_SetOtherTestService(_arg_name, _arg_service)?; let _aidl_reply = self.binder.submit_transact(transactions::r#SetOtherTestService, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_SetOtherTestService(_arg_name, _arg_service, _aidl_reply) } fn r#VerifyName(&self, _arg_service: &binder::Strong, _arg_name: &str) -> binder::Result { let _aidl_data = self.build_parcel_VerifyName(_arg_service, _arg_name)?; let _aidl_reply = self.binder.submit_transact(transactions::r#VerifyName, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_VerifyName(_arg_service, _arg_name, _aidl_reply) } fn r#GetInterfaceArray(&self, _arg_names: &[String]) -> binder::Result>> { let _aidl_data = self.build_parcel_GetInterfaceArray(_arg_names)?; let _aidl_reply = self.binder.submit_transact(transactions::r#GetInterfaceArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_GetInterfaceArray(_arg_names, _aidl_reply) } fn r#VerifyNamesWithInterfaceArray(&self, _arg_services: &[binder::Strong], _arg_names: &[String]) -> binder::Result { let _aidl_data = self.build_parcel_VerifyNamesWithInterfaceArray(_arg_services, _arg_names)?; let _aidl_reply = self.binder.submit_transact(transactions::r#VerifyNamesWithInterfaceArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_VerifyNamesWithInterfaceArray(_arg_services, _arg_names, _aidl_reply) } fn r#GetNullableInterfaceArray(&self, _arg_names: Option<&[Option]>) -> binder::Result>>>> { let _aidl_data = self.build_parcel_GetNullableInterfaceArray(_arg_names)?; let _aidl_reply = self.binder.submit_transact(transactions::r#GetNullableInterfaceArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_GetNullableInterfaceArray(_arg_names, _aidl_reply) } fn r#VerifyNamesWithNullableInterfaceArray(&self, _arg_services: Option<&[Option>]>, _arg_names: Option<&[Option]>) -> binder::Result { let _aidl_data = self.build_parcel_VerifyNamesWithNullableInterfaceArray(_arg_services, _arg_names)?; let _aidl_reply = self.binder.submit_transact(transactions::r#VerifyNamesWithNullableInterfaceArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_VerifyNamesWithNullableInterfaceArray(_arg_services, _arg_names, _aidl_reply) } fn r#GetInterfaceList(&self, _arg_names: Option<&[Option]>) -> binder::Result>>>> { let _aidl_data = self.build_parcel_GetInterfaceList(_arg_names)?; let _aidl_reply = self.binder.submit_transact(transactions::r#GetInterfaceList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_GetInterfaceList(_arg_names, _aidl_reply) } fn r#VerifyNamesWithInterfaceList(&self, _arg_services: Option<&[Option>]>, _arg_names: Option<&[Option]>) -> binder::Result { let _aidl_data = self.build_parcel_VerifyNamesWithInterfaceList(_arg_services, _arg_names)?; let _aidl_reply = self.binder.submit_transact(transactions::r#VerifyNamesWithInterfaceList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_VerifyNamesWithInterfaceList(_arg_services, _arg_names, _aidl_reply) } fn r#ReverseStringList(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result> { let _aidl_data = self.build_parcel_ReverseStringList(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseStringList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseStringList(_arg_input, _arg_repeated, _aidl_reply) } fn r#RepeatParcelFileDescriptor(&self, _arg_read: &binder::ParcelFileDescriptor) -> binder::Result { let _aidl_data = self.build_parcel_RepeatParcelFileDescriptor(_arg_read)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatParcelFileDescriptor, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatParcelFileDescriptor(_arg_read, _aidl_reply) } fn r#ReverseParcelFileDescriptorArray(&self, _arg_input: &[binder::ParcelFileDescriptor], _arg_repeated: &mut Vec>) -> binder::Result> { let _aidl_data = self.build_parcel_ReverseParcelFileDescriptorArray(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseParcelFileDescriptorArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseParcelFileDescriptorArray(_arg_input, _arg_repeated, _aidl_reply) } fn r#ThrowServiceException(&self, _arg_code: i32) -> binder::Result<()> { let _aidl_data = self.build_parcel_ThrowServiceException(_arg_code)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ThrowServiceException, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ThrowServiceException(_arg_code, _aidl_reply) } fn r#RepeatNullableIntArray(&self, _arg_input: Option<&[i32]>) -> binder::Result>> { let _aidl_data = self.build_parcel_RepeatNullableIntArray(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatNullableIntArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatNullableIntArray(_arg_input, _aidl_reply) } fn r#RepeatNullableByteEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum]>) -> binder::Result>> { let _aidl_data = self.build_parcel_RepeatNullableByteEnumArray(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatNullableByteEnumArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatNullableByteEnumArray(_arg_input, _aidl_reply) } fn r#RepeatNullableIntEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum]>) -> binder::Result>> { let _aidl_data = self.build_parcel_RepeatNullableIntEnumArray(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatNullableIntEnumArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatNullableIntEnumArray(_arg_input, _aidl_reply) } fn r#RepeatNullableLongEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum]>) -> binder::Result>> { let _aidl_data = self.build_parcel_RepeatNullableLongEnumArray(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatNullableLongEnumArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatNullableLongEnumArray(_arg_input, _aidl_reply) } fn r#RepeatNullableString(&self, _arg_input: Option<&str>) -> binder::Result> { let _aidl_data = self.build_parcel_RepeatNullableString(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatNullableString, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatNullableString(_arg_input, _aidl_reply) } fn r#RepeatNullableStringList(&self, _arg_input: Option<&[Option]>) -> binder::Result>>> { let _aidl_data = self.build_parcel_RepeatNullableStringList(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatNullableStringList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatNullableStringList(_arg_input, _aidl_reply) } fn r#RepeatNullableParcelable(&self, _arg_input: Option<&crate::mangled::_7_android_4_aidl_5_tests_12_ITestService_5_Empty>) -> binder::Result> { let _aidl_data = self.build_parcel_RepeatNullableParcelable(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatNullableParcelable, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatNullableParcelable(_arg_input, _aidl_reply) } fn r#RepeatNullableParcelableArray(&self, _arg_input: Option<&[Option]>) -> binder::Result>>> { let _aidl_data = self.build_parcel_RepeatNullableParcelableArray(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatNullableParcelableArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatNullableParcelableArray(_arg_input, _aidl_reply) } fn r#RepeatNullableParcelableList(&self, _arg_input: Option<&[Option]>) -> binder::Result>>> { let _aidl_data = self.build_parcel_RepeatNullableParcelableList(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatNullableParcelableList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatNullableParcelableList(_arg_input, _aidl_reply) } fn r#TakesAnIBinder(&self, _arg_input: &binder::SpIBinder) -> binder::Result<()> { let _aidl_data = self.build_parcel_TakesAnIBinder(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#TakesAnIBinder, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_TakesAnIBinder(_arg_input, _aidl_reply) } fn r#TakesANullableIBinder(&self, _arg_input: Option<&binder::SpIBinder>) -> binder::Result<()> { let _aidl_data = self.build_parcel_TakesANullableIBinder(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#TakesANullableIBinder, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_TakesANullableIBinder(_arg_input, _aidl_reply) } fn r#TakesAnIBinderList(&self, _arg_input: &[binder::SpIBinder]) -> binder::Result<()> { let _aidl_data = self.build_parcel_TakesAnIBinderList(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#TakesAnIBinderList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_TakesAnIBinderList(_arg_input, _aidl_reply) } fn r#TakesANullableIBinderList(&self, _arg_input: Option<&[Option]>) -> binder::Result<()> { let _aidl_data = self.build_parcel_TakesANullableIBinderList(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#TakesANullableIBinderList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_TakesANullableIBinderList(_arg_input, _aidl_reply) } fn r#RepeatUtf8CppString(&self, _arg_token: &str) -> binder::Result { let _aidl_data = self.build_parcel_RepeatUtf8CppString(_arg_token)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatUtf8CppString, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatUtf8CppString(_arg_token, _aidl_reply) } fn r#RepeatNullableUtf8CppString(&self, _arg_token: Option<&str>) -> binder::Result> { let _aidl_data = self.build_parcel_RepeatNullableUtf8CppString(_arg_token)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatNullableUtf8CppString, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatNullableUtf8CppString(_arg_token, _aidl_reply) } fn r#ReverseUtf8CppString(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result> { let _aidl_data = self.build_parcel_ReverseUtf8CppString(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseUtf8CppString, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseUtf8CppString(_arg_input, _arg_repeated, _aidl_reply) } fn r#ReverseNullableUtf8CppString(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>> { let _aidl_data = self.build_parcel_ReverseNullableUtf8CppString(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseNullableUtf8CppString, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseNullableUtf8CppString(_arg_input, _arg_repeated, _aidl_reply) } fn r#ReverseUtf8CppStringList(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>> { let _aidl_data = self.build_parcel_ReverseUtf8CppStringList(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseUtf8CppStringList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseUtf8CppStringList(_arg_input, _arg_repeated, _aidl_reply) } fn r#GetCallback(&self, _arg_return_null: bool) -> binder::Result>> { let _aidl_data = self.build_parcel_GetCallback(_arg_return_null)?; let _aidl_reply = self.binder.submit_transact(transactions::r#GetCallback, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_GetCallback(_arg_return_null, _aidl_reply) } fn r#FillOutStructuredParcelable(&self, _arg_parcel: &mut crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable) -> binder::Result<()> { let _aidl_data = self.build_parcel_FillOutStructuredParcelable(_arg_parcel)?; let _aidl_reply = self.binder.submit_transact(transactions::r#FillOutStructuredParcelable, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_FillOutStructuredParcelable(_arg_parcel, _aidl_reply) } fn r#RepeatExtendableParcelable(&self, _arg_ep: &crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable, _arg_ep2: &mut crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable) -> binder::Result<()> { let _aidl_data = self.build_parcel_RepeatExtendableParcelable(_arg_ep, _arg_ep2)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatExtendableParcelable, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatExtendableParcelable(_arg_ep, _arg_ep2, _aidl_reply) } fn r#ReverseList(&self, _arg_list: &crate::mangled::_7_android_4_aidl_5_tests_13_RecursiveList) -> binder::Result { let _aidl_data = self.build_parcel_ReverseList(_arg_list)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseList(_arg_list, _aidl_reply) } fn r#ReverseIBinderArray(&self, _arg_input: &[binder::SpIBinder], _arg_repeated: &mut Vec>) -> binder::Result> { let _aidl_data = self.build_parcel_ReverseIBinderArray(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseIBinderArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseIBinderArray(_arg_input, _arg_repeated, _aidl_reply) } fn r#ReverseNullableIBinderArray(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>> { let _aidl_data = self.build_parcel_ReverseNullableIBinderArray(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseNullableIBinderArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseNullableIBinderArray(_arg_input, _arg_repeated, _aidl_reply) } fn r#RepeatSimpleParcelable(&self, _arg_input: &simple_parcelable::SimpleParcelable, _arg_repeat: &mut simple_parcelable::SimpleParcelable) -> binder::Result { let _aidl_data = self.build_parcel_RepeatSimpleParcelable(_arg_input, _arg_repeat)?; let _aidl_reply = self.binder.submit_transact(transactions::r#RepeatSimpleParcelable, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_RepeatSimpleParcelable(_arg_input, _arg_repeat, _aidl_reply) } fn r#ReverseSimpleParcelables(&self, _arg_input: &[simple_parcelable::SimpleParcelable], _arg_repeated: &mut Vec) -> binder::Result> { let _aidl_data = self.build_parcel_ReverseSimpleParcelables(_arg_input, _arg_repeated)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ReverseSimpleParcelables, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ReverseSimpleParcelables(_arg_input, _arg_repeated, _aidl_reply) } fn r#GetOldNameInterface(&self) -> binder::Result> { let _aidl_data = self.build_parcel_GetOldNameInterface()?; let _aidl_reply = self.binder.submit_transact(transactions::r#GetOldNameInterface, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_GetOldNameInterface(_aidl_reply) } fn r#GetNewNameInterface(&self) -> binder::Result> { let _aidl_data = self.build_parcel_GetNewNameInterface()?; let _aidl_reply = self.binder.submit_transact(transactions::r#GetNewNameInterface, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_GetNewNameInterface(_aidl_reply) } fn r#GetUnionTags(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_5_Union]) -> binder::Result> { let _aidl_data = self.build_parcel_GetUnionTags(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#GetUnionTags, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_GetUnionTags(_arg_input, _aidl_reply) } fn r#GetCppJavaTests(&self) -> binder::Result> { let _aidl_data = self.build_parcel_GetCppJavaTests()?; let _aidl_reply = self.binder.submit_transact(transactions::r#GetCppJavaTests, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_GetCppJavaTests(_aidl_reply) } fn r#getBackendType(&self) -> binder::Result { let _aidl_data = self.build_parcel_getBackendType()?; let _aidl_reply = self.binder.submit_transact(transactions::r#getBackendType, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_getBackendType(_aidl_reply) } fn r#GetCircular(&self, _arg_cp: &mut crate::mangled::_7_android_4_aidl_5_tests_18_CircularParcelable) -> binder::Result> { let _aidl_data = self.build_parcel_GetCircular(_arg_cp)?; let _aidl_reply = self.binder.submit_transact(transactions::r#GetCircular, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_GetCircular(_arg_cp, _aidl_reply) } } impl ITestServiceAsync

for BpTestService { fn r#UnimplementedMethod<'a>(&'a self, _arg_arg: i32) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_UnimplementedMethod(_arg_arg) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#UnimplementedMethod, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_UnimplementedMethod(_arg_arg, _aidl_reply) } ) } fn r#Deprecated<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_Deprecated() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#Deprecated, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_Deprecated(_aidl_reply) } ) } fn r#TestOneway(&self) -> std::future::Ready> { let _aidl_data = match self.build_parcel_TestOneway() { Ok(_aidl_data) => _aidl_data, Err(err) => return std::future::ready(Err(err)), }; let _aidl_reply = self.binder.submit_transact(transactions::r#TestOneway, _aidl_data, binder::binder_impl::FLAG_ONEWAY | binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL); std::future::ready(self.read_response_TestOneway(_aidl_reply)) } fn r#RepeatBoolean<'a>(&'a self, _arg_token: bool) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_RepeatBoolean(_arg_token) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatBoolean, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatBoolean(_arg_token, _aidl_reply) } ) } fn r#RepeatByte<'a>(&'a self, _arg_token: i8) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_RepeatByte(_arg_token) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatByte, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatByte(_arg_token, _aidl_reply) } ) } fn r#RepeatChar<'a>(&'a self, _arg_token: u16) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_RepeatChar(_arg_token) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatChar, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatChar(_arg_token, _aidl_reply) } ) } fn r#RepeatInt<'a>(&'a self, _arg_token: i32) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_RepeatInt(_arg_token) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatInt, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatInt(_arg_token, _aidl_reply) } ) } fn r#RepeatLong<'a>(&'a self, _arg_token: i64) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_RepeatLong(_arg_token) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatLong, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatLong(_arg_token, _aidl_reply) } ) } fn r#RepeatFloat<'a>(&'a self, _arg_token: f32) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_RepeatFloat(_arg_token) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatFloat, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatFloat(_arg_token, _aidl_reply) } ) } fn r#RepeatDouble<'a>(&'a self, _arg_token: f64) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_RepeatDouble(_arg_token) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatDouble, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatDouble(_arg_token, _aidl_reply) } ) } fn r#RepeatString<'a>(&'a self, _arg_token: &'a str) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_RepeatString(_arg_token) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatString, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatString(_arg_token, _aidl_reply) } ) } fn r#RepeatByteEnum<'a>(&'a self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_RepeatByteEnum(_arg_token) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatByteEnum, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatByteEnum(_arg_token, _aidl_reply) } ) } fn r#RepeatIntEnum<'a>(&'a self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_RepeatIntEnum(_arg_token) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatIntEnum, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatIntEnum(_arg_token, _aidl_reply) } ) } fn r#RepeatLongEnum<'a>(&'a self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_RepeatLongEnum(_arg_token) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatLongEnum, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatLongEnum(_arg_token, _aidl_reply) } ) } fn r#ReverseBoolean<'a>(&'a self, _arg_input: &'a [bool], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_ReverseBoolean(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseBoolean, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseBoolean(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#ReverseByte<'a>(&'a self, _arg_input: &'a [u8], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_ReverseByte(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseByte, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseByte(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#ReverseChar<'a>(&'a self, _arg_input: &'a [u16], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_ReverseChar(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseChar, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseChar(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#ReverseInt<'a>(&'a self, _arg_input: &'a [i32], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_ReverseInt(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseInt, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseInt(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#ReverseLong<'a>(&'a self, _arg_input: &'a [i64], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_ReverseLong(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseLong, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseLong(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#ReverseFloat<'a>(&'a self, _arg_input: &'a [f32], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_ReverseFloat(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseFloat, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseFloat(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#ReverseDouble<'a>(&'a self, _arg_input: &'a [f64], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_ReverseDouble(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseDouble, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseDouble(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#ReverseString<'a>(&'a self, _arg_input: &'a [String], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_ReverseString(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseString, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseString(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#ReverseByteEnum<'a>(&'a self, _arg_input: &'a [crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_ReverseByteEnum(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseByteEnum, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseByteEnum(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#ReverseIntEnum<'a>(&'a self, _arg_input: &'a [crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_ReverseIntEnum(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseIntEnum, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseIntEnum(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#ReverseLongEnum<'a>(&'a self, _arg_input: &'a [crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_ReverseLongEnum(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseLongEnum, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseLongEnum(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#GetOtherTestService<'a>(&'a self, _arg_name: &'a str) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_GetOtherTestService(_arg_name) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#GetOtherTestService, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_GetOtherTestService(_arg_name, _aidl_reply) } ) } fn r#SetOtherTestService<'a>(&'a self, _arg_name: &'a str, _arg_service: &'a binder::Strong) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_SetOtherTestService(_arg_name, _arg_service) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#SetOtherTestService, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_SetOtherTestService(_arg_name, _arg_service, _aidl_reply) } ) } fn r#VerifyName<'a>(&'a self, _arg_service: &'a binder::Strong, _arg_name: &'a str) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_VerifyName(_arg_service, _arg_name) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#VerifyName, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_VerifyName(_arg_service, _arg_name, _aidl_reply) } ) } fn r#GetInterfaceArray<'a>(&'a self, _arg_names: &'a [String]) -> binder::BoxFuture<'a, binder::Result>>> { let _aidl_data = match self.build_parcel_GetInterfaceArray(_arg_names) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#GetInterfaceArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_GetInterfaceArray(_arg_names, _aidl_reply) } ) } fn r#VerifyNamesWithInterfaceArray<'a>(&'a self, _arg_services: &'a [binder::Strong], _arg_names: &'a [String]) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_VerifyNamesWithInterfaceArray(_arg_services, _arg_names) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#VerifyNamesWithInterfaceArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_VerifyNamesWithInterfaceArray(_arg_services, _arg_names, _aidl_reply) } ) } fn r#GetNullableInterfaceArray<'a>(&'a self, _arg_names: Option<&'a [Option]>) -> binder::BoxFuture<'a, binder::Result>>>>> { let _aidl_data = match self.build_parcel_GetNullableInterfaceArray(_arg_names) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#GetNullableInterfaceArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_GetNullableInterfaceArray(_arg_names, _aidl_reply) } ) } fn r#VerifyNamesWithNullableInterfaceArray<'a>(&'a self, _arg_services: Option<&'a [Option>]>, _arg_names: Option<&'a [Option]>) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_VerifyNamesWithNullableInterfaceArray(_arg_services, _arg_names) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#VerifyNamesWithNullableInterfaceArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_VerifyNamesWithNullableInterfaceArray(_arg_services, _arg_names, _aidl_reply) } ) } fn r#GetInterfaceList<'a>(&'a self, _arg_names: Option<&'a [Option]>) -> binder::BoxFuture<'a, binder::Result>>>>> { let _aidl_data = match self.build_parcel_GetInterfaceList(_arg_names) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#GetInterfaceList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_GetInterfaceList(_arg_names, _aidl_reply) } ) } fn r#VerifyNamesWithInterfaceList<'a>(&'a self, _arg_services: Option<&'a [Option>]>, _arg_names: Option<&'a [Option]>) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_VerifyNamesWithInterfaceList(_arg_services, _arg_names) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#VerifyNamesWithInterfaceList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_VerifyNamesWithInterfaceList(_arg_services, _arg_names, _aidl_reply) } ) } fn r#ReverseStringList<'a>(&'a self, _arg_input: &'a [String], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_ReverseStringList(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseStringList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseStringList(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#RepeatParcelFileDescriptor<'a>(&'a self, _arg_read: &'a binder::ParcelFileDescriptor) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_RepeatParcelFileDescriptor(_arg_read) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatParcelFileDescriptor, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatParcelFileDescriptor(_arg_read, _aidl_reply) } ) } fn r#ReverseParcelFileDescriptorArray<'a>(&'a self, _arg_input: &'a [binder::ParcelFileDescriptor], _arg_repeated: &'a mut Vec>) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_ReverseParcelFileDescriptorArray(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseParcelFileDescriptorArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseParcelFileDescriptorArray(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#ThrowServiceException<'a>(&'a self, _arg_code: i32) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_ThrowServiceException(_arg_code) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ThrowServiceException, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ThrowServiceException(_arg_code, _aidl_reply) } ) } fn r#RepeatNullableIntArray<'a>(&'a self, _arg_input: Option<&'a [i32]>) -> binder::BoxFuture<'a, binder::Result>>> { let _aidl_data = match self.build_parcel_RepeatNullableIntArray(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatNullableIntArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatNullableIntArray(_arg_input, _aidl_reply) } ) } fn r#RepeatNullableByteEnumArray<'a>(&'a self, _arg_input: Option<&'a [crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum]>) -> binder::BoxFuture<'a, binder::Result>>> { let _aidl_data = match self.build_parcel_RepeatNullableByteEnumArray(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatNullableByteEnumArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatNullableByteEnumArray(_arg_input, _aidl_reply) } ) } fn r#RepeatNullableIntEnumArray<'a>(&'a self, _arg_input: Option<&'a [crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum]>) -> binder::BoxFuture<'a, binder::Result>>> { let _aidl_data = match self.build_parcel_RepeatNullableIntEnumArray(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatNullableIntEnumArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatNullableIntEnumArray(_arg_input, _aidl_reply) } ) } fn r#RepeatNullableLongEnumArray<'a>(&'a self, _arg_input: Option<&'a [crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum]>) -> binder::BoxFuture<'a, binder::Result>>> { let _aidl_data = match self.build_parcel_RepeatNullableLongEnumArray(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatNullableLongEnumArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatNullableLongEnumArray(_arg_input, _aidl_reply) } ) } fn r#RepeatNullableString<'a>(&'a self, _arg_input: Option<&'a str>) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_RepeatNullableString(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatNullableString, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatNullableString(_arg_input, _aidl_reply) } ) } fn r#RepeatNullableStringList<'a>(&'a self, _arg_input: Option<&'a [Option]>) -> binder::BoxFuture<'a, binder::Result>>>> { let _aidl_data = match self.build_parcel_RepeatNullableStringList(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatNullableStringList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatNullableStringList(_arg_input, _aidl_reply) } ) } fn r#RepeatNullableParcelable<'a>(&'a self, _arg_input: Option<&'a crate::mangled::_7_android_4_aidl_5_tests_12_ITestService_5_Empty>) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_RepeatNullableParcelable(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatNullableParcelable, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatNullableParcelable(_arg_input, _aidl_reply) } ) } fn r#RepeatNullableParcelableArray<'a>(&'a self, _arg_input: Option<&'a [Option]>) -> binder::BoxFuture<'a, binder::Result>>>> { let _aidl_data = match self.build_parcel_RepeatNullableParcelableArray(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatNullableParcelableArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatNullableParcelableArray(_arg_input, _aidl_reply) } ) } fn r#RepeatNullableParcelableList<'a>(&'a self, _arg_input: Option<&'a [Option]>) -> binder::BoxFuture<'a, binder::Result>>>> { let _aidl_data = match self.build_parcel_RepeatNullableParcelableList(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatNullableParcelableList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatNullableParcelableList(_arg_input, _aidl_reply) } ) } fn r#TakesAnIBinder<'a>(&'a self, _arg_input: &'a binder::SpIBinder) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_TakesAnIBinder(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#TakesAnIBinder, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_TakesAnIBinder(_arg_input, _aidl_reply) } ) } fn r#TakesANullableIBinder<'a>(&'a self, _arg_input: Option<&'a binder::SpIBinder>) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_TakesANullableIBinder(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#TakesANullableIBinder, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_TakesANullableIBinder(_arg_input, _aidl_reply) } ) } fn r#TakesAnIBinderList<'a>(&'a self, _arg_input: &'a [binder::SpIBinder]) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_TakesAnIBinderList(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#TakesAnIBinderList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_TakesAnIBinderList(_arg_input, _aidl_reply) } ) } fn r#TakesANullableIBinderList<'a>(&'a self, _arg_input: Option<&'a [Option]>) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_TakesANullableIBinderList(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#TakesANullableIBinderList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_TakesANullableIBinderList(_arg_input, _aidl_reply) } ) } fn r#RepeatUtf8CppString<'a>(&'a self, _arg_token: &'a str) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_RepeatUtf8CppString(_arg_token) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatUtf8CppString, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatUtf8CppString(_arg_token, _aidl_reply) } ) } fn r#RepeatNullableUtf8CppString<'a>(&'a self, _arg_token: Option<&'a str>) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_RepeatNullableUtf8CppString(_arg_token) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatNullableUtf8CppString, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatNullableUtf8CppString(_arg_token, _aidl_reply) } ) } fn r#ReverseUtf8CppString<'a>(&'a self, _arg_input: &'a [String], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_ReverseUtf8CppString(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseUtf8CppString, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseUtf8CppString(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#ReverseNullableUtf8CppString<'a>(&'a self, _arg_input: Option<&'a [Option]>, _arg_repeated: &'a mut Option>>) -> binder::BoxFuture<'a, binder::Result>>>> { let _aidl_data = match self.build_parcel_ReverseNullableUtf8CppString(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseNullableUtf8CppString, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseNullableUtf8CppString(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#ReverseUtf8CppStringList<'a>(&'a self, _arg_input: Option<&'a [Option]>, _arg_repeated: &'a mut Option>>) -> binder::BoxFuture<'a, binder::Result>>>> { let _aidl_data = match self.build_parcel_ReverseUtf8CppStringList(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseUtf8CppStringList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseUtf8CppStringList(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#GetCallback<'a>(&'a self, _arg_return_null: bool) -> binder::BoxFuture<'a, binder::Result>>> { let _aidl_data = match self.build_parcel_GetCallback(_arg_return_null) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#GetCallback, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_GetCallback(_arg_return_null, _aidl_reply) } ) } fn r#FillOutStructuredParcelable<'a>(&'a self, _arg_parcel: &'a mut crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_FillOutStructuredParcelable(_arg_parcel) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#FillOutStructuredParcelable, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_FillOutStructuredParcelable(_arg_parcel, _aidl_reply) } ) } fn r#RepeatExtendableParcelable<'a>(&'a self, _arg_ep: &'a crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable, _arg_ep2: &'a mut crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_RepeatExtendableParcelable(_arg_ep, _arg_ep2) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatExtendableParcelable, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatExtendableParcelable(_arg_ep, _arg_ep2, _aidl_reply) } ) } fn r#ReverseList<'a>(&'a self, _arg_list: &'a crate::mangled::_7_android_4_aidl_5_tests_13_RecursiveList) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_ReverseList(_arg_list) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseList, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseList(_arg_list, _aidl_reply) } ) } fn r#ReverseIBinderArray<'a>(&'a self, _arg_input: &'a [binder::SpIBinder], _arg_repeated: &'a mut Vec>) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_ReverseIBinderArray(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseIBinderArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseIBinderArray(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#ReverseNullableIBinderArray<'a>(&'a self, _arg_input: Option<&'a [Option]>, _arg_repeated: &'a mut Option>>) -> binder::BoxFuture<'a, binder::Result>>>> { let _aidl_data = match self.build_parcel_ReverseNullableIBinderArray(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseNullableIBinderArray, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseNullableIBinderArray(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#RepeatSimpleParcelable<'a>(&'a self, _arg_input: &'a simple_parcelable::SimpleParcelable, _arg_repeat: &'a mut simple_parcelable::SimpleParcelable) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_RepeatSimpleParcelable(_arg_input, _arg_repeat) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#RepeatSimpleParcelable, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_RepeatSimpleParcelable(_arg_input, _arg_repeat, _aidl_reply) } ) } fn r#ReverseSimpleParcelables<'a>(&'a self, _arg_input: &'a [simple_parcelable::SimpleParcelable], _arg_repeated: &'a mut Vec) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_ReverseSimpleParcelables(_arg_input, _arg_repeated) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ReverseSimpleParcelables, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ReverseSimpleParcelables(_arg_input, _arg_repeated, _aidl_reply) } ) } fn r#GetOldNameInterface<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_GetOldNameInterface() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#GetOldNameInterface, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_GetOldNameInterface(_aidl_reply) } ) } fn r#GetNewNameInterface<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_GetNewNameInterface() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#GetNewNameInterface, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_GetNewNameInterface(_aidl_reply) } ) } fn r#GetUnionTags<'a>(&'a self, _arg_input: &'a [crate::mangled::_7_android_4_aidl_5_tests_5_Union]) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_GetUnionTags(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#GetUnionTags, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_GetUnionTags(_arg_input, _aidl_reply) } ) } fn r#GetCppJavaTests<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_GetCppJavaTests() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#GetCppJavaTests, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_GetCppJavaTests(_aidl_reply) } ) } fn r#getBackendType<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_getBackendType() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#getBackendType, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_getBackendType(_aidl_reply) } ) } fn r#GetCircular<'a>(&'a self, _arg_cp: &'a mut crate::mangled::_7_android_4_aidl_5_tests_18_CircularParcelable) -> binder::BoxFuture<'a, binder::Result>> { let _aidl_data = match self.build_parcel_GetCircular(_arg_cp) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#GetCircular, _aidl_data, binder::binder_impl::FLAG_CLEAR_BUF | binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_GetCircular(_arg_cp, _aidl_reply) } ) } } impl ITestService for binder::binder_impl::Binder { fn r#UnimplementedMethod(&self, _arg_arg: i32) -> binder::Result { self.0.r#UnimplementedMethod(_arg_arg) } fn r#Deprecated(&self) -> binder::Result<()> { self.0.r#Deprecated() } fn r#TestOneway(&self) -> binder::Result<()> { self.0.r#TestOneway() } fn r#RepeatBoolean(&self, _arg_token: bool) -> binder::Result { self.0.r#RepeatBoolean(_arg_token) } fn r#RepeatByte(&self, _arg_token: i8) -> binder::Result { self.0.r#RepeatByte(_arg_token) } fn r#RepeatChar(&self, _arg_token: u16) -> binder::Result { self.0.r#RepeatChar(_arg_token) } fn r#RepeatInt(&self, _arg_token: i32) -> binder::Result { self.0.r#RepeatInt(_arg_token) } fn r#RepeatLong(&self, _arg_token: i64) -> binder::Result { self.0.r#RepeatLong(_arg_token) } fn r#RepeatFloat(&self, _arg_token: f32) -> binder::Result { self.0.r#RepeatFloat(_arg_token) } fn r#RepeatDouble(&self, _arg_token: f64) -> binder::Result { self.0.r#RepeatDouble(_arg_token) } fn r#RepeatString(&self, _arg_token: &str) -> binder::Result { self.0.r#RepeatString(_arg_token) } fn r#RepeatByteEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum) -> binder::Result { self.0.r#RepeatByteEnum(_arg_token) } fn r#RepeatIntEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum) -> binder::Result { self.0.r#RepeatIntEnum(_arg_token) } fn r#RepeatLongEnum(&self, _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum) -> binder::Result { self.0.r#RepeatLongEnum(_arg_token) } fn r#ReverseBoolean(&self, _arg_input: &[bool], _arg_repeated: &mut Vec) -> binder::Result> { self.0.r#ReverseBoolean(_arg_input, _arg_repeated) } fn r#ReverseByte(&self, _arg_input: &[u8], _arg_repeated: &mut Vec) -> binder::Result> { self.0.r#ReverseByte(_arg_input, _arg_repeated) } fn r#ReverseChar(&self, _arg_input: &[u16], _arg_repeated: &mut Vec) -> binder::Result> { self.0.r#ReverseChar(_arg_input, _arg_repeated) } fn r#ReverseInt(&self, _arg_input: &[i32], _arg_repeated: &mut Vec) -> binder::Result> { self.0.r#ReverseInt(_arg_input, _arg_repeated) } fn r#ReverseLong(&self, _arg_input: &[i64], _arg_repeated: &mut Vec) -> binder::Result> { self.0.r#ReverseLong(_arg_input, _arg_repeated) } fn r#ReverseFloat(&self, _arg_input: &[f32], _arg_repeated: &mut Vec) -> binder::Result> { self.0.r#ReverseFloat(_arg_input, _arg_repeated) } fn r#ReverseDouble(&self, _arg_input: &[f64], _arg_repeated: &mut Vec) -> binder::Result> { self.0.r#ReverseDouble(_arg_input, _arg_repeated) } fn r#ReverseString(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result> { self.0.r#ReverseString(_arg_input, _arg_repeated) } fn r#ReverseByteEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum], _arg_repeated: &mut Vec) -> binder::Result> { self.0.r#ReverseByteEnum(_arg_input, _arg_repeated) } fn r#ReverseIntEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum], _arg_repeated: &mut Vec) -> binder::Result> { self.0.r#ReverseIntEnum(_arg_input, _arg_repeated) } fn r#ReverseLongEnum(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum], _arg_repeated: &mut Vec) -> binder::Result> { self.0.r#ReverseLongEnum(_arg_input, _arg_repeated) } fn r#GetOtherTestService(&self, _arg_name: &str) -> binder::Result> { self.0.r#GetOtherTestService(_arg_name) } fn r#SetOtherTestService(&self, _arg_name: &str, _arg_service: &binder::Strong) -> binder::Result { self.0.r#SetOtherTestService(_arg_name, _arg_service) } fn r#VerifyName(&self, _arg_service: &binder::Strong, _arg_name: &str) -> binder::Result { self.0.r#VerifyName(_arg_service, _arg_name) } fn r#GetInterfaceArray(&self, _arg_names: &[String]) -> binder::Result>> { self.0.r#GetInterfaceArray(_arg_names) } fn r#VerifyNamesWithInterfaceArray(&self, _arg_services: &[binder::Strong], _arg_names: &[String]) -> binder::Result { self.0.r#VerifyNamesWithInterfaceArray(_arg_services, _arg_names) } fn r#GetNullableInterfaceArray(&self, _arg_names: Option<&[Option]>) -> binder::Result>>>> { self.0.r#GetNullableInterfaceArray(_arg_names) } fn r#VerifyNamesWithNullableInterfaceArray(&self, _arg_services: Option<&[Option>]>, _arg_names: Option<&[Option]>) -> binder::Result { self.0.r#VerifyNamesWithNullableInterfaceArray(_arg_services, _arg_names) } fn r#GetInterfaceList(&self, _arg_names: Option<&[Option]>) -> binder::Result>>>> { self.0.r#GetInterfaceList(_arg_names) } fn r#VerifyNamesWithInterfaceList(&self, _arg_services: Option<&[Option>]>, _arg_names: Option<&[Option]>) -> binder::Result { self.0.r#VerifyNamesWithInterfaceList(_arg_services, _arg_names) } fn r#ReverseStringList(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result> { self.0.r#ReverseStringList(_arg_input, _arg_repeated) } fn r#RepeatParcelFileDescriptor(&self, _arg_read: &binder::ParcelFileDescriptor) -> binder::Result { self.0.r#RepeatParcelFileDescriptor(_arg_read) } fn r#ReverseParcelFileDescriptorArray(&self, _arg_input: &[binder::ParcelFileDescriptor], _arg_repeated: &mut Vec>) -> binder::Result> { self.0.r#ReverseParcelFileDescriptorArray(_arg_input, _arg_repeated) } fn r#ThrowServiceException(&self, _arg_code: i32) -> binder::Result<()> { self.0.r#ThrowServiceException(_arg_code) } fn r#RepeatNullableIntArray(&self, _arg_input: Option<&[i32]>) -> binder::Result>> { self.0.r#RepeatNullableIntArray(_arg_input) } fn r#RepeatNullableByteEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum]>) -> binder::Result>> { self.0.r#RepeatNullableByteEnumArray(_arg_input) } fn r#RepeatNullableIntEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum]>) -> binder::Result>> { self.0.r#RepeatNullableIntEnumArray(_arg_input) } fn r#RepeatNullableLongEnumArray(&self, _arg_input: Option<&[crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum]>) -> binder::Result>> { self.0.r#RepeatNullableLongEnumArray(_arg_input) } fn r#RepeatNullableString(&self, _arg_input: Option<&str>) -> binder::Result> { self.0.r#RepeatNullableString(_arg_input) } fn r#RepeatNullableStringList(&self, _arg_input: Option<&[Option]>) -> binder::Result>>> { self.0.r#RepeatNullableStringList(_arg_input) } fn r#RepeatNullableParcelable(&self, _arg_input: Option<&crate::mangled::_7_android_4_aidl_5_tests_12_ITestService_5_Empty>) -> binder::Result> { self.0.r#RepeatNullableParcelable(_arg_input) } fn r#RepeatNullableParcelableArray(&self, _arg_input: Option<&[Option]>) -> binder::Result>>> { self.0.r#RepeatNullableParcelableArray(_arg_input) } fn r#RepeatNullableParcelableList(&self, _arg_input: Option<&[Option]>) -> binder::Result>>> { self.0.r#RepeatNullableParcelableList(_arg_input) } fn r#TakesAnIBinder(&self, _arg_input: &binder::SpIBinder) -> binder::Result<()> { self.0.r#TakesAnIBinder(_arg_input) } fn r#TakesANullableIBinder(&self, _arg_input: Option<&binder::SpIBinder>) -> binder::Result<()> { self.0.r#TakesANullableIBinder(_arg_input) } fn r#TakesAnIBinderList(&self, _arg_input: &[binder::SpIBinder]) -> binder::Result<()> { self.0.r#TakesAnIBinderList(_arg_input) } fn r#TakesANullableIBinderList(&self, _arg_input: Option<&[Option]>) -> binder::Result<()> { self.0.r#TakesANullableIBinderList(_arg_input) } fn r#RepeatUtf8CppString(&self, _arg_token: &str) -> binder::Result { self.0.r#RepeatUtf8CppString(_arg_token) } fn r#RepeatNullableUtf8CppString(&self, _arg_token: Option<&str>) -> binder::Result> { self.0.r#RepeatNullableUtf8CppString(_arg_token) } fn r#ReverseUtf8CppString(&self, _arg_input: &[String], _arg_repeated: &mut Vec) -> binder::Result> { self.0.r#ReverseUtf8CppString(_arg_input, _arg_repeated) } fn r#ReverseNullableUtf8CppString(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>> { self.0.r#ReverseNullableUtf8CppString(_arg_input, _arg_repeated) } fn r#ReverseUtf8CppStringList(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>> { self.0.r#ReverseUtf8CppStringList(_arg_input, _arg_repeated) } fn r#GetCallback(&self, _arg_return_null: bool) -> binder::Result>> { self.0.r#GetCallback(_arg_return_null) } fn r#FillOutStructuredParcelable(&self, _arg_parcel: &mut crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable) -> binder::Result<()> { self.0.r#FillOutStructuredParcelable(_arg_parcel) } fn r#RepeatExtendableParcelable(&self, _arg_ep: &crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable, _arg_ep2: &mut crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable) -> binder::Result<()> { self.0.r#RepeatExtendableParcelable(_arg_ep, _arg_ep2) } fn r#ReverseList(&self, _arg_list: &crate::mangled::_7_android_4_aidl_5_tests_13_RecursiveList) -> binder::Result { self.0.r#ReverseList(_arg_list) } fn r#ReverseIBinderArray(&self, _arg_input: &[binder::SpIBinder], _arg_repeated: &mut Vec>) -> binder::Result> { self.0.r#ReverseIBinderArray(_arg_input, _arg_repeated) } fn r#ReverseNullableIBinderArray(&self, _arg_input: Option<&[Option]>, _arg_repeated: &mut Option>>) -> binder::Result>>> { self.0.r#ReverseNullableIBinderArray(_arg_input, _arg_repeated) } fn r#RepeatSimpleParcelable(&self, _arg_input: &simple_parcelable::SimpleParcelable, _arg_repeat: &mut simple_parcelable::SimpleParcelable) -> binder::Result { self.0.r#RepeatSimpleParcelable(_arg_input, _arg_repeat) } fn r#ReverseSimpleParcelables(&self, _arg_input: &[simple_parcelable::SimpleParcelable], _arg_repeated: &mut Vec) -> binder::Result> { self.0.r#ReverseSimpleParcelables(_arg_input, _arg_repeated) } fn r#GetOldNameInterface(&self) -> binder::Result> { self.0.r#GetOldNameInterface() } fn r#GetNewNameInterface(&self) -> binder::Result> { self.0.r#GetNewNameInterface() } fn r#GetUnionTags(&self, _arg_input: &[crate::mangled::_7_android_4_aidl_5_tests_5_Union]) -> binder::Result> { self.0.r#GetUnionTags(_arg_input) } fn r#GetCppJavaTests(&self) -> binder::Result> { self.0.r#GetCppJavaTests() } fn r#getBackendType(&self) -> binder::Result { self.0.r#getBackendType() } fn r#GetCircular(&self, _arg_cp: &mut crate::mangled::_7_android_4_aidl_5_tests_18_CircularParcelable) -> binder::Result> { self.0.r#GetCircular(_arg_cp) } } fn on_transact(_aidl_service: &dyn ITestService, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#UnimplementedMethod => { let _arg_arg: i32 = _aidl_data.read()?; let _aidl_return = _aidl_service.r#UnimplementedMethod(_arg_arg); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#Deprecated => { let _aidl_return = _aidl_service.r#Deprecated(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#TestOneway => { let _aidl_return = _aidl_service.r#TestOneway(); Ok(()) } transactions::r#RepeatBoolean => { let _arg_token: bool = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatBoolean(_arg_token); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatByte => { let _arg_token: i8 = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatByte(_arg_token); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatChar => { let _arg_token: u16 = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatChar(_arg_token); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatInt => { let _arg_token: i32 = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatInt(_arg_token); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatLong => { let _arg_token: i64 = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatLong(_arg_token); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatFloat => { let _arg_token: f32 = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatFloat(_arg_token); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatDouble => { let _arg_token: f64 = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatDouble(_arg_token); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatString => { let _arg_token: String = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatString(&_arg_token); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatByteEnum => { let _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatByteEnum(_arg_token); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatIntEnum => { let _arg_token: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatIntEnum(_arg_token); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatLongEnum => { let _arg_token: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatLongEnum(_arg_token); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseBoolean => { let _arg_input: Vec = _aidl_data.read()?; let mut _arg_repeated: Vec = Default::default(); _aidl_data.resize_out_vec(&mut _arg_repeated)?; let _aidl_return = _aidl_service.r#ReverseBoolean(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseByte => { let _arg_input: Vec = _aidl_data.read()?; let mut _arg_repeated: Vec = Default::default(); _aidl_data.resize_out_vec(&mut _arg_repeated)?; let _aidl_return = _aidl_service.r#ReverseByte(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseChar => { let _arg_input: Vec = _aidl_data.read()?; let mut _arg_repeated: Vec = Default::default(); _aidl_data.resize_out_vec(&mut _arg_repeated)?; let _aidl_return = _aidl_service.r#ReverseChar(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseInt => { let _arg_input: Vec = _aidl_data.read()?; let mut _arg_repeated: Vec = Default::default(); _aidl_data.resize_out_vec(&mut _arg_repeated)?; let _aidl_return = _aidl_service.r#ReverseInt(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseLong => { let _arg_input: Vec = _aidl_data.read()?; let mut _arg_repeated: Vec = Default::default(); _aidl_data.resize_out_vec(&mut _arg_repeated)?; let _aidl_return = _aidl_service.r#ReverseLong(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseFloat => { let _arg_input: Vec = _aidl_data.read()?; let mut _arg_repeated: Vec = Default::default(); _aidl_data.resize_out_vec(&mut _arg_repeated)?; let _aidl_return = _aidl_service.r#ReverseFloat(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseDouble => { let _arg_input: Vec = _aidl_data.read()?; let mut _arg_repeated: Vec = Default::default(); _aidl_data.resize_out_vec(&mut _arg_repeated)?; let _aidl_return = _aidl_service.r#ReverseDouble(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseString => { let _arg_input: Vec = _aidl_data.read()?; let mut _arg_repeated: Vec = Default::default(); _aidl_data.resize_out_vec(&mut _arg_repeated)?; let _aidl_return = _aidl_service.r#ReverseString(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseByteEnum => { let _arg_input: Vec = _aidl_data.read()?; let mut _arg_repeated: Vec = Default::default(); _aidl_data.resize_out_vec(&mut _arg_repeated)?; let _aidl_return = _aidl_service.r#ReverseByteEnum(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseIntEnum => { let _arg_input: Vec = _aidl_data.read()?; let mut _arg_repeated: Vec = Default::default(); _aidl_data.resize_out_vec(&mut _arg_repeated)?; let _aidl_return = _aidl_service.r#ReverseIntEnum(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseLongEnum => { let _arg_input: Vec = _aidl_data.read()?; let mut _arg_repeated: Vec = Default::default(); _aidl_data.resize_out_vec(&mut _arg_repeated)?; let _aidl_return = _aidl_service.r#ReverseLongEnum(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#GetOtherTestService => { let _arg_name: String = _aidl_data.read()?; let _aidl_return = _aidl_service.r#GetOtherTestService(&_arg_name); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#SetOtherTestService => { let _arg_name: String = _aidl_data.read()?; let _arg_service: binder::Strong = _aidl_data.read()?; let _aidl_return = _aidl_service.r#SetOtherTestService(&_arg_name, &_arg_service); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#VerifyName => { let _arg_service: binder::Strong = _aidl_data.read()?; let _arg_name: String = _aidl_data.read()?; let _aidl_return = _aidl_service.r#VerifyName(&_arg_service, &_arg_name); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#GetInterfaceArray => { let _arg_names: Vec = _aidl_data.read()?; let _aidl_return = _aidl_service.r#GetInterfaceArray(&_arg_names); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#VerifyNamesWithInterfaceArray => { let _arg_services: Vec> = _aidl_data.read()?; let _arg_names: Vec = _aidl_data.read()?; let _aidl_return = _aidl_service.r#VerifyNamesWithInterfaceArray(&_arg_services, &_arg_names); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#GetNullableInterfaceArray => { let _arg_names: Option>> = _aidl_data.read()?; let _aidl_return = _aidl_service.r#GetNullableInterfaceArray(_arg_names.as_deref()); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#VerifyNamesWithNullableInterfaceArray => { let _arg_services: Option>>> = _aidl_data.read()?; let _arg_names: Option>> = _aidl_data.read()?; let _aidl_return = _aidl_service.r#VerifyNamesWithNullableInterfaceArray(_arg_services.as_deref(), _arg_names.as_deref()); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#GetInterfaceList => { let _arg_names: Option>> = _aidl_data.read()?; let _aidl_return = _aidl_service.r#GetInterfaceList(_arg_names.as_deref()); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#VerifyNamesWithInterfaceList => { let _arg_services: Option>>> = _aidl_data.read()?; let _arg_names: Option>> = _aidl_data.read()?; let _aidl_return = _aidl_service.r#VerifyNamesWithInterfaceList(_arg_services.as_deref(), _arg_names.as_deref()); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseStringList => { let _arg_input: Vec = _aidl_data.read()?; let mut _arg_repeated: Vec = Default::default(); let _aidl_return = _aidl_service.r#ReverseStringList(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatParcelFileDescriptor => { let _arg_read: binder::ParcelFileDescriptor = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatParcelFileDescriptor(&_arg_read); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseParcelFileDescriptorArray => { let _arg_input: Vec = _aidl_data.read()?; let mut _arg_repeated: Vec> = Default::default(); _aidl_data.resize_out_vec(&mut _arg_repeated)?; let _aidl_return = _aidl_service.r#ReverseParcelFileDescriptorArray(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; if _arg_repeated.iter().any(Option::is_none) { return Err(binder::StatusCode::UNEXPECTED_NULL); } _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ThrowServiceException => { let _arg_code: i32 = _aidl_data.read()?; let _aidl_return = _aidl_service.r#ThrowServiceException(_arg_code); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatNullableIntArray => { let _arg_input: Option> = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatNullableIntArray(_arg_input.as_deref()); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatNullableByteEnumArray => { let _arg_input: Option> = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatNullableByteEnumArray(_arg_input.as_deref()); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatNullableIntEnumArray => { let _arg_input: Option> = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatNullableIntEnumArray(_arg_input.as_deref()); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatNullableLongEnumArray => { let _arg_input: Option> = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatNullableLongEnumArray(_arg_input.as_deref()); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatNullableString => { let _arg_input: Option = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatNullableString(_arg_input.as_deref()); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatNullableStringList => { let _arg_input: Option>> = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatNullableStringList(_arg_input.as_deref()); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatNullableParcelable => { let _arg_input: Option = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatNullableParcelable(_arg_input.as_ref()); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatNullableParcelableArray => { let _arg_input: Option>> = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatNullableParcelableArray(_arg_input.as_deref()); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatNullableParcelableList => { let _arg_input: Option>> = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatNullableParcelableList(_arg_input.as_deref()); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#TakesAnIBinder => { let _arg_input: binder::SpIBinder = _aidl_data.read()?; let _aidl_return = _aidl_service.r#TakesAnIBinder(&_arg_input); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#TakesANullableIBinder => { let _arg_input: Option = _aidl_data.read()?; let _aidl_return = _aidl_service.r#TakesANullableIBinder(_arg_input.as_ref()); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#TakesAnIBinderList => { let _arg_input: Vec = _aidl_data.read()?; let _aidl_return = _aidl_service.r#TakesAnIBinderList(&_arg_input); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#TakesANullableIBinderList => { let _arg_input: Option>> = _aidl_data.read()?; let _aidl_return = _aidl_service.r#TakesANullableIBinderList(_arg_input.as_deref()); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatUtf8CppString => { let _arg_token: String = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatUtf8CppString(&_arg_token); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatNullableUtf8CppString => { let _arg_token: Option = _aidl_data.read()?; let _aidl_return = _aidl_service.r#RepeatNullableUtf8CppString(_arg_token.as_deref()); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseUtf8CppString => { let _arg_input: Vec = _aidl_data.read()?; let mut _arg_repeated: Vec = Default::default(); _aidl_data.resize_out_vec(&mut _arg_repeated)?; let _aidl_return = _aidl_service.r#ReverseUtf8CppString(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseNullableUtf8CppString => { let _arg_input: Option>> = _aidl_data.read()?; let mut _arg_repeated: Option>> = Default::default(); _aidl_data.resize_nullable_out_vec(&mut _arg_repeated)?; let _aidl_return = _aidl_service.r#ReverseNullableUtf8CppString(_arg_input.as_deref(), &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseUtf8CppStringList => { let _arg_input: Option>> = _aidl_data.read()?; let mut _arg_repeated: Option>> = Default::default(); let _aidl_return = _aidl_service.r#ReverseUtf8CppStringList(_arg_input.as_deref(), &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#GetCallback => { let _arg_return_null: bool = _aidl_data.read()?; let _aidl_return = _aidl_service.r#GetCallback(_arg_return_null); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#FillOutStructuredParcelable => { let mut _arg_parcel: crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable = _aidl_data.read()?; let _aidl_return = _aidl_service.r#FillOutStructuredParcelable(&mut _arg_parcel); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(&_arg_parcel)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatExtendableParcelable => { let _arg_ep: crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable = _aidl_data.read()?; let mut _arg_ep2: crate::mangled::_7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable = Default::default(); let _aidl_return = _aidl_service.r#RepeatExtendableParcelable(&_arg_ep, &mut _arg_ep2); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(&_arg_ep2)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseList => { let _arg_list: crate::mangled::_7_android_4_aidl_5_tests_13_RecursiveList = _aidl_data.read()?; let _aidl_return = _aidl_service.r#ReverseList(&_arg_list); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseIBinderArray => { let _arg_input: Vec = _aidl_data.read()?; let mut _arg_repeated: Vec> = Default::default(); _aidl_data.resize_out_vec(&mut _arg_repeated)?; let _aidl_return = _aidl_service.r#ReverseIBinderArray(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseNullableIBinderArray => { let _arg_input: Option>> = _aidl_data.read()?; let mut _arg_repeated: Option>> = Default::default(); _aidl_data.resize_nullable_out_vec(&mut _arg_repeated)?; let _aidl_return = _aidl_service.r#ReverseNullableIBinderArray(_arg_input.as_deref(), &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#RepeatSimpleParcelable => { let _arg_input: simple_parcelable::SimpleParcelable = _aidl_data.read()?; let mut _arg_repeat: simple_parcelable::SimpleParcelable = Default::default(); let _aidl_return = _aidl_service.r#RepeatSimpleParcelable(&_arg_input, &mut _arg_repeat); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeat)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ReverseSimpleParcelables => { let _arg_input: Vec = _aidl_data.read()?; let mut _arg_repeated: Vec = Default::default(); _aidl_data.resize_out_vec(&mut _arg_repeated)?; let _aidl_return = _aidl_service.r#ReverseSimpleParcelables(&_arg_input, &mut _arg_repeated); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_repeated)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#GetOldNameInterface => { let _aidl_return = _aidl_service.r#GetOldNameInterface(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#GetNewNameInterface => { let _aidl_return = _aidl_service.r#GetNewNameInterface(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#GetUnionTags => { let _arg_input: Vec = _aidl_data.read()?; let _aidl_return = _aidl_service.r#GetUnionTags(&_arg_input); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#GetCppJavaTests => { let _aidl_return = _aidl_service.r#GetCppJavaTests(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#getBackendType => { let _aidl_return = _aidl_service.r#getBackendType(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#GetCircular => { let mut _arg_cp: crate::mangled::_7_android_4_aidl_5_tests_18_CircularParcelable = Default::default(); let _aidl_return = _aidl_service.r#GetCircular(&mut _arg_cp); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_cp)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } pub mod r#Empty { #[derive(Debug, Clone, PartialEq)] pub struct r#Empty { } impl Default for r#Empty { fn default() -> Self { Self { } } } impl binder::Parcelable for r#Empty { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#Empty); binder::impl_deserialize_for_parcelable!(r#Empty); impl binder::binder_impl::ParcelableMetadata for r#Empty { fn get_descriptor() -> &'static str { "android.aidl.tests.ITestService.Empty" } } } pub mod r#CompilerChecks { #[derive(Debug)] pub struct r#CompilerChecks { pub r#binder: Option, pub r#nullable_binder: Option, pub r#binder_array: Vec, pub r#nullable_binder_array: Option>>, pub r#binder_list: Vec, pub r#nullable_binder_list: Option>>, pub r#pfd: Option, pub r#nullable_pfd: Option, pub r#pfd_array: Vec, pub r#nullable_pfd_array: Option>>, pub r#pfd_list: Vec, pub r#nullable_pfd_list: Option>>, pub r#parcel: crate::mangled::_7_android_4_aidl_5_tests_12_ITestService_5_Empty, pub r#nullable_parcel: Option, pub r#parcel_array: Vec, pub r#nullable_parcel_array: Option>>, pub r#parcel_list: Vec, pub r#nullable_parcel_list: Option>>, } impl Default for r#CompilerChecks { fn default() -> Self { Self { r#binder: Default::default(), r#nullable_binder: Default::default(), r#binder_array: Default::default(), r#nullable_binder_array: Default::default(), r#binder_list: Default::default(), r#nullable_binder_list: Default::default(), r#pfd: Default::default(), r#nullable_pfd: Default::default(), r#pfd_array: Default::default(), r#nullable_pfd_array: Default::default(), r#pfd_list: Default::default(), r#nullable_pfd_list: Default::default(), r#parcel: Default::default(), r#nullable_parcel: Default::default(), r#parcel_array: Default::default(), r#nullable_parcel_array: Default::default(), r#parcel_list: Default::default(), r#nullable_parcel_list: Default::default(), } } } impl binder::Parcelable for r#CompilerChecks { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { let __field_ref = self.r#binder.as_ref().ok_or(binder::StatusCode::UNEXPECTED_NULL)?; subparcel.write(__field_ref)?; subparcel.write(&self.r#nullable_binder)?; subparcel.write(&self.r#binder_array)?; subparcel.write(&self.r#nullable_binder_array)?; subparcel.write(&self.r#binder_list)?; subparcel.write(&self.r#nullable_binder_list)?; let __field_ref = self.r#pfd.as_ref().ok_or(binder::StatusCode::UNEXPECTED_NULL)?; subparcel.write(__field_ref)?; subparcel.write(&self.r#nullable_pfd)?; subparcel.write(&self.r#pfd_array)?; subparcel.write(&self.r#nullable_pfd_array)?; subparcel.write(&self.r#pfd_list)?; subparcel.write(&self.r#nullable_pfd_list)?; subparcel.write(&self.r#parcel)?; subparcel.write(&self.r#nullable_parcel)?; subparcel.write(&self.r#parcel_array)?; subparcel.write(&self.r#nullable_parcel_array)?; subparcel.write(&self.r#parcel_list)?; subparcel.write(&self.r#nullable_parcel_list)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#binder = Some(subparcel.read()?); } if subparcel.has_more_data() { self.r#nullable_binder = subparcel.read()?; } if subparcel.has_more_data() { self.r#binder_array = subparcel.read()?; } if subparcel.has_more_data() { self.r#nullable_binder_array = subparcel.read()?; } if subparcel.has_more_data() { self.r#binder_list = subparcel.read()?; } if subparcel.has_more_data() { self.r#nullable_binder_list = subparcel.read()?; } if subparcel.has_more_data() { self.r#pfd = Some(subparcel.read()?); } if subparcel.has_more_data() { self.r#nullable_pfd = subparcel.read()?; } if subparcel.has_more_data() { self.r#pfd_array = subparcel.read()?; } if subparcel.has_more_data() { self.r#nullable_pfd_array = subparcel.read()?; } if subparcel.has_more_data() { self.r#pfd_list = subparcel.read()?; } if subparcel.has_more_data() { self.r#nullable_pfd_list = subparcel.read()?; } if subparcel.has_more_data() { self.r#parcel = subparcel.read()?; } if subparcel.has_more_data() { self.r#nullable_parcel = subparcel.read()?; } if subparcel.has_more_data() { self.r#parcel_array = subparcel.read()?; } if subparcel.has_more_data() { self.r#nullable_parcel_array = subparcel.read()?; } if subparcel.has_more_data() { self.r#parcel_list = subparcel.read()?; } if subparcel.has_more_data() { self.r#nullable_parcel_list = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#CompilerChecks); binder::impl_deserialize_for_parcelable!(r#CompilerChecks); impl binder::binder_impl::ParcelableMetadata for r#CompilerChecks { fn get_descriptor() -> &'static str { "android.aidl.tests.ITestService.CompilerChecks" } } pub mod r#Foo { #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { IFoo["android.aidl.tests.ITestService.CompilerChecks.Foo"] { native: BnFoo(on_transact), proxy: BpFoo { }, async: IFooAsync, } } pub trait IFoo: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ITestService.CompilerChecks.Foo" } fn getDefaultImpl() -> IFooDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: IFooDefaultRef) -> IFooDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait IFooAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ITestService.CompilerChecks.Foo" } } #[::async_trait::async_trait] pub trait IFooAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ITestService.CompilerChecks.Foo" } } impl BnFoo { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: IFooAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl IFoo for Wrapper where T: IFooAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait IFooDefault: Send + Sync { } pub mod transactions { } pub type IFooDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); impl BpFoo { } impl IFoo for BpFoo { } impl IFooAsync

for BpFoo { } impl IFoo for binder::binder_impl::Binder { } fn on_transact(_aidl_service: &dyn IFoo, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } } pub mod r#HasDeprecated { #[derive(Debug)] pub struct r#HasDeprecated { #[deprecated = "field"] pub r#deprecated: i32, } impl Default for r#HasDeprecated { fn default() -> Self { Self { r#deprecated: 0, } } } impl binder::Parcelable for r#HasDeprecated { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#deprecated)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#deprecated = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#HasDeprecated); binder::impl_deserialize_for_parcelable!(r#HasDeprecated); impl binder::binder_impl::ParcelableMetadata for r#HasDeprecated { fn get_descriptor() -> &'static str { "android.aidl.tests.ITestService.CompilerChecks.HasDeprecated" } } } pub mod r#UsingHasDeprecated { #[derive(Debug)] pub enum r#UsingHasDeprecated { N(i32), M(crate::mangled::_7_android_4_aidl_5_tests_12_ITestService_14_CompilerChecks_13_HasDeprecated), } impl Default for r#UsingHasDeprecated { fn default() -> Self { Self::N(0) } } impl binder::Parcelable for r#UsingHasDeprecated { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { match self { Self::N(v) => { parcel.write(&0i32)?; parcel.write(v) } Self::M(v) => { parcel.write(&1i32)?; parcel.write(v) } } } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { let tag: i32 = parcel.read()?; match tag { 0 => { let value: i32 = parcel.read()?; *self = Self::N(value); Ok(()) } 1 => { let value: crate::mangled::_7_android_4_aidl_5_tests_12_ITestService_14_CompilerChecks_13_HasDeprecated = parcel.read()?; *self = Self::M(value); Ok(()) } _ => { Err(binder::StatusCode::BAD_VALUE) } } } } binder::impl_serialize_for_parcelable!(r#UsingHasDeprecated); binder::impl_deserialize_for_parcelable!(r#UsingHasDeprecated); impl binder::binder_impl::ParcelableMetadata for r#UsingHasDeprecated { fn get_descriptor() -> &'static str { "android.aidl.tests.ITestService.CompilerChecks.UsingHasDeprecated" } } pub mod r#Tag { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#Tag : [i32; 2] { r#n = 0, r#m = 1, } } } } pub mod r#NoPrefixInterface { #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { INoPrefixInterface["android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface"] { native: BnNoPrefixInterface(on_transact), proxy: BpNoPrefixInterface { }, async: INoPrefixInterfaceAsync, } } pub trait INoPrefixInterface: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface" } fn r#foo(&self) -> binder::Result<()>; fn getDefaultImpl() -> INoPrefixInterfaceDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: INoPrefixInterfaceDefaultRef) -> INoPrefixInterfaceDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait INoPrefixInterfaceAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface" } fn r#foo<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result<()>>; } #[::async_trait::async_trait] pub trait INoPrefixInterfaceAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface" } async fn r#foo(&self) -> binder::Result<()>; } impl BnNoPrefixInterface { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: INoPrefixInterfaceAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl INoPrefixInterface for Wrapper where T: INoPrefixInterfaceAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#foo(&self) -> binder::Result<()> { self._rt.block_on(self._inner.r#foo()) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait INoPrefixInterfaceDefault: Send + Sync { fn r#foo(&self) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#foo: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; } pub type INoPrefixInterfaceDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); impl BpNoPrefixInterface { fn build_parcel_foo(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_foo(&self, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#foo(); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } Ok(()) } } impl INoPrefixInterface for BpNoPrefixInterface { fn r#foo(&self) -> binder::Result<()> { let _aidl_data = self.build_parcel_foo()?; let _aidl_reply = self.binder.submit_transact(transactions::r#foo, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_foo(_aidl_reply) } } impl INoPrefixInterfaceAsync

for BpNoPrefixInterface { fn r#foo<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_foo() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#foo, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_foo(_aidl_reply) } ) } } impl INoPrefixInterface for binder::binder_impl::Binder { fn r#foo(&self) -> binder::Result<()> { self.0.r#foo() } } fn on_transact(_aidl_service: &dyn INoPrefixInterface, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#foo => { let _aidl_return = _aidl_service.r#foo(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } pub mod r#Nested { #[derive(Debug)] pub struct r#Nested { } impl Default for r#Nested { fn default() -> Self { Self { } } } impl binder::Parcelable for r#Nested { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#Nested); binder::impl_deserialize_for_parcelable!(r#Nested); impl binder::binder_impl::ParcelableMetadata for r#Nested { fn get_descriptor() -> &'static str { "android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.Nested" } } } pub mod r#NestedNoPrefixInterface { #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { INestedNoPrefixInterface["android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.NestedNoPrefixInterface"] { native: BnNestedNoPrefixInterface(on_transact), proxy: BpNestedNoPrefixInterface { }, async: INestedNoPrefixInterfaceAsync, } } pub trait INestedNoPrefixInterface: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.NestedNoPrefixInterface" } fn r#foo(&self) -> binder::Result<()>; fn getDefaultImpl() -> INestedNoPrefixInterfaceDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: INestedNoPrefixInterfaceDefaultRef) -> INestedNoPrefixInterfaceDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait INestedNoPrefixInterfaceAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.NestedNoPrefixInterface" } fn r#foo<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result<()>>; } #[::async_trait::async_trait] pub trait INestedNoPrefixInterfaceAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ITestService.CompilerChecks.NoPrefixInterface.NestedNoPrefixInterface" } async fn r#foo(&self) -> binder::Result<()>; } impl BnNestedNoPrefixInterface { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: INestedNoPrefixInterfaceAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl INestedNoPrefixInterface for Wrapper where T: INestedNoPrefixInterfaceAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#foo(&self) -> binder::Result<()> { self._rt.block_on(self._inner.r#foo()) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait INestedNoPrefixInterfaceDefault: Send + Sync { fn r#foo(&self) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#foo: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; } pub type INestedNoPrefixInterfaceDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); impl BpNestedNoPrefixInterface { fn build_parcel_foo(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_foo(&self, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#foo(); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } Ok(()) } } impl INestedNoPrefixInterface for BpNestedNoPrefixInterface { fn r#foo(&self) -> binder::Result<()> { let _aidl_data = self.build_parcel_foo()?; let _aidl_reply = self.binder.submit_transact(transactions::r#foo, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_foo(_aidl_reply) } } impl INestedNoPrefixInterfaceAsync

for BpNestedNoPrefixInterface { fn r#foo<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_foo() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#foo, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_foo(_aidl_reply) } ) } } impl INestedNoPrefixInterface for binder::binder_impl::Binder { fn r#foo(&self) -> binder::Result<()> { self.0.r#foo() } } fn on_transact(_aidl_service: &dyn INestedNoPrefixInterface, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#foo => { let _aidl_return = _aidl_service.r#foo(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } } } } pub(crate) mod mangled { pub use super::r#ITestService as _7_android_4_aidl_5_tests_12_ITestService; pub use super::r#Empty::r#Empty as _7_android_4_aidl_5_tests_12_ITestService_5_Empty; pub use super::r#CompilerChecks::r#CompilerChecks as _7_android_4_aidl_5_tests_12_ITestService_14_CompilerChecks; pub use super::r#CompilerChecks::r#Foo::r#IFoo as _7_android_4_aidl_5_tests_12_ITestService_14_CompilerChecks_3_Foo; pub use super::r#CompilerChecks::r#HasDeprecated::r#HasDeprecated as _7_android_4_aidl_5_tests_12_ITestService_14_CompilerChecks_13_HasDeprecated; pub use super::r#CompilerChecks::r#UsingHasDeprecated::r#UsingHasDeprecated as _7_android_4_aidl_5_tests_12_ITestService_14_CompilerChecks_18_UsingHasDeprecated; pub use super::r#CompilerChecks::r#UsingHasDeprecated::r#Tag::r#Tag as _7_android_4_aidl_5_tests_12_ITestService_14_CompilerChecks_18_UsingHasDeprecated_3_Tag; pub use super::r#CompilerChecks::r#NoPrefixInterface::r#INoPrefixInterface as _7_android_4_aidl_5_tests_12_ITestService_14_CompilerChecks_17_NoPrefixInterface; pub use super::r#CompilerChecks::r#NoPrefixInterface::r#Nested::r#Nested as _7_android_4_aidl_5_tests_12_ITestService_14_CompilerChecks_17_NoPrefixInterface_6_Nested; pub use super::r#CompilerChecks::r#NoPrefixInterface::r#NestedNoPrefixInterface::r#INestedNoPrefixInterface as _7_android_4_aidl_5_tests_12_ITestService_14_CompilerChecks_17_NoPrefixInterface_23_NestedNoPrefixInterface; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_IT0100644 0000000 0000000 00000000034 15172120304 033251 xustar000000000 0000000 28 mtime=1776853188.6700000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/ITestService.rs.d0100644 0000000 0000000 00000002225 15172120304 032660 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/ITestService.rs : \ system/tools/aidl/tests/android/aidl/tests/ITestService.aidl \ system/tools/aidl/tests/android/aidl/tests/BackendType.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/CircularParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ICircular.aidl \ system/tools/aidl/tests/android/aidl/tests/INamedCallback.aidl \ system/tools/aidl/tests/android/aidl/tests/INewName.aidl \ system/tools/aidl/tests/android/aidl/tests/IOldName.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl \ system/tools/aidl/tests/android/aidl/tests/SimpleParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_In0100644 0000000 0000000 00000000034 15172120304 033303 xustar000000000 0000000 28 mtime=1776853188.6700000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/IntEnum.rs0100644 0000000 0000000 00000001531 15172120304 031443 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/IntEnum.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#IntEnum : [i32; 4] { r#FOO = 1000, r#BAR = 2000, r#BAZ = 2001, #[deprecated = "do not use this"] r#QUX = 2002, } } pub(crate) mod mangled { pub use super::r#IntEnum as _7_android_4_aidl_5_tests_7_IntEnum; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_In0100644 0000000 0000000 00000000034 15172120304 033303 xustar000000000 0000000 28 mtime=1776853188.6700000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/IntEnum.rs.d0100644 0000000 0000000 00000000253 15172120304 031665 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/IntEnum.rs : \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_Li0100644 0000000 0000000 00000000213 15172120304 033300 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/ListOfInterfaces.rs 28 mtime=1776853188.6700000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/ListOfInterfaces.r0100644 0000000 0000000 00000100321 15172120304 033102 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/ListOfInterfaces.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ListOfInterfaces.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub struct r#ListOfInterfaces { } impl Default for r#ListOfInterfaces { fn default() -> Self { Self { } } } impl binder::Parcelable for r#ListOfInterfaces { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#ListOfInterfaces); binder::impl_deserialize_for_parcelable!(r#ListOfInterfaces); impl binder::binder_impl::ParcelableMetadata for r#ListOfInterfaces { fn get_descriptor() -> &'static str { "android.aidl.tests.ListOfInterfaces" } } pub mod r#IEmptyInterface { #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { IEmptyInterface["android.aidl.tests.ListOfInterfaces.IEmptyInterface"] { native: BnEmptyInterface(on_transact), proxy: BpEmptyInterface { }, async: IEmptyInterfaceAsync, } } pub trait IEmptyInterface: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ListOfInterfaces.IEmptyInterface" } fn getDefaultImpl() -> IEmptyInterfaceDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: IEmptyInterfaceDefaultRef) -> IEmptyInterfaceDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait IEmptyInterfaceAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ListOfInterfaces.IEmptyInterface" } } #[::async_trait::async_trait] pub trait IEmptyInterfaceAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ListOfInterfaces.IEmptyInterface" } } impl BnEmptyInterface { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: IEmptyInterfaceAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl IEmptyInterface for Wrapper where T: IEmptyInterfaceAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait IEmptyInterfaceDefault: Send + Sync { } pub mod transactions { } pub type IEmptyInterfaceDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); impl BpEmptyInterface { } impl IEmptyInterface for BpEmptyInterface { } impl IEmptyInterfaceAsync

for BpEmptyInterface { } impl IEmptyInterface for binder::binder_impl::Binder { } fn on_transact(_aidl_service: &dyn IEmptyInterface, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } } pub mod r#IMyInterface { #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { IMyInterface["android.aidl.tests.ListOfInterfaces.IMyInterface"] { native: BnMyInterface(on_transact), proxy: BpMyInterface { }, async: IMyInterfaceAsync, } } pub trait IMyInterface: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ListOfInterfaces.IMyInterface" } fn r#methodWithInterfaces(&self, _arg_iface: &binder::Strong, _arg_nullable_iface: Option<&binder::Strong>, _arg_iface_list_in: &[binder::Strong], _arg_iface_list_out: &mut Vec>>, _arg_iface_list_inout: &mut Vec>, _arg_nullable_iface_list_in: Option<&[Option>]>, _arg_nullable_iface_list_out: &mut Option>>>, _arg_nullable_iface_list_inout: &mut Option>>>) -> binder::Result>>>>; fn getDefaultImpl() -> IMyInterfaceDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: IMyInterfaceDefaultRef) -> IMyInterfaceDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait IMyInterfaceAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ListOfInterfaces.IMyInterface" } fn r#methodWithInterfaces<'a>(&'a self, _arg_iface: &'a binder::Strong, _arg_nullable_iface: Option<&'a binder::Strong>, _arg_iface_list_in: &'a [binder::Strong], _arg_iface_list_out: &'a mut Vec>>, _arg_iface_list_inout: &'a mut Vec>, _arg_nullable_iface_list_in: Option<&'a [Option>]>, _arg_nullable_iface_list_out: &'a mut Option>>>, _arg_nullable_iface_list_inout: &'a mut Option>>>) -> binder::BoxFuture<'a, binder::Result>>>>>; } #[::async_trait::async_trait] pub trait IMyInterfaceAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.ListOfInterfaces.IMyInterface" } async fn r#methodWithInterfaces(&self, _arg_iface: &binder::Strong, _arg_nullable_iface: Option<&binder::Strong>, _arg_iface_list_in: &[binder::Strong], _arg_iface_list_out: &mut Vec>>, _arg_iface_list_inout: &mut Vec>, _arg_nullable_iface_list_in: Option<&[Option>]>, _arg_nullable_iface_list_out: &mut Option>>>, _arg_nullable_iface_list_inout: &mut Option>>>) -> binder::Result>>>>; } impl BnMyInterface { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: IMyInterfaceAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl IMyInterface for Wrapper where T: IMyInterfaceAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#methodWithInterfaces(&self, _arg_iface: &binder::Strong, _arg_nullable_iface: Option<&binder::Strong>, _arg_iface_list_in: &[binder::Strong], _arg_iface_list_out: &mut Vec>>, _arg_iface_list_inout: &mut Vec>, _arg_nullable_iface_list_in: Option<&[Option>]>, _arg_nullable_iface_list_out: &mut Option>>>, _arg_nullable_iface_list_inout: &mut Option>>>) -> binder::Result>>>> { self._rt.block_on(self._inner.r#methodWithInterfaces(_arg_iface, _arg_nullable_iface, _arg_iface_list_in, _arg_iface_list_out, _arg_iface_list_inout, _arg_nullable_iface_list_in, _arg_nullable_iface_list_out, _arg_nullable_iface_list_inout)) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait IMyInterfaceDefault: Send + Sync { fn r#methodWithInterfaces(&self, _arg_iface: &binder::Strong, _arg_nullable_iface: Option<&binder::Strong>, _arg_iface_list_in: &[binder::Strong], _arg_iface_list_out: &mut Vec>>, _arg_iface_list_inout: &mut Vec>, _arg_nullable_iface_list_in: Option<&[Option>]>, _arg_nullable_iface_list_out: &mut Option>>>, _arg_nullable_iface_list_inout: &mut Option>>>) -> binder::Result>>>> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#methodWithInterfaces: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; } pub type IMyInterfaceDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); impl BpMyInterface { fn build_parcel_methodWithInterfaces(&self, _arg_iface: &binder::Strong, _arg_nullable_iface: Option<&binder::Strong>, _arg_iface_list_in: &[binder::Strong], _arg_iface_list_out: &mut Vec>>, _arg_iface_list_inout: &mut Vec>, _arg_nullable_iface_list_in: Option<&[Option>]>, _arg_nullable_iface_list_out: &mut Option>>>, _arg_nullable_iface_list_inout: &mut Option>>>) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_iface)?; aidl_data.write(&_arg_nullable_iface)?; aidl_data.write(_arg_iface_list_in)?; aidl_data.write(_arg_iface_list_inout)?; aidl_data.write(&_arg_nullable_iface_list_in)?; aidl_data.write(_arg_nullable_iface_list_inout)?; Ok(aidl_data) } fn read_response_methodWithInterfaces(&self, _arg_iface: &binder::Strong, _arg_nullable_iface: Option<&binder::Strong>, _arg_iface_list_in: &[binder::Strong], _arg_iface_list_out: &mut Vec>>, _arg_iface_list_inout: &mut Vec>, _arg_nullable_iface_list_in: Option<&[Option>]>, _arg_nullable_iface_list_out: &mut Option>>>, _arg_nullable_iface_list_inout: &mut Option>>>, _aidl_reply: std::result::Result) -> binder::Result>>>> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#methodWithInterfaces(_arg_iface, _arg_nullable_iface, _arg_iface_list_in, _arg_iface_list_out, _arg_iface_list_inout, _arg_nullable_iface_list_in, _arg_nullable_iface_list_out, _arg_nullable_iface_list_inout); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: Option>>> = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_iface_list_out)?; _aidl_reply.read_onto(_arg_iface_list_inout)?; _aidl_reply.read_onto(_arg_nullable_iface_list_out)?; _aidl_reply.read_onto(_arg_nullable_iface_list_inout)?; Ok(_aidl_return) } } impl IMyInterface for BpMyInterface { fn r#methodWithInterfaces(&self, _arg_iface: &binder::Strong, _arg_nullable_iface: Option<&binder::Strong>, _arg_iface_list_in: &[binder::Strong], _arg_iface_list_out: &mut Vec>>, _arg_iface_list_inout: &mut Vec>, _arg_nullable_iface_list_in: Option<&[Option>]>, _arg_nullable_iface_list_out: &mut Option>>>, _arg_nullable_iface_list_inout: &mut Option>>>) -> binder::Result>>>> { let _aidl_data = self.build_parcel_methodWithInterfaces(_arg_iface, _arg_nullable_iface, _arg_iface_list_in, _arg_iface_list_out, _arg_iface_list_inout, _arg_nullable_iface_list_in, _arg_nullable_iface_list_out, _arg_nullable_iface_list_inout)?; let _aidl_reply = self.binder.submit_transact(transactions::r#methodWithInterfaces, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_methodWithInterfaces(_arg_iface, _arg_nullable_iface, _arg_iface_list_in, _arg_iface_list_out, _arg_iface_list_inout, _arg_nullable_iface_list_in, _arg_nullable_iface_list_out, _arg_nullable_iface_list_inout, _aidl_reply) } } impl IMyInterfaceAsync

for BpMyInterface { fn r#methodWithInterfaces<'a>(&'a self, _arg_iface: &'a binder::Strong, _arg_nullable_iface: Option<&'a binder::Strong>, _arg_iface_list_in: &'a [binder::Strong], _arg_iface_list_out: &'a mut Vec>>, _arg_iface_list_inout: &'a mut Vec>, _arg_nullable_iface_list_in: Option<&'a [Option>]>, _arg_nullable_iface_list_out: &'a mut Option>>>, _arg_nullable_iface_list_inout: &'a mut Option>>>) -> binder::BoxFuture<'a, binder::Result>>>>> { let _aidl_data = match self.build_parcel_methodWithInterfaces(_arg_iface, _arg_nullable_iface, _arg_iface_list_in, _arg_iface_list_out, _arg_iface_list_inout, _arg_nullable_iface_list_in, _arg_nullable_iface_list_out, _arg_nullable_iface_list_inout) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#methodWithInterfaces, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_methodWithInterfaces(_arg_iface, _arg_nullable_iface, _arg_iface_list_in, _arg_iface_list_out, _arg_iface_list_inout, _arg_nullable_iface_list_in, _arg_nullable_iface_list_out, _arg_nullable_iface_list_inout, _aidl_reply) } ) } } impl IMyInterface for binder::binder_impl::Binder { fn r#methodWithInterfaces(&self, _arg_iface: &binder::Strong, _arg_nullable_iface: Option<&binder::Strong>, _arg_iface_list_in: &[binder::Strong], _arg_iface_list_out: &mut Vec>>, _arg_iface_list_inout: &mut Vec>, _arg_nullable_iface_list_in: Option<&[Option>]>, _arg_nullable_iface_list_out: &mut Option>>>, _arg_nullable_iface_list_inout: &mut Option>>>) -> binder::Result>>>> { self.0.r#methodWithInterfaces(_arg_iface, _arg_nullable_iface, _arg_iface_list_in, _arg_iface_list_out, _arg_iface_list_inout, _arg_nullable_iface_list_in, _arg_nullable_iface_list_out, _arg_nullable_iface_list_inout) } } fn on_transact(_aidl_service: &dyn IMyInterface, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#methodWithInterfaces => { let _arg_iface: binder::Strong = _aidl_data.read()?; let _arg_nullable_iface: Option> = _aidl_data.read()?; let _arg_iface_list_in: Vec> = _aidl_data.read()?; let mut _arg_iface_list_out: Vec>> = Default::default(); let mut _arg_iface_list_inout: Vec> = _aidl_data.read()?; let _arg_nullable_iface_list_in: Option>>> = _aidl_data.read()?; let mut _arg_nullable_iface_list_out: Option>>> = Default::default(); let mut _arg_nullable_iface_list_inout: Option>>> = _aidl_data.read()?; let _aidl_return = _aidl_service.r#methodWithInterfaces(&_arg_iface, _arg_nullable_iface.as_ref(), &_arg_iface_list_in, &mut _arg_iface_list_out, &mut _arg_iface_list_inout, _arg_nullable_iface_list_in.as_deref(), &mut _arg_nullable_iface_list_out, &mut _arg_nullable_iface_list_inout); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_iface_list_out)?; _aidl_reply.write(&_arg_iface_list_inout)?; _aidl_reply.write(&_arg_nullable_iface_list_out)?; _aidl_reply.write(&_arg_nullable_iface_list_inout)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } } pub mod r#MyParcelable { #[derive(Debug)] pub struct r#MyParcelable { pub r#iface: Option>, pub r#nullable_iface: Option>, pub r#iface_list: Vec>, pub r#nullable_iface_list: Option>>>, } impl Default for r#MyParcelable { fn default() -> Self { Self { r#iface: Default::default(), r#nullable_iface: Default::default(), r#iface_list: Default::default(), r#nullable_iface_list: Default::default(), } } } impl binder::Parcelable for r#MyParcelable { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { let __field_ref = self.r#iface.as_ref().ok_or(binder::StatusCode::UNEXPECTED_NULL)?; subparcel.write(__field_ref)?; subparcel.write(&self.r#nullable_iface)?; subparcel.write(&self.r#iface_list)?; subparcel.write(&self.r#nullable_iface_list)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#iface = Some(subparcel.read()?); } if subparcel.has_more_data() { self.r#nullable_iface = subparcel.read()?; } if subparcel.has_more_data() { self.r#iface_list = subparcel.read()?; } if subparcel.has_more_data() { self.r#nullable_iface_list = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#MyParcelable); binder::impl_deserialize_for_parcelable!(r#MyParcelable); impl binder::binder_impl::ParcelableMetadata for r#MyParcelable { fn get_descriptor() -> &'static str { "android.aidl.tests.ListOfInterfaces.MyParcelable" } } } pub mod r#MyUnion { #[derive(Debug)] pub enum r#MyUnion { Iface(Option>), Nullable_iface(Option>), Iface_list(Vec>), Nullable_iface_list(Option>>>), } impl Default for r#MyUnion { fn default() -> Self { Self::Iface(Default::default()) } } impl binder::Parcelable for r#MyUnion { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { match self { Self::Iface(v) => { parcel.write(&0i32)?; let __field_ref = v.as_ref().ok_or(binder::StatusCode::UNEXPECTED_NULL)?; parcel.write(__field_ref) } Self::Nullable_iface(v) => { parcel.write(&1i32)?; parcel.write(v) } Self::Iface_list(v) => { parcel.write(&2i32)?; parcel.write(v) } Self::Nullable_iface_list(v) => { parcel.write(&3i32)?; parcel.write(v) } } } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { let tag: i32 = parcel.read()?; match tag { 0 => { let value: Option> = Some(parcel.read()?); *self = Self::Iface(value); Ok(()) } 1 => { let value: Option> = parcel.read()?; *self = Self::Nullable_iface(value); Ok(()) } 2 => { let value: Vec> = parcel.read()?; *self = Self::Iface_list(value); Ok(()) } 3 => { let value: Option>>> = parcel.read()?; *self = Self::Nullable_iface_list(value); Ok(()) } _ => { Err(binder::StatusCode::BAD_VALUE) } } } } binder::impl_serialize_for_parcelable!(r#MyUnion); binder::impl_deserialize_for_parcelable!(r#MyUnion); impl binder::binder_impl::ParcelableMetadata for r#MyUnion { fn get_descriptor() -> &'static str { "android.aidl.tests.ListOfInterfaces.MyUnion" } } pub mod r#Tag { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#Tag : [i32; 4] { r#iface = 0, r#nullable_iface = 1, r#iface_list = 2, r#nullable_iface_list = 3, } } } } pub(crate) mod mangled { pub use super::r#ListOfInterfaces as _7_android_4_aidl_5_tests_16_ListOfInterfaces; pub use super::r#IEmptyInterface::r#IEmptyInterface as _7_android_4_aidl_5_tests_16_ListOfInterfaces_15_IEmptyInterface; pub use super::r#IMyInterface::r#IMyInterface as _7_android_4_aidl_5_tests_16_ListOfInterfaces_12_IMyInterface; pub use super::r#MyParcelable::r#MyParcelable as _7_android_4_aidl_5_tests_16_ListOfInterfaces_12_MyParcelable; pub use super::r#MyUnion::r#MyUnion as _7_android_4_aidl_5_tests_16_ListOfInterfaces_7_MyUnion; pub use super::r#MyUnion::r#Tag::r#Tag as _7_android_4_aidl_5_tests_16_ListOfInterfaces_7_MyUnion_3_Tag; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_Li0100644 0000000 0000000 00000000215 15172120304 033302 xustar000000000 0000000 113 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/ListOfInterfaces.rs.d 28 mtime=1776853188.6710000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/ListOfInterfaces.r0100644 0000000 0000000 00000000275 15172120304 033111 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/ListOfInterfaces.rs : \ system/tools/aidl/tests/android/aidl/tests/ListOfInterfaces.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_Lo0100644 0000000 0000000 00000000034 15172120304 033307 xustar000000000 0000000 28 mtime=1776853188.6710000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/LongEnum.rs0100644 0000000 0000000 00000001476 15172120304 031620 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/LongEnum.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#LongEnum : [i64; 3] { r#FOO = 100000000000, r#BAR = 200000000000, r#BAZ = 200000000001, } } pub(crate) mod mangled { pub use super::r#LongEnum as _7_android_4_aidl_5_tests_8_LongEnum; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_Lo0100644 0000000 0000000 00000000034 15172120304 033307 xustar000000000 0000000 28 mtime=1776853188.6710000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/LongEnum.rs.d0100644 0000000 0000000 00000000255 15172120304 032034 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/LongEnum.rs : \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_Ot0100644 0000000 0000000 00000000225 15172120304 033321 xustar000000000 0000000 121 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/OtherParcelableForToString.rs 28 mtime=1776853188.6710000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/OtherParcelableFor0100644 0000000 0000000 00000003403 15172120304 033144 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/OtherParcelableForToString.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub struct r#OtherParcelableForToString { pub r#field: String, } impl Default for r#OtherParcelableForToString { fn default() -> Self { Self { r#field: Default::default(), } } } impl binder::Parcelable for r#OtherParcelableForToString { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#field)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#field = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#OtherParcelableForToString); binder::impl_deserialize_for_parcelable!(r#OtherParcelableForToString); impl binder::binder_impl::ParcelableMetadata for r#OtherParcelableForToString { fn get_descriptor() -> &'static str { "android.aidl.tests.OtherParcelableForToString" } } pub(crate) mod mangled { pub use super::r#OtherParcelableForToString as _7_android_4_aidl_5_tests_26_OtherParcelableForToString; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_Ot0100644 0000000 0000000 00000000227 15172120304 033323 xustar000000000 0000000 123 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/OtherParcelableForToString.rs.d 28 mtime=1776853188.6710000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/OtherParcelableFor0100644 0000000 0000000 00000000321 15172120304 033140 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/OtherParcelableForToString.rs : \ system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_Pa0100644 0000000 0000000 00000000220 15172120304 033272 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/ParcelableForToString.rs 28 mtime=1776853188.6710000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/ParcelableForToStr0100644 0000000 0000000 00000015115 15172120304 033141 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/ParcelableForToString.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/ParcelableForToString.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub struct r#ParcelableForToString { pub r#intValue: i32, pub r#intArray: Vec, pub r#longValue: i64, pub r#longArray: Vec, pub r#doubleValue: f64, pub r#doubleArray: Vec, pub r#floatValue: f32, pub r#floatArray: Vec, pub r#byteValue: i8, pub r#byteArray: Vec, pub r#booleanValue: bool, pub r#booleanArray: Vec, pub r#stringValue: String, pub r#stringArray: Vec, pub r#stringList: Vec, pub r#parcelableValue: crate::mangled::_7_android_4_aidl_5_tests_26_OtherParcelableForToString, pub r#parcelableArray: Vec, pub r#enumValue: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum, pub r#enumArray: Vec, pub r#nullArray: Vec, pub r#nullList: Vec, pub r#parcelableGeneric: crate::mangled::_7_android_4_aidl_5_tests_27_GenericStructuredParcelable, pub r#unionValue: crate::mangled::_7_android_4_aidl_5_tests_5_Union, } impl Default for r#ParcelableForToString { fn default() -> Self { Self { r#intValue: 0, r#intArray: Default::default(), r#longValue: 0, r#longArray: Default::default(), r#doubleValue: 0.000000f64, r#doubleArray: Default::default(), r#floatValue: 0.000000f32, r#floatArray: Default::default(), r#byteValue: 0, r#byteArray: Default::default(), r#booleanValue: false, r#booleanArray: Default::default(), r#stringValue: Default::default(), r#stringArray: Default::default(), r#stringList: Default::default(), r#parcelableValue: Default::default(), r#parcelableArray: Default::default(), r#enumValue: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum::FOO, r#enumArray: Default::default(), r#nullArray: Default::default(), r#nullList: Default::default(), r#parcelableGeneric: Default::default(), r#unionValue: Default::default(), } } } impl binder::Parcelable for r#ParcelableForToString { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#intValue)?; subparcel.write(&self.r#intArray)?; subparcel.write(&self.r#longValue)?; subparcel.write(&self.r#longArray)?; subparcel.write(&self.r#doubleValue)?; subparcel.write(&self.r#doubleArray)?; subparcel.write(&self.r#floatValue)?; subparcel.write(&self.r#floatArray)?; subparcel.write(&self.r#byteValue)?; subparcel.write(&self.r#byteArray)?; subparcel.write(&self.r#booleanValue)?; subparcel.write(&self.r#booleanArray)?; subparcel.write(&self.r#stringValue)?; subparcel.write(&self.r#stringArray)?; subparcel.write(&self.r#stringList)?; subparcel.write(&self.r#parcelableValue)?; subparcel.write(&self.r#parcelableArray)?; subparcel.write(&self.r#enumValue)?; subparcel.write(&self.r#enumArray)?; subparcel.write(&self.r#nullArray)?; subparcel.write(&self.r#nullList)?; subparcel.write(&self.r#parcelableGeneric)?; subparcel.write(&self.r#unionValue)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#intValue = subparcel.read()?; } if subparcel.has_more_data() { self.r#intArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#longValue = subparcel.read()?; } if subparcel.has_more_data() { self.r#longArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#doubleValue = subparcel.read()?; } if subparcel.has_more_data() { self.r#doubleArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#floatValue = subparcel.read()?; } if subparcel.has_more_data() { self.r#floatArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#byteValue = subparcel.read()?; } if subparcel.has_more_data() { self.r#byteArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#booleanValue = subparcel.read()?; } if subparcel.has_more_data() { self.r#booleanArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#stringValue = subparcel.read()?; } if subparcel.has_more_data() { self.r#stringArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#stringList = subparcel.read()?; } if subparcel.has_more_data() { self.r#parcelableValue = subparcel.read()?; } if subparcel.has_more_data() { self.r#parcelableArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#enumValue = subparcel.read()?; } if subparcel.has_more_data() { self.r#enumArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#nullArray = subparcel.read()?; } if subparcel.has_more_data() { self.r#nullList = subparcel.read()?; } if subparcel.has_more_data() { self.r#parcelableGeneric = subparcel.read()?; } if subparcel.has_more_data() { self.r#unionValue = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#ParcelableForToString); binder::impl_deserialize_for_parcelable!(r#ParcelableForToString); impl binder::binder_impl::ParcelableMetadata for r#ParcelableForToString { fn get_descriptor() -> &'static str { "android.aidl.tests.ParcelableForToString" } } pub(crate) mod mangled { pub use super::r#ParcelableForToString as _7_android_4_aidl_5_tests_21_ParcelableForToString; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_Pa0100644 0000000 0000000 00000000222 15172120304 033274 xustar000000000 0000000 118 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/ParcelableForToString.rs.d 28 mtime=1776853188.6710000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/ParcelableForToStr0100644 0000000 0000000 00000001352 15172120304 033137 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/ParcelableForToString.rs : \ system/tools/aidl/tests/android/aidl/tests/ParcelableForToString.aidl \ system/tools/aidl/tests/android/aidl/tests/GenericStructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/OtherParcelableForToString.aidl \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_Re0100644 0000000 0000000 00000000034 15172120304 033303 xustar000000000 0000000 28 mtime=1776853188.6710000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/RecursiveList.rs0100644 0000000 0000000 00000003525 15172120304 032674 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/RecursiveList.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub struct r#RecursiveList { pub r#value: i32, pub r#next: Option>, } impl Default for r#RecursiveList { fn default() -> Self { Self { r#value: 0, r#next: Default::default(), } } } impl binder::Parcelable for r#RecursiveList { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#value)?; subparcel.write(&self.r#next)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#value = subparcel.read()?; } if subparcel.has_more_data() { self.r#next = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#RecursiveList); binder::impl_deserialize_for_parcelable!(r#RecursiveList); impl binder::binder_impl::ParcelableMetadata for r#RecursiveList { fn get_descriptor() -> &'static str { "android.aidl.tests.RecursiveList" } } pub(crate) mod mangled { pub use super::r#RecursiveList as _7_android_4_aidl_5_tests_13_RecursiveList; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_Re0100644 0000000 0000000 00000000212 15172120304 033301 xustar000000000 0000000 110 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/RecursiveList.rs.d 28 mtime=1776853188.6710000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/RecursiveList.rs.d0100644 0000000 0000000 00000000267 15172120304 033116 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/RecursiveList.rs : \ system/tools/aidl/tests/android/aidl/tests/RecursiveList.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_St0100644 0000000 0000000 00000000217 15172120304 033326 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/StructuredParcelable.rs 28 mtime=1776853188.6720000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/StructuredParcelab0100644 0000000 0000000 00000036674 15172120304 033257 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/StructuredParcelable.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug, Clone, PartialEq)] pub struct r#StructuredParcelable { pub r#shouldContainThreeFs: Vec, pub r#f: i32, pub r#shouldBeJerry: String, pub r#shouldBeByteBar: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum, pub r#shouldBeIntBar: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum, pub r#shouldBeLongBar: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum, pub r#shouldContainTwoByteFoos: Vec, pub r#shouldContainTwoIntFoos: Vec, pub r#shouldContainTwoLongFoos: Vec, pub r#stringDefaultsToFoo: String, pub r#byteDefaultsToFour: i8, pub r#intDefaultsToFive: i32, pub r#longDefaultsToNegativeSeven: i64, pub r#booleanDefaultsToTrue: bool, pub r#charDefaultsToC: u16, pub r#floatDefaultsToPi: f32, pub r#doubleWithDefault: f64, pub r#arrayDefaultsTo123: Vec, pub r#arrayDefaultsToEmpty: Vec, pub r#boolDefault: bool, pub r#byteDefault: i8, pub r#intDefault: i32, pub r#longDefault: i64, pub r#floatDefault: f32, pub r#doubleDefault: f64, pub r#checkDoubleFromFloat: f64, pub r#checkStringArray1: Vec, pub r#checkStringArray2: Vec, pub r#int32_min: i32, pub r#int32_max: i32, pub r#int64_max: i64, pub r#hexInt32_neg_1: i32, pub r#ibinder: Option, pub r#empty: crate::mangled::_7_android_4_aidl_5_tests_20_StructuredParcelable_5_Empty, pub r#int8_1: Vec, pub r#int32_1: Vec, pub r#int64_1: Vec, pub r#hexInt32_pos_1: i32, pub r#hexInt64_pos_1: i32, pub r#const_exprs_1: crate::mangled::_7_android_4_aidl_5_tests_22_ConstantExpressionEnum, pub r#const_exprs_2: crate::mangled::_7_android_4_aidl_5_tests_22_ConstantExpressionEnum, pub r#const_exprs_3: crate::mangled::_7_android_4_aidl_5_tests_22_ConstantExpressionEnum, pub r#const_exprs_4: crate::mangled::_7_android_4_aidl_5_tests_22_ConstantExpressionEnum, pub r#const_exprs_5: crate::mangled::_7_android_4_aidl_5_tests_22_ConstantExpressionEnum, pub r#const_exprs_6: crate::mangled::_7_android_4_aidl_5_tests_22_ConstantExpressionEnum, pub r#const_exprs_7: crate::mangled::_7_android_4_aidl_5_tests_22_ConstantExpressionEnum, pub r#const_exprs_8: crate::mangled::_7_android_4_aidl_5_tests_22_ConstantExpressionEnum, pub r#const_exprs_9: crate::mangled::_7_android_4_aidl_5_tests_22_ConstantExpressionEnum, pub r#const_exprs_10: crate::mangled::_7_android_4_aidl_5_tests_22_ConstantExpressionEnum, pub r#addString1: String, pub r#addString2: String, pub r#shouldSetBit0AndBit2: i32, pub r#u: Option, pub r#shouldBeConstS1: Option, pub r#defaultWithFoo: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum, } pub const r#BIT0: i32 = 1; pub const r#BIT1: i32 = 2; pub const r#BIT2: i32 = 4; impl Default for r#StructuredParcelable { fn default() -> Self { Self { r#shouldContainThreeFs: Default::default(), r#f: 0, r#shouldBeJerry: Default::default(), r#shouldBeByteBar: Default::default(), r#shouldBeIntBar: Default::default(), r#shouldBeLongBar: Default::default(), r#shouldContainTwoByteFoos: Default::default(), r#shouldContainTwoIntFoos: Default::default(), r#shouldContainTwoLongFoos: Default::default(), r#stringDefaultsToFoo: "foo".into(), r#byteDefaultsToFour: 4, r#intDefaultsToFive: 5, r#longDefaultsToNegativeSeven: -7, r#booleanDefaultsToTrue: true, r#charDefaultsToC: 'C' as u16, r#floatDefaultsToPi: 3.140000f32, r#doubleWithDefault: -314000000000000000.000000f64, r#arrayDefaultsTo123: vec![1, 2, 3], r#arrayDefaultsToEmpty: vec![], r#boolDefault: false, r#byteDefault: 0, r#intDefault: 0, r#longDefault: 0, r#floatDefault: 0.000000f32, r#doubleDefault: 0.000000f64, r#checkDoubleFromFloat: 3.140000f64, r#checkStringArray1: vec!["a".into(), "b".into()], r#checkStringArray2: vec!["a".into(), "b".into()], r#int32_min: -2147483648, r#int32_max: 2147483647, r#int64_max: 9223372036854775807, r#hexInt32_neg_1: -1, r#ibinder: Default::default(), r#empty: Default::default(), r#int8_1: vec![1, 1, 1, 1, 1], r#int32_1: vec![1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], r#int64_1: vec![1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], r#hexInt32_pos_1: 1, r#hexInt64_pos_1: 1, r#const_exprs_1: Default::default(), r#const_exprs_2: Default::default(), r#const_exprs_3: Default::default(), r#const_exprs_4: Default::default(), r#const_exprs_5: Default::default(), r#const_exprs_6: Default::default(), r#const_exprs_7: Default::default(), r#const_exprs_8: Default::default(), r#const_exprs_9: Default::default(), r#const_exprs_10: Default::default(), r#addString1: "hello world!".into(), r#addString2: "The quick brown fox jumps over the lazy dog.".into(), r#shouldSetBit0AndBit2: 0, r#u: Default::default(), r#shouldBeConstS1: Default::default(), r#defaultWithFoo: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum::FOO, } } } impl binder::Parcelable for r#StructuredParcelable { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#shouldContainThreeFs)?; subparcel.write(&self.r#f)?; subparcel.write(&self.r#shouldBeJerry)?; subparcel.write(&self.r#shouldBeByteBar)?; subparcel.write(&self.r#shouldBeIntBar)?; subparcel.write(&self.r#shouldBeLongBar)?; subparcel.write(&self.r#shouldContainTwoByteFoos)?; subparcel.write(&self.r#shouldContainTwoIntFoos)?; subparcel.write(&self.r#shouldContainTwoLongFoos)?; subparcel.write(&self.r#stringDefaultsToFoo)?; subparcel.write(&self.r#byteDefaultsToFour)?; subparcel.write(&self.r#intDefaultsToFive)?; subparcel.write(&self.r#longDefaultsToNegativeSeven)?; subparcel.write(&self.r#booleanDefaultsToTrue)?; subparcel.write(&self.r#charDefaultsToC)?; subparcel.write(&self.r#floatDefaultsToPi)?; subparcel.write(&self.r#doubleWithDefault)?; subparcel.write(&self.r#arrayDefaultsTo123)?; subparcel.write(&self.r#arrayDefaultsToEmpty)?; subparcel.write(&self.r#boolDefault)?; subparcel.write(&self.r#byteDefault)?; subparcel.write(&self.r#intDefault)?; subparcel.write(&self.r#longDefault)?; subparcel.write(&self.r#floatDefault)?; subparcel.write(&self.r#doubleDefault)?; subparcel.write(&self.r#checkDoubleFromFloat)?; subparcel.write(&self.r#checkStringArray1)?; subparcel.write(&self.r#checkStringArray2)?; subparcel.write(&self.r#int32_min)?; subparcel.write(&self.r#int32_max)?; subparcel.write(&self.r#int64_max)?; subparcel.write(&self.r#hexInt32_neg_1)?; subparcel.write(&self.r#ibinder)?; subparcel.write(&self.r#empty)?; subparcel.write(&self.r#int8_1)?; subparcel.write(&self.r#int32_1)?; subparcel.write(&self.r#int64_1)?; subparcel.write(&self.r#hexInt32_pos_1)?; subparcel.write(&self.r#hexInt64_pos_1)?; subparcel.write(&self.r#const_exprs_1)?; subparcel.write(&self.r#const_exprs_2)?; subparcel.write(&self.r#const_exprs_3)?; subparcel.write(&self.r#const_exprs_4)?; subparcel.write(&self.r#const_exprs_5)?; subparcel.write(&self.r#const_exprs_6)?; subparcel.write(&self.r#const_exprs_7)?; subparcel.write(&self.r#const_exprs_8)?; subparcel.write(&self.r#const_exprs_9)?; subparcel.write(&self.r#const_exprs_10)?; subparcel.write(&self.r#addString1)?; subparcel.write(&self.r#addString2)?; subparcel.write(&self.r#shouldSetBit0AndBit2)?; subparcel.write(&self.r#u)?; subparcel.write(&self.r#shouldBeConstS1)?; subparcel.write(&self.r#defaultWithFoo)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#shouldContainThreeFs = subparcel.read()?; } if subparcel.has_more_data() { self.r#f = subparcel.read()?; } if subparcel.has_more_data() { self.r#shouldBeJerry = subparcel.read()?; } if subparcel.has_more_data() { self.r#shouldBeByteBar = subparcel.read()?; } if subparcel.has_more_data() { self.r#shouldBeIntBar = subparcel.read()?; } if subparcel.has_more_data() { self.r#shouldBeLongBar = subparcel.read()?; } if subparcel.has_more_data() { self.r#shouldContainTwoByteFoos = subparcel.read()?; } if subparcel.has_more_data() { self.r#shouldContainTwoIntFoos = subparcel.read()?; } if subparcel.has_more_data() { self.r#shouldContainTwoLongFoos = subparcel.read()?; } if subparcel.has_more_data() { self.r#stringDefaultsToFoo = subparcel.read()?; } if subparcel.has_more_data() { self.r#byteDefaultsToFour = subparcel.read()?; } if subparcel.has_more_data() { self.r#intDefaultsToFive = subparcel.read()?; } if subparcel.has_more_data() { self.r#longDefaultsToNegativeSeven = subparcel.read()?; } if subparcel.has_more_data() { self.r#booleanDefaultsToTrue = subparcel.read()?; } if subparcel.has_more_data() { self.r#charDefaultsToC = subparcel.read()?; } if subparcel.has_more_data() { self.r#floatDefaultsToPi = subparcel.read()?; } if subparcel.has_more_data() { self.r#doubleWithDefault = subparcel.read()?; } if subparcel.has_more_data() { self.r#arrayDefaultsTo123 = subparcel.read()?; } if subparcel.has_more_data() { self.r#arrayDefaultsToEmpty = subparcel.read()?; } if subparcel.has_more_data() { self.r#boolDefault = subparcel.read()?; } if subparcel.has_more_data() { self.r#byteDefault = subparcel.read()?; } if subparcel.has_more_data() { self.r#intDefault = subparcel.read()?; } if subparcel.has_more_data() { self.r#longDefault = subparcel.read()?; } if subparcel.has_more_data() { self.r#floatDefault = subparcel.read()?; } if subparcel.has_more_data() { self.r#doubleDefault = subparcel.read()?; } if subparcel.has_more_data() { self.r#checkDoubleFromFloat = subparcel.read()?; } if subparcel.has_more_data() { self.r#checkStringArray1 = subparcel.read()?; } if subparcel.has_more_data() { self.r#checkStringArray2 = subparcel.read()?; } if subparcel.has_more_data() { self.r#int32_min = subparcel.read()?; } if subparcel.has_more_data() { self.r#int32_max = subparcel.read()?; } if subparcel.has_more_data() { self.r#int64_max = subparcel.read()?; } if subparcel.has_more_data() { self.r#hexInt32_neg_1 = subparcel.read()?; } if subparcel.has_more_data() { self.r#ibinder = subparcel.read()?; } if subparcel.has_more_data() { self.r#empty = subparcel.read()?; } if subparcel.has_more_data() { self.r#int8_1 = subparcel.read()?; } if subparcel.has_more_data() { self.r#int32_1 = subparcel.read()?; } if subparcel.has_more_data() { self.r#int64_1 = subparcel.read()?; } if subparcel.has_more_data() { self.r#hexInt32_pos_1 = subparcel.read()?; } if subparcel.has_more_data() { self.r#hexInt64_pos_1 = subparcel.read()?; } if subparcel.has_more_data() { self.r#const_exprs_1 = subparcel.read()?; } if subparcel.has_more_data() { self.r#const_exprs_2 = subparcel.read()?; } if subparcel.has_more_data() { self.r#const_exprs_3 = subparcel.read()?; } if subparcel.has_more_data() { self.r#const_exprs_4 = subparcel.read()?; } if subparcel.has_more_data() { self.r#const_exprs_5 = subparcel.read()?; } if subparcel.has_more_data() { self.r#const_exprs_6 = subparcel.read()?; } if subparcel.has_more_data() { self.r#const_exprs_7 = subparcel.read()?; } if subparcel.has_more_data() { self.r#const_exprs_8 = subparcel.read()?; } if subparcel.has_more_data() { self.r#const_exprs_9 = subparcel.read()?; } if subparcel.has_more_data() { self.r#const_exprs_10 = subparcel.read()?; } if subparcel.has_more_data() { self.r#addString1 = subparcel.read()?; } if subparcel.has_more_data() { self.r#addString2 = subparcel.read()?; } if subparcel.has_more_data() { self.r#shouldSetBit0AndBit2 = subparcel.read()?; } if subparcel.has_more_data() { self.r#u = subparcel.read()?; } if subparcel.has_more_data() { self.r#shouldBeConstS1 = subparcel.read()?; } if subparcel.has_more_data() { self.r#defaultWithFoo = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#StructuredParcelable); binder::impl_deserialize_for_parcelable!(r#StructuredParcelable); impl binder::binder_impl::ParcelableMetadata for r#StructuredParcelable { fn get_descriptor() -> &'static str { "android.aidl.tests.StructuredParcelable" } } pub mod r#Empty { #[derive(Debug, Clone, PartialEq)] pub struct r#Empty { } impl Default for r#Empty { fn default() -> Self { Self { } } } impl binder::Parcelable for r#Empty { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#Empty); binder::impl_deserialize_for_parcelable!(r#Empty); impl binder::binder_impl::ParcelableMetadata for r#Empty { fn get_descriptor() -> &'static str { "android.aidl.tests.StructuredParcelable.Empty" } } } pub(crate) mod mangled { pub use super::r#StructuredParcelable as _7_android_4_aidl_5_tests_20_StructuredParcelable; pub use super::r#Empty::r#Empty as _7_android_4_aidl_5_tests_20_StructuredParcelable_5_Empty; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_St0100644 0000000 0000000 00000000221 15172120304 033321 xustar000000000 0000000 117 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/StructuredParcelable.rs.d 28 mtime=1776853188.6720000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/StructuredParcelab0100644 0000000 0000000 00000001000 15172120304 033226 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/StructuredParcelable.rs : \ system/tools/aidl/tests/android/aidl/tests/StructuredParcelable.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/ConstantExpressionEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/Union.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_Un0100644 0000000 0000000 00000000034 15172120304 033317 xustar000000000 0000000 28 mtime=1776853188.6720000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/Union.rs0100644 0000000 0000000 00000006557 15172120304 031171 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/Union.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/Union.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug, Clone, PartialEq)] pub enum r#Union { Ns(Vec), N(i32), M(i32), S(String), Ibinder(Option), Ss(Vec), Be(crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum), } pub const r#S1: &str = "a string constant in union"; impl Default for r#Union { fn default() -> Self { Self::Ns(vec![]) } } impl binder::Parcelable for r#Union { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { match self { Self::Ns(v) => { parcel.write(&0i32)?; parcel.write(v) } Self::N(v) => { parcel.write(&1i32)?; parcel.write(v) } Self::M(v) => { parcel.write(&2i32)?; parcel.write(v) } Self::S(v) => { parcel.write(&3i32)?; parcel.write(v) } Self::Ibinder(v) => { parcel.write(&4i32)?; parcel.write(v) } Self::Ss(v) => { parcel.write(&5i32)?; parcel.write(v) } Self::Be(v) => { parcel.write(&6i32)?; parcel.write(v) } } } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { let tag: i32 = parcel.read()?; match tag { 0 => { let value: Vec = parcel.read()?; *self = Self::Ns(value); Ok(()) } 1 => { let value: i32 = parcel.read()?; *self = Self::N(value); Ok(()) } 2 => { let value: i32 = parcel.read()?; *self = Self::M(value); Ok(()) } 3 => { let value: String = parcel.read()?; *self = Self::S(value); Ok(()) } 4 => { let value: Option = parcel.read()?; *self = Self::Ibinder(value); Ok(()) } 5 => { let value: Vec = parcel.read()?; *self = Self::Ss(value); Ok(()) } 6 => { let value: crate::mangled::_7_android_4_aidl_5_tests_8_ByteEnum = parcel.read()?; *self = Self::Be(value); Ok(()) } _ => { Err(binder::StatusCode::BAD_VALUE) } } } } binder::impl_serialize_for_parcelable!(r#Union); binder::impl_deserialize_for_parcelable!(r#Union); impl binder::binder_impl::ParcelableMetadata for r#Union { fn get_descriptor() -> &'static str { "android.aidl.tests.Union" } } pub mod r#Tag { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#Tag : [i32; 7] { r#ns = 0, r#n = 1, r#m = 2, r#s = 3, r#ibinder = 4, r#ss = 5, r#be = 6, } } } pub(crate) mod mangled { pub use super::r#Union as _7_android_4_aidl_5_tests_5_Union; pub use super::r#Tag::r#Tag as _7_android_4_aidl_5_tests_5_Union_3_Tag; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_Un0100644 0000000 0000000 00000000034 15172120304 033317 xustar000000000 0000000 28 mtime=1776853188.6720000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/Union.rs.d0100644 0000000 0000000 00000000344 15172120304 031377 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/Union.rs : \ system/tools/aidl/tests/android/aidl/tests/Union.aidl \ system/tools/aidl/tests/android/aidl/tests/ByteEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_Un0100644 0000000 0000000 00000000034 15172120304 033317 xustar000000000 0000000 28 mtime=1776853188.6720000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/UnionWithFd.rs0100644 0000000 0000000 00000004416 15172120304 032267 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/UnionWithFd.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/UnionWithFd.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub enum r#UnionWithFd { Num(i32), Pfd(Option), } impl Default for r#UnionWithFd { fn default() -> Self { Self::Num(0) } } impl binder::Parcelable for r#UnionWithFd { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { match self { Self::Num(v) => { parcel.write(&0i32)?; parcel.write(v) } Self::Pfd(v) => { parcel.write(&1i32)?; let __field_ref = v.as_ref().ok_or(binder::StatusCode::UNEXPECTED_NULL)?; parcel.write(__field_ref) } } } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { let tag: i32 = parcel.read()?; match tag { 0 => { let value: i32 = parcel.read()?; *self = Self::Num(value); Ok(()) } 1 => { let value: Option = Some(parcel.read()?); *self = Self::Pfd(value); Ok(()) } _ => { Err(binder::StatusCode::BAD_VALUE) } } } } binder::impl_serialize_for_parcelable!(r#UnionWithFd); binder::impl_deserialize_for_parcelable!(r#UnionWithFd); impl binder::binder_impl::ParcelableMetadata for r#UnionWithFd { fn get_descriptor() -> &'static str { "android.aidl.tests.UnionWithFd" } } pub mod r#Tag { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#Tag : [i32; 2] { r#num = 0, r#pfd = 1, } } } pub(crate) mod mangled { pub use super::r#UnionWithFd as _7_android_4_aidl_5_tests_11_UnionWithFd; pub use super::r#Tag::r#Tag as _7_android_4_aidl_5_tests_11_UnionWithFd_3_Tag; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_Un0100644 0000000 0000000 00000000034 15172120304 033317 xustar000000000 0000000 28 mtime=1776853188.6720000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/UnionWithFd.rs.d0100644 0000000 0000000 00000000263 15172120304 032505 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/UnionWithFd.rs : \ system/tools/aidl/tests/android/aidl/tests/UnionWithFd.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_ex0100644 0000000 0000000 00000000034 15172120304 033351 xustar000000000 0000000 28 mtime=1776853188.6720000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/0040755 0000000 0000000 00000000000 15172120304 031535 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_ex0100644 0000000 0000000 00000000231 15172120304 033350 xustar000000000 0000000 125 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/ExtendableParcelable.rs 28 mtime=1776853188.6720000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/Extendab0100644 0000000 0000000 00000004757 15172120304 033224 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/ExtendableParcelable.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub struct r#ExtendableParcelable { pub r#a: i32, pub r#b: String, pub r#ext: binder::ParcelableHolder, pub r#c: i64, pub r#ext2: binder::ParcelableHolder, } impl Default for r#ExtendableParcelable { fn default() -> Self { Self { r#a: 0, r#b: Default::default(), r#ext: binder::ParcelableHolder::new(binder::binder_impl::Stability::Local), r#c: 0, r#ext2: binder::ParcelableHolder::new(binder::binder_impl::Stability::Local), } } } impl binder::Parcelable for r#ExtendableParcelable { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#a)?; subparcel.write(&self.r#b)?; subparcel.write(&self.r#ext)?; subparcel.write(&self.r#c)?; subparcel.write(&self.r#ext2)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#a = subparcel.read()?; } if subparcel.has_more_data() { self.r#b = subparcel.read()?; } if subparcel.has_more_data() { self.r#ext = subparcel.read()?; } if subparcel.has_more_data() { self.r#c = subparcel.read()?; } if subparcel.has_more_data() { self.r#ext2 = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#ExtendableParcelable); binder::impl_deserialize_for_parcelable!(r#ExtendableParcelable); impl binder::binder_impl::ParcelableMetadata for r#ExtendableParcelable { fn get_descriptor() -> &'static str { "android.aidl.tests.extension.ExtendableParcelable" } } pub(crate) mod mangled { pub use super::r#ExtendableParcelable as _7_android_4_aidl_5_tests_9_extension_20_ExtendableParcelable; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_ex0100644 0000000 0000000 00000000233 15172120304 033352 xustar000000000 0000000 127 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/ExtendableParcelable.rs.d 28 mtime=1776853188.6720000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/Extendab0100644 0000000 0000000 00000000331 15172120304 033204 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/ExtendableParcelable.rs : \ system/tools/aidl/tests/android/aidl/tests/extension/ExtendableParcelable.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_ex0100644 0000000 0000000 00000000212 15172120304 033347 xustar000000000 0000000 110 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/MyExt.rs 28 mtime=1776853188.6720000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/MyExt.rs0100644 0000000 0000000 00000003311 15172120304 033144 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/MyExt.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub struct r#MyExt { pub r#a: i32, pub r#b: String, } impl Default for r#MyExt { fn default() -> Self { Self { r#a: 0, r#b: Default::default(), } } } impl binder::Parcelable for r#MyExt { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#a)?; subparcel.write(&self.r#b)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#a = subparcel.read()?; } if subparcel.has_more_data() { self.r#b = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#MyExt); binder::impl_deserialize_for_parcelable!(r#MyExt); impl binder::binder_impl::ParcelableMetadata for r#MyExt { fn get_descriptor() -> &'static str { "android.aidl.tests.extension.MyExt" } } pub(crate) mod mangled { pub use super::r#MyExt as _7_android_4_aidl_5_tests_9_extension_5_MyExt; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_ex0100644 0000000 0000000 00000000214 15172120304 033351 xustar000000000 0000000 112 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/MyExt.rs.d 28 mtime=1776853188.6720000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/MyExt.rs0100644 0000000 0000000 00000000273 15172120304 033150 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/MyExt.rs : \ system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_ex0100644 0000000 0000000 00000000213 15172120304 033350 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/MyExt2.rs 28 mtime=1776853188.6720000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/MyExt2.r0100644 0000000 0000000 00000003663 15172120304 033055 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/MyExt2.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExt2.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub struct r#MyExt2 { pub r#a: i32, pub r#b: crate::mangled::_7_android_4_aidl_5_tests_9_extension_5_MyExt, pub r#c: String, } impl Default for r#MyExt2 { fn default() -> Self { Self { r#a: 0, r#b: Default::default(), r#c: Default::default(), } } } impl binder::Parcelable for r#MyExt2 { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#a)?; subparcel.write(&self.r#b)?; subparcel.write(&self.r#c)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#a = subparcel.read()?; } if subparcel.has_more_data() { self.r#b = subparcel.read()?; } if subparcel.has_more_data() { self.r#c = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#MyExt2); binder::impl_deserialize_for_parcelable!(r#MyExt2); impl binder::binder_impl::ParcelableMetadata for r#MyExt2 { fn get_descriptor() -> &'static str { "android.aidl.tests.extension.MyExt2" } } pub(crate) mod mangled { pub use super::r#MyExt2 as _7_android_4_aidl_5_tests_9_extension_6_MyExt2; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_ex0100644 0000000 0000000 00000000215 15172120304 033352 xustar000000000 0000000 113 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/MyExt2.rs.d 28 mtime=1776853188.6730000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/MyExt2.r0100644 0000000 0000000 00000000401 15172120304 033040 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/MyExt2.rs : \ system/tools/aidl/tests/android/aidl/tests/extension/MyExt2.aidl \ system/tools/aidl/tests/android/aidl/tests/extension/MyExt.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_ex0100644 0000000 0000000 00000000216 15172120304 033353 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/MyExtLike.rs 28 mtime=1776853188.6730000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/MyExtLik0100644 0000000 0000000 00000003365 15172120304 033172 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/MyExtLike.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/extension/MyExtLike.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub struct r#MyExtLike { pub r#a: i32, pub r#b: String, } impl Default for r#MyExtLike { fn default() -> Self { Self { r#a: 0, r#b: Default::default(), } } } impl binder::Parcelable for r#MyExtLike { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#a)?; subparcel.write(&self.r#b)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#a = subparcel.read()?; } if subparcel.has_more_data() { self.r#b = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#MyExtLike); binder::impl_deserialize_for_parcelable!(r#MyExtLike); impl binder::binder_impl::ParcelableMetadata for r#MyExtLike { fn get_descriptor() -> &'static str { "android.aidl.tests.extension.MyExtLike" } } pub(crate) mod mangled { pub use super::r#MyExtLike as _7_android_4_aidl_5_tests_9_extension_9_MyExtLike; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_ex0100644 0000000 0000000 00000000220 15172120304 033346 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/MyExtLike.rs.d 28 mtime=1776853188.6730000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/MyExtLik0100644 0000000 0000000 00000000303 15172120304 033157 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/extension/MyExtLike.rs : \ system/tools/aidl/tests/android/aidl/tests/extension/MyExtLike.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_ne0100644 0000000 0000000 00000000034 15172120304 033337 xustar000000000 0000000 28 mtime=1776853188.6730000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/nested/0040755 0000000 0000000 00000000000 15172120304 031003 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_ne0100644 0000000 0000000 00000000216 15172120304 033341 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/nested/DeeplyNested.rs 28 mtime=1776853188.6730000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/nested/DeeplyNeste0100644 0000000 0000000 00000013503 15172120304 033146 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/nested/DeeplyNested.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/DeeplyNested.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub struct r#DeeplyNested { } impl Default for r#DeeplyNested { fn default() -> Self { Self { } } } impl binder::Parcelable for r#DeeplyNested { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#DeeplyNested); binder::impl_deserialize_for_parcelable!(r#DeeplyNested); impl binder::binder_impl::ParcelableMetadata for r#DeeplyNested { fn get_descriptor() -> &'static str { "android.aidl.tests.nested.DeeplyNested" } } pub mod r#A { #[derive(Debug)] pub struct r#A { pub r#e: crate::mangled::_7_android_4_aidl_5_tests_6_nested_12_DeeplyNested_1_B_1_C_1_D_1_E, } impl Default for r#A { fn default() -> Self { Self { r#e: crate::mangled::_7_android_4_aidl_5_tests_6_nested_12_DeeplyNested_1_B_1_C_1_D_1_E::OK, } } } impl binder::Parcelable for r#A { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#e)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#e = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#A); binder::impl_deserialize_for_parcelable!(r#A); impl binder::binder_impl::ParcelableMetadata for r#A { fn get_descriptor() -> &'static str { "android.aidl.tests.nested.DeeplyNested.A" } } } pub mod r#B { #[derive(Debug)] pub struct r#B { } impl Default for r#B { fn default() -> Self { Self { } } } impl binder::Parcelable for r#B { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#B); binder::impl_deserialize_for_parcelable!(r#B); impl binder::binder_impl::ParcelableMetadata for r#B { fn get_descriptor() -> &'static str { "android.aidl.tests.nested.DeeplyNested.B" } } pub mod r#C { #[derive(Debug)] pub struct r#C { } impl Default for r#C { fn default() -> Self { Self { } } } impl binder::Parcelable for r#C { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#C); binder::impl_deserialize_for_parcelable!(r#C); impl binder::binder_impl::ParcelableMetadata for r#C { fn get_descriptor() -> &'static str { "android.aidl.tests.nested.DeeplyNested.B.C" } } pub mod r#D { #[derive(Debug)] pub struct r#D { } impl Default for r#D { fn default() -> Self { Self { } } } impl binder::Parcelable for r#D { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#D); binder::impl_deserialize_for_parcelable!(r#D); impl binder::binder_impl::ParcelableMetadata for r#D { fn get_descriptor() -> &'static str { "android.aidl.tests.nested.DeeplyNested.B.C.D" } } pub mod r#E { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#E : [i8; 1] { r#OK = 0, } } } } } } pub(crate) mod mangled { pub use super::r#DeeplyNested as _7_android_4_aidl_5_tests_6_nested_12_DeeplyNested; pub use super::r#A::r#A as _7_android_4_aidl_5_tests_6_nested_12_DeeplyNested_1_A; pub use super::r#B::r#B as _7_android_4_aidl_5_tests_6_nested_12_DeeplyNested_1_B; pub use super::r#B::r#C::r#C as _7_android_4_aidl_5_tests_6_nested_12_DeeplyNested_1_B_1_C; pub use super::r#B::r#C::r#D::r#D as _7_android_4_aidl_5_tests_6_nested_12_DeeplyNested_1_B_1_C_1_D; pub use super::r#B::r#C::r#D::r#E::r#E as _7_android_4_aidl_5_tests_6_nested_12_DeeplyNested_1_B_1_C_1_D_1_E; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_ne0100644 0000000 0000000 00000000220 15172120304 033334 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/nested/DeeplyNested.rs.d 28 mtime=1776853188.6730000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/nested/DeeplyNeste0100644 0000000 0000000 00000000303 15172120304 033140 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/nested/DeeplyNested.rs : \ system/tools/aidl/tests/android/aidl/tests/nested/DeeplyNested.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_ne0100644 0000000 0000000 00000000220 15172120304 033334 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/nested/INestedService.rs 28 mtime=1776853188.6730000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/nested/INestedServ0100644 0000000 0000000 00000052107 15172120304 033123 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/nested/INestedService.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/INestedService.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { INestedService["android.aidl.tests.nested.INestedService"] { native: BnNestedService(on_transact), proxy: BpNestedService { }, async: INestedServiceAsync, } } pub trait INestedService: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.nested.INestedService" } fn r#flipStatus(&self, _arg_p: &crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested) -> binder::Result; fn r#flipStatusWithCallback(&self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status, _arg_cb: &binder::Strong) -> binder::Result<()>; fn getDefaultImpl() -> INestedServiceDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: INestedServiceDefaultRef) -> INestedServiceDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait INestedServiceAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.nested.INestedService" } fn r#flipStatus<'a>(&'a self, _arg_p: &'a crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested) -> binder::BoxFuture<'a, binder::Result>; fn r#flipStatusWithCallback<'a>(&'a self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status, _arg_cb: &'a binder::Strong) -> binder::BoxFuture<'a, binder::Result<()>>; } #[::async_trait::async_trait] pub trait INestedServiceAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.nested.INestedService" } async fn r#flipStatus(&self, _arg_p: &crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested) -> binder::Result; async fn r#flipStatusWithCallback(&self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status, _arg_cb: &binder::Strong) -> binder::Result<()>; } impl BnNestedService { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: INestedServiceAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl INestedService for Wrapper where T: INestedServiceAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#flipStatus(&self, _arg_p: &crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested) -> binder::Result { self._rt.block_on(self._inner.r#flipStatus(_arg_p)) } fn r#flipStatusWithCallback(&self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status, _arg_cb: &binder::Strong) -> binder::Result<()> { self._rt.block_on(self._inner.r#flipStatusWithCallback(_arg_status, _arg_cb)) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait INestedServiceDefault: Send + Sync { fn r#flipStatus(&self, _arg_p: &crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#flipStatusWithCallback(&self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status, _arg_cb: &binder::Strong) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#flipStatus: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; pub const r#flipStatusWithCallback: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 1; } pub type INestedServiceDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); impl BpNestedService { fn build_parcel_flipStatus(&self, _arg_p: &crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_p)?; Ok(aidl_data) } fn read_response_flipStatus(&self, _arg_p: &crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#flipStatus(_arg_p); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_5_tests_6_nested_14_INestedService_6_Result = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_flipStatusWithCallback(&self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status, _arg_cb: &binder::Strong) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(&_arg_status)?; aidl_data.write(_arg_cb)?; Ok(aidl_data) } fn read_response_flipStatusWithCallback(&self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status, _arg_cb: &binder::Strong, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#flipStatusWithCallback(_arg_status, _arg_cb); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } Ok(()) } } impl INestedService for BpNestedService { fn r#flipStatus(&self, _arg_p: &crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested) -> binder::Result { let _aidl_data = self.build_parcel_flipStatus(_arg_p)?; let _aidl_reply = self.binder.submit_transact(transactions::r#flipStatus, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_flipStatus(_arg_p, _aidl_reply) } fn r#flipStatusWithCallback(&self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status, _arg_cb: &binder::Strong) -> binder::Result<()> { let _aidl_data = self.build_parcel_flipStatusWithCallback(_arg_status, _arg_cb)?; let _aidl_reply = self.binder.submit_transact(transactions::r#flipStatusWithCallback, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_flipStatusWithCallback(_arg_status, _arg_cb, _aidl_reply) } } impl INestedServiceAsync

for BpNestedService { fn r#flipStatus<'a>(&'a self, _arg_p: &'a crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_flipStatus(_arg_p) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#flipStatus, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_flipStatus(_arg_p, _aidl_reply) } ) } fn r#flipStatusWithCallback<'a>(&'a self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status, _arg_cb: &'a binder::Strong) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_flipStatusWithCallback(_arg_status, _arg_cb) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#flipStatusWithCallback, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_flipStatusWithCallback(_arg_status, _arg_cb, _aidl_reply) } ) } } impl INestedService for binder::binder_impl::Binder { fn r#flipStatus(&self, _arg_p: &crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested) -> binder::Result { self.0.r#flipStatus(_arg_p) } fn r#flipStatusWithCallback(&self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status, _arg_cb: &binder::Strong) -> binder::Result<()> { self.0.r#flipStatusWithCallback(_arg_status, _arg_cb) } } fn on_transact(_aidl_service: &dyn INestedService, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#flipStatus => { let _arg_p: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested = _aidl_data.read()?; let _aidl_return = _aidl_service.r#flipStatus(&_arg_p); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#flipStatusWithCallback => { let _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status = _aidl_data.read()?; let _arg_cb: binder::Strong = _aidl_data.read()?; let _aidl_return = _aidl_service.r#flipStatusWithCallback(_arg_status, &_arg_cb); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } pub mod r#Result { #[derive(Debug, PartialEq)] pub struct r#Result { pub r#status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status, } impl Default for r#Result { fn default() -> Self { Self { r#status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status::OK, } } } impl binder::Parcelable for r#Result { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#status)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#status = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#Result); binder::impl_deserialize_for_parcelable!(r#Result); impl binder::binder_impl::ParcelableMetadata for r#Result { fn get_descriptor() -> &'static str { "android.aidl.tests.nested.INestedService.Result" } } } pub mod r#ICallback { #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { ICallback["android.aidl.tests.nested.INestedService.ICallback"] { native: BnCallback(on_transact), proxy: BpCallback { }, async: ICallbackAsync, } } pub trait ICallback: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.nested.INestedService.ICallback" } fn r#done(&self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status) -> binder::Result<()>; fn getDefaultImpl() -> ICallbackDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: ICallbackDefaultRef) -> ICallbackDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait ICallbackAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.nested.INestedService.ICallback" } fn r#done<'a>(&'a self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status) -> binder::BoxFuture<'a, binder::Result<()>>; } #[::async_trait::async_trait] pub trait ICallbackAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.tests.nested.INestedService.ICallback" } async fn r#done(&self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status) -> binder::Result<()>; } impl BnCallback { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: ICallbackAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl ICallback for Wrapper where T: ICallbackAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#done(&self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status) -> binder::Result<()> { self._rt.block_on(self._inner.r#done(_arg_status)) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait ICallbackDefault: Send + Sync { fn r#done(&self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#done: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; } pub type ICallbackDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); impl BpCallback { fn build_parcel_done(&self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(&_arg_status)?; Ok(aidl_data) } fn read_response_done(&self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#done(_arg_status); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } Ok(()) } } impl ICallback for BpCallback { fn r#done(&self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status) -> binder::Result<()> { let _aidl_data = self.build_parcel_done(_arg_status)?; let _aidl_reply = self.binder.submit_transact(transactions::r#done, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_done(_arg_status, _aidl_reply) } } impl ICallbackAsync

for BpCallback { fn r#done<'a>(&'a self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_done(_arg_status) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#done, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_done(_arg_status, _aidl_reply) } ) } } impl ICallback for binder::binder_impl::Binder { fn r#done(&self, _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status) -> binder::Result<()> { self.0.r#done(_arg_status) } } fn on_transact(_aidl_service: &dyn ICallback, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#done => { let _arg_status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status = _aidl_data.read()?; let _aidl_return = _aidl_service.r#done(_arg_status); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } } pub(crate) mod mangled { pub use super::r#INestedService as _7_android_4_aidl_5_tests_6_nested_14_INestedService; pub use super::r#Result::r#Result as _7_android_4_aidl_5_tests_6_nested_14_INestedService_6_Result; pub use super::r#ICallback::r#ICallback as _7_android_4_aidl_5_tests_6_nested_14_INestedService_9_ICallback; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_ne0100644 0000000 0000000 00000000222 15172120304 033336 xustar000000000 0000000 118 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/nested/INestedService.rs.d 28 mtime=1776853188.6740000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/nested/INestedServ0100644 0000000 0000000 00000000427 15172120304 033121 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/nested/INestedService.rs : \ system/tools/aidl/tests/android/aidl/tests/nested/INestedService.aidl \ system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_ne0100644 0000000 0000000 00000000226 15172120304 033342 xustar000000000 0000000 122 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/nested/ParcelableWithNested.rs 28 mtime=1776853188.6740000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/nested/ParcelableW0100644 0000000 0000000 00000004234 15172120304 033107 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/nested/ParcelableWithNested.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub struct r#ParcelableWithNested { pub r#status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status, } impl Default for r#ParcelableWithNested { fn default() -> Self { Self { r#status: crate::mangled::_7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status::OK, } } } impl binder::Parcelable for r#ParcelableWithNested { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#status)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#status = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#ParcelableWithNested); binder::impl_deserialize_for_parcelable!(r#ParcelableWithNested); impl binder::binder_impl::ParcelableMetadata for r#ParcelableWithNested { fn get_descriptor() -> &'static str { "android.aidl.tests.nested.ParcelableWithNested" } } pub mod r#Status { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#Status : [i8; 2] { r#OK = 0, r#NOT_OK = 1, } } } pub(crate) mod mangled { pub use super::r#ParcelableWithNested as _7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested; pub use super::r#Status::r#Status as _7_android_4_aidl_5_tests_6_nested_20_ParcelableWithNested_6_Status; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_ne0100644 0000000 0000000 00000000230 15172120304 033335 xustar000000000 0000000 124 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/nested/ParcelableWithNested.rs.d 28 mtime=1776853188.6740000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/nested/ParcelableW0100644 0000000 0000000 00000000323 15172120304 033102 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/nested/ParcelableWithNested.rs : \ system/tools/aidl/tests/android/aidl/tests/nested/ParcelableWithNested.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_un0100644 0000000 0000000 00000000034 15172120304 033357 xustar000000000 0000000 28 mtime=1776853188.6740000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/unions/0040755 0000000 0000000 00000000000 15172120304 031034 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_un0100644 0000000 0000000 00000000213 15172120304 033356 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/unions/EnumUnion.rs 28 mtime=1776853188.6740000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/unions/EnumUnion.r0100644 0000000 0000000 00000005410 15172120304 033131 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/unions/EnumUnion.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug, Clone, PartialEq)] pub enum r#EnumUnion { IntEnum(crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum), LongEnum(crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum), #[deprecated = "do not use this"] DeprecatedField(i32), } impl Default for r#EnumUnion { fn default() -> Self { Self::IntEnum(crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum::FOO) } } impl binder::Parcelable for r#EnumUnion { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { match self { Self::IntEnum(v) => { parcel.write(&0i32)?; parcel.write(v) } Self::LongEnum(v) => { parcel.write(&1i32)?; parcel.write(v) } Self::DeprecatedField(v) => { parcel.write(&2i32)?; parcel.write(v) } } } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { let tag: i32 = parcel.read()?; match tag { 0 => { let value: crate::mangled::_7_android_4_aidl_5_tests_7_IntEnum = parcel.read()?; *self = Self::IntEnum(value); Ok(()) } 1 => { let value: crate::mangled::_7_android_4_aidl_5_tests_8_LongEnum = parcel.read()?; *self = Self::LongEnum(value); Ok(()) } 2 => { let value: i32 = parcel.read()?; *self = Self::DeprecatedField(value); Ok(()) } _ => { Err(binder::StatusCode::BAD_VALUE) } } } } binder::impl_serialize_for_parcelable!(r#EnumUnion); binder::impl_deserialize_for_parcelable!(r#EnumUnion); impl binder::binder_impl::ParcelableMetadata for r#EnumUnion { fn get_descriptor() -> &'static str { "android.aidl.tests.unions.EnumUnion" } } pub mod r#Tag { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#Tag : [i32; 3] { r#intEnum = 0, r#longEnum = 1, #[deprecated = "do not use this"] r#deprecatedField = 2, } } } pub(crate) mod mangled { pub use super::r#EnumUnion as _7_android_4_aidl_5_tests_6_unions_9_EnumUnion; pub use super::r#Tag::r#Tag as _7_android_4_aidl_5_tests_6_unions_9_EnumUnion_3_Tag; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_un0100644 0000000 0000000 00000000215 15172120304 033360 xustar000000000 0000000 113 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/unions/EnumUnion.rs.d 28 mtime=1776853188.6740000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/unions/EnumUnion.r0100644 0000000 0000000 00000000466 15172120304 033137 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/unions/EnumUnion.rs : \ system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_un0100644 0000000 0000000 00000000216 15172120304 033361 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/unions/UnionInUnion.rs 28 mtime=1776853188.6750000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/unions/UnionInUnio0100644 0000000 0000000 00000004514 15172120304 033172 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/unions/UnionInUnion.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/tests/unions/UnionInUnion.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug, Clone, PartialEq)] pub enum r#UnionInUnion { First(crate::mangled::_7_android_4_aidl_5_tests_6_unions_9_EnumUnion), Second(i32), } impl Default for r#UnionInUnion { fn default() -> Self { Self::First(Default::default()) } } impl binder::Parcelable for r#UnionInUnion { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { match self { Self::First(v) => { parcel.write(&0i32)?; parcel.write(v) } Self::Second(v) => { parcel.write(&1i32)?; parcel.write(v) } } } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { let tag: i32 = parcel.read()?; match tag { 0 => { let value: crate::mangled::_7_android_4_aidl_5_tests_6_unions_9_EnumUnion = parcel.read()?; *self = Self::First(value); Ok(()) } 1 => { let value: i32 = parcel.read()?; *self = Self::Second(value); Ok(()) } _ => { Err(binder::StatusCode::BAD_VALUE) } } } } binder::impl_serialize_for_parcelable!(r#UnionInUnion); binder::impl_deserialize_for_parcelable!(r#UnionInUnion); impl binder::binder_impl::ParcelableMetadata for r#UnionInUnion { fn get_descriptor() -> &'static str { "android.aidl.tests.unions.UnionInUnion" } } pub mod r#Tag { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#Tag : [i32; 2] { r#first = 0, r#second = 1, } } } pub(crate) mod mangled { pub use super::r#UnionInUnion as _7_android_4_aidl_5_tests_6_unions_12_UnionInUnion; pub use super::r#Tag::r#Tag as _7_android_4_aidl_5_tests_6_unions_12_UnionInUnion_3_Tag; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_android_aidl_tests_un0100644 0000000 0000000 00000000220 15172120304 033354 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/unions/UnionInUnion.rs.d 28 mtime=1776853188.6750000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/android/aidl/tests/unions/UnionInUnio0100644 0000000 0000000 00000000601 15172120304 033163 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-interface-rust-source/gen/android/aidl/tests/unions/UnionInUnion.rs : \ system/tools/aidl/tests/android/aidl/tests/unions/UnionInUnion.aidl \ system/tools/aidl/tests/android/aidl/tests/unions/EnumUnion.aidl \ system/tools/aidl/tests/android/aidl/tests/IntEnum.aidl \ system/tools/aidl/tests/android/aidl/tests/LongEnum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-interface-rust-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 031025 xustar000000000 0000000 28 mtime=1776853188.6750000 tests/golden_output/frozen/aidl-test-interface-rust-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 025737 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-cpp-source_0100644 0000000 0000000 00000000034 15172120304 030315 xustar000000000 0000000 28 mtime=1776853188.6750000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/0040755 0000000 0000000 00000000000 15172120304 025322 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-cpp-source_gen_0100644 0000000 0000000 00000000034 15172120304 031146 xustar000000000 0000000 28 mtime=1776853188.6750000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/0040755 0000000 0000000 00000000000 15172120304 026073 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-cpp-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 032646 xustar000000000 0000000 28 mtime=1776853188.6750000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 027513 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-cpp-source_gen_android_a0100644 0000000 0000000 00000000034 15172120304 033007 xustar000000000 0000000 28 mtime=1776853188.6750000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 030424 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-cpp-source_gen_android_a0100644 0000000 0000000 00000000034 15172120304 033007 xustar000000000 0000000 28 mtime=1776853188.6750000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/versioned/0040755 0000000 0000000 00000000000 15172120304 032422 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-cpp-source_gen_android_a0100644 0000000 0000000 00000000216 15172120304 033011 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/versioned/tests/ 28 mtime=1776853188.6750000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/versioned/te0040755 0000000 0000000 00000000000 15172120304 032753 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-cpp-source_gen_android_a0100644 0000000 0000000 00000000232 15172120304 033007 xustar000000000 0000000 126 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/versioned/tests/BazUnion.cpp 28 mtime=1776853188.6750000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000004050 15172120304 032751 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl */ #include namespace android { namespace aidl { namespace versioned { namespace tests { ::android::status_t BazUnion::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_tag)) != ::android::OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case intNum: { int32_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } } return ::android::BAD_VALUE; } ::android::status_t BazUnion::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(getTag())); if (_aidl_ret_status != ::android::OK) return _aidl_ret_status; switch (getTag()) { case intNum: return _aidl_parcel->writeInt32(get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-cpp-source_gen_android_a0100644 0000000 0000000 00000000234 15172120304 033011 xustar000000000 0000000 128 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/versioned/tests/BazUnion.cpp.d 28 mtime=1776853188.6750000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000000361 15172120304 032752 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/versioned/tests/BazUnion.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-cpp-source_gen_android_a0100644 0000000 0000000 00000000225 15172120304 033011 xustar000000000 0000000 121 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/versioned/tests/Foo.cpp 28 mtime=1776853188.6750000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000004160 15172120304 032753 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl */ #include namespace android { namespace aidl { namespace versioned { namespace tests { ::android::status_t Foo::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t Foo::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-cpp-source_gen_android_a0100644 0000000 0000000 00000000227 15172120304 033013 xustar000000000 0000000 123 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/versioned/tests/Foo.cpp.d 28 mtime=1776853188.6750000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000000347 15172120304 032756 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/versioned/tests/Foo.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-cpp-source_gen_android_a0100644 0000000 0000000 00000000237 15172120304 033014 xustar000000000 0000000 131 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/versioned/tests/IFooInterface.cpp 28 mtime=1776853188.6750000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000036263 15172120304 032764 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/IFooInterface.aidl */ #include #include namespace android { namespace aidl { namespace versioned { namespace tests { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE(FooInterface, "android.aidl.versioned.tests.IFooInterface") } // namespace tests } // namespace versioned } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace versioned { namespace tests { BpFooInterface::BpFooInterface(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } ::android::binder::Status BpFooInterface::originalApi() { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::originalApi::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnFooInterface::TRANSACTION_originalApi, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) [[unlikely]] { return IFooInterface::getDefaultImpl()->originalApi(); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpFooInterface::acceptUnionAndReturnString(const ::android::aidl::versioned::tests::BazUnion& u, ::std::string* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::acceptUnionAndReturnString::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(u); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnFooInterface::TRANSACTION_acceptUnionAndReturnString, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) [[unlikely]] { return IFooInterface::getDefaultImpl()->acceptUnionAndReturnString(u, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readUtf8FromUtf16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpFooInterface::ignoreParcelablesAndRepeatInt(const ::android::aidl::versioned::tests::Foo& inFoo, ::android::aidl::versioned::tests::Foo* inoutFoo, ::android::aidl::versioned::tests::Foo* outFoo, int32_t value, int32_t* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::ignoreParcelablesAndRepeatInt::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(inFoo); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(*inoutFoo); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeInt32(value); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnFooInterface::TRANSACTION_ignoreParcelablesAndRepeatInt, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) [[unlikely]] { return IFooInterface::getDefaultImpl()->ignoreParcelablesAndRepeatInt(inFoo, inoutFoo, outFoo, value, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readInt32(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readParcelable(inoutFoo); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readParcelable(outFoo); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpFooInterface::returnsLengthOfFooArray(const ::std::vector<::android::aidl::versioned::tests::Foo>& foos, int32_t* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::returnsLengthOfFooArray::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelableVector(foos); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnFooInterface::TRANSACTION_returnsLengthOfFooArray, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) [[unlikely]] { return IFooInterface::getDefaultImpl()->returnsLengthOfFooArray(foos, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readInt32(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } int32_t BpFooInterface::getInterfaceVersion() { if (cached_version_ == -1) { ::android::Parcel data; ::android::Parcel reply; data.writeInterfaceToken(getInterfaceDescriptor()); ::android::status_t err = remote()->transact(BnFooInterface::TRANSACTION_getInterfaceVersion, data, &reply); if (err == ::android::OK) { ::android::binder::Status _aidl_status; err = _aidl_status.readFromParcel(reply); if (err == ::android::OK && _aidl_status.isOk()) { cached_version_ = reply.readInt32(); } } } return cached_version_; } std::string BpFooInterface::getInterfaceHash() { std::lock_guard lockGuard(cached_hash_mutex_); if (cached_hash_ == "-1") { ::android::Parcel data; ::android::Parcel reply; data.writeInterfaceToken(getInterfaceDescriptor()); ::android::status_t err = remote()->transact(BnFooInterface::TRANSACTION_getInterfaceHash, data, &reply); if (err == ::android::OK) { ::android::binder::Status _aidl_status; err = _aidl_status.readFromParcel(reply); if (err == ::android::OK && _aidl_status.isOk()) { reply.readUtf8FromUtf16(&cached_hash_); } } } return cached_hash_; } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace versioned { namespace tests { BnFooInterface::BnFooInterface() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t BnFooInterface::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnFooInterface::TRANSACTION_originalApi: { if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::originalApi::cppServer"); ::android::binder::Status _aidl_status(originalApi()); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; case BnFooInterface::TRANSACTION_acceptUnionAndReturnString: { ::android::aidl::versioned::tests::BazUnion in_u; ::std::string _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::acceptUnionAndReturnString::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_u); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(acceptUnionAndReturnString(in_u, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeUtf8AsUtf16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnFooInterface::TRANSACTION_ignoreParcelablesAndRepeatInt: { ::android::aidl::versioned::tests::Foo in_inFoo; ::android::aidl::versioned::tests::Foo in_inoutFoo; ::android::aidl::versioned::tests::Foo out_outFoo; int32_t in_value; int32_t _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::ignoreParcelablesAndRepeatInt::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_inFoo); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readParcelable(&in_inoutFoo); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readInt32(&in_value); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ignoreParcelablesAndRepeatInt(in_inFoo, &in_inoutFoo, &out_outFoo, in_value, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeInt32(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(in_inoutFoo); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(out_outFoo); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnFooInterface::TRANSACTION_returnsLengthOfFooArray: { ::std::vector<::android::aidl::versioned::tests::Foo> in_foos; int32_t _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::returnsLengthOfFooArray::cppServer"); _aidl_ret_status = _aidl_data.readParcelableVector(&in_foos); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(returnsLengthOfFooArray(in_foos, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeInt32(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnFooInterface::TRANSACTION_getInterfaceVersion: { _aidl_data.checkInterface(this); _aidl_reply->writeNoException(); _aidl_reply->writeInt32(IFooInterface::VERSION); } break; case BnFooInterface::TRANSACTION_getInterfaceHash: { _aidl_data.checkInterface(this); _aidl_reply->writeNoException(); _aidl_reply->writeUtf8AsUtf16(IFooInterface::HASH); } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } int32_t BnFooInterface::getInterfaceVersion() { return IFooInterface::VERSION; } std::string BnFooInterface::getInterfaceHash() { return IFooInterface::HASH; } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-cpp-source_gen_android_a0100644 0000000 0000000 00000000241 15172120304 033007 xustar000000000 0000000 133 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/versioned/tests/IFooInterface.cpp.d 28 mtime=1776853188.6760000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000000712 15172120304 032752 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/android/aidl/versioned/tests/IFooInterface.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/IFooInterface.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-cpp-source_gen_include_0100644 0000000 0000000 00000000034 15172120304 032651 xustar000000000 0000000 28 mtime=1776853188.6760000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/include/0040755 0000000 0000000 00000000000 15172120304 027516 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-cpp-source_gen_include_a0100644 0000000 0000000 00000000034 15172120304 033012 xustar000000000 0000000 28 mtime=1776853188.6760000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/0040755 0000000 0000000 00000000000 15172120304 031136 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-cpp-source_gen_include_a0100644 0000000 0000000 00000000034 15172120304 033012 xustar000000000 0000000 28 mtime=1776853188.6760000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/0040755 0000000 0000000 00000000000 15172120304 032047 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-cpp-source_gen_include_a0100644 0000000 0000000 00000000220 15172120304 033007 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/versioned/ 28 mtime=1776853188.6760000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/vers0040755 0000000 0000000 00000000000 15172120304 032747 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-cpp-source_gen_include_a0100644 0000000 0000000 00000000226 15172120304 033015 xustar000000000 0000000 122 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/versioned/tests/ 28 mtime=1776853188.6760000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/vers0040755 0000000 0000000 00000000000 15172120304 032747 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-cpp-source_gen_include_a0100644 0000000 0000000 00000000240 15172120304 033011 xustar000000000 0000000 132 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/versioned/tests/BazUnion.h 28 mtime=1776853188.6760000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/vers0100644 0000000 0000000 00000012035 15172120304 032747 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace android { namespace aidl { namespace versioned { namespace tests { class BazUnion : public ::android::Parcelable { public: enum class Tag : int32_t { intNum = 0, }; // Expose tag symbols for legacy code static const inline Tag intNum = Tag::intNum; template static constexpr bool _not_self = !std::is_same_v>, BazUnion>; BazUnion() : _value(std::in_place_index(intNum)>, int32_t(0)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr BazUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit BazUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static BazUnion make(_Tp&&... _args) { return BazUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static BazUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return BazUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } inline bool operator==(const BazUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const BazUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const BazUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const BazUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const BazUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const BazUnion& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.versioned.tests.BazUnion"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream os; os << "BazUnion{"; switch (getTag()) { case intNum: os << "intNum: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant _value; }; // class BazUnion } // namespace tests } // namespace versioned } // namespace aidl } // namespace android namespace android { namespace aidl { namespace versioned { namespace tests { [[nodiscard]] static inline std::string toString(BazUnion::Tag val) { switch(val) { case BazUnion::Tag::intNum: return "intNum"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::versioned::tests::BazUnion::Tag, 1> enum_values<::android::aidl::versioned::tests::BazUnion::Tag> = { ::android::aidl::versioned::tests::BazUnion::Tag::intNum, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-cpp-source_gen_include_a0100644 0000000 0000000 00000000242 15172120304 033013 xustar000000000 0000000 134 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/versioned/tests/BnBazUnion.h 28 mtime=1776853188.6780000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/vers0100644 0000000 0000000 00000001432 15172120304 032746 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-cpp-source_gen_include_a0100644 0000000 0000000 00000000235 15172120304 033015 xustar000000000 0000000 129 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/versioned/tests/BnFoo.h 28 mtime=1776853188.6780000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/vers0100644 0000000 0000000 00000001420 15172120304 032743 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-cpp-source_gen_include_a0100644 0000000 0000000 00000000246 15172120304 033017 xustar000000000 0000000 138 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/versioned/tests/BnFooInterface.h 28 mtime=1776853188.6780000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/vers0100644 0000000 0000000 00000007224 15172120304 032753 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace versioned { namespace tests { class BnFooInterface : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_originalApi = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_acceptUnionAndReturnString = ::android::IBinder::FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_ignoreParcelablesAndRepeatInt = ::android::IBinder::FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_returnsLengthOfFooArray = ::android::IBinder::FIRST_CALL_TRANSACTION + 3; static constexpr uint32_t TRANSACTION_getInterfaceVersion = ::android::IBinder::FIRST_CALL_TRANSACTION + 16777214; static constexpr uint32_t TRANSACTION_getInterfaceHash = ::android::IBinder::FIRST_CALL_TRANSACTION + 16777213; explicit BnFooInterface(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; int32_t getInterfaceVersion(); std::string getInterfaceHash(); }; // class BnFooInterface class IFooInterfaceDelegator : public BnFooInterface { public: explicit IFooInterfaceDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status originalApi() override { return _aidl_delegate->originalApi(); } ::android::binder::Status acceptUnionAndReturnString(const ::android::aidl::versioned::tests::BazUnion& u, ::std::string* _aidl_return) override { return _aidl_delegate->acceptUnionAndReturnString(u, _aidl_return); } ::android::binder::Status ignoreParcelablesAndRepeatInt(const ::android::aidl::versioned::tests::Foo& inFoo, ::android::aidl::versioned::tests::Foo* inoutFoo, ::android::aidl::versioned::tests::Foo* outFoo, int32_t value, int32_t* _aidl_return) override { return _aidl_delegate->ignoreParcelablesAndRepeatInt(inFoo, inoutFoo, outFoo, value, _aidl_return); } ::android::binder::Status returnsLengthOfFooArray(const ::std::vector<::android::aidl::versioned::tests::Foo>& foos, int32_t* _aidl_return) override { return _aidl_delegate->returnsLengthOfFooArray(foos, _aidl_return); } int32_t getInterfaceVersion() override { int32_t _delegator_ver = BnFooInterface::getInterfaceVersion(); int32_t _impl_ver = _aidl_delegate->getInterfaceVersion(); return _delegator_ver < _impl_ver ? _delegator_ver : _impl_ver; } std::string getInterfaceHash() override { return _aidl_delegate->getInterfaceHash(); } private: ::android::sp _aidl_delegate; }; // class IFooInterfaceDelegator } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-cpp-source_gen_include_a0100644 0000000 0000000 00000000242 15172120304 033013 xustar000000000 0000000 134 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/versioned/tests/BpBazUnion.h 28 mtime=1776853188.6780000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/vers0100644 0000000 0000000 00000001432 15172120304 032746 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-cpp-source_gen_include_a0100644 0000000 0000000 00000000235 15172120304 033015 xustar000000000 0000000 129 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/versioned/tests/BpFoo.h 28 mtime=1776853188.6780000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/vers0100644 0000000 0000000 00000001420 15172120304 032743 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-cpp-source_gen_include_a0100644 0000000 0000000 00000000246 15172120304 033017 xustar000000000 0000000 138 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/versioned/tests/BpFooInterface.h 28 mtime=1776853188.6780000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/vers0100644 0000000 0000000 00000004063 15172120304 032751 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace versioned { namespace tests { class BpFooInterface : public ::android::BpInterface { public: explicit BpFooInterface(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpFooInterface() = default; ::android::binder::Status originalApi() override; ::android::binder::Status acceptUnionAndReturnString(const ::android::aidl::versioned::tests::BazUnion& u, ::std::string* _aidl_return) override; ::android::binder::Status ignoreParcelablesAndRepeatInt(const ::android::aidl::versioned::tests::Foo& inFoo, ::android::aidl::versioned::tests::Foo* inoutFoo, ::android::aidl::versioned::tests::Foo* outFoo, int32_t value, int32_t* _aidl_return) override; ::android::binder::Status returnsLengthOfFooArray(const ::std::vector<::android::aidl::versioned::tests::Foo>& foos, int32_t* _aidl_return) override; int32_t getInterfaceVersion() override; std::string getInterfaceHash() override; private: int32_t cached_version_ = -1; std::string cached_hash_ = "-1"; std::mutex cached_hash_mutex_; }; // class BpFooInterface } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-cpp-source_gen_include_a0100644 0000000 0000000 00000000233 15172120304 033013 xustar000000000 0000000 127 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/versioned/tests/Foo.h 28 mtime=1776853188.6780000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/vers0100644 0000000 0000000 00000004075 15172120304 032754 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl */ #pragma once #include #include #include #include #include namespace android { namespace aidl { namespace versioned { namespace tests { class Foo : public ::android::Parcelable { public: inline bool operator==(const Foo&) const { return std::tie() == std::tie(); } inline bool operator<(const Foo&) const { return std::tie() < std::tie(); } inline bool operator!=(const Foo& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Foo& _rhs) const { return _rhs < *this; } inline bool operator>=(const Foo& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Foo& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.versioned.tests.Foo"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "Foo{"; _aidl_os << "}"; return _aidl_os.str(); } }; // class Foo } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-cpp-source_gen_include_a0100644 0000000 0000000 00000000245 15172120304 033016 xustar000000000 0000000 137 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/versioned/tests/IFooInterface.h 28 mtime=1776853188.6780000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/include/android/aidl/vers0100644 0000000 0000000 00000007155 15172120304 032756 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include namespace android::aidl::versioned::tests { class Foo; } // namespace android::aidl::versioned::tests namespace android { namespace aidl { namespace versioned { namespace tests { class IFooInterfaceDelegator; class IFooInterface : public ::android::IInterface { public: typedef IFooInterfaceDelegator DefaultDelegator; DECLARE_META_INTERFACE(FooInterface) static inline const int32_t VERSION = 1; static inline const std::string HASH = "9e7be1859820c59d9d55dd133e71a3687b5d2e5b"; virtual ::android::binder::Status originalApi() = 0; virtual ::android::binder::Status acceptUnionAndReturnString(const ::android::aidl::versioned::tests::BazUnion& u, ::std::string* _aidl_return) = 0; virtual ::android::binder::Status ignoreParcelablesAndRepeatInt(const ::android::aidl::versioned::tests::Foo& inFoo, ::android::aidl::versioned::tests::Foo* inoutFoo, ::android::aidl::versioned::tests::Foo* outFoo, int32_t value, int32_t* _aidl_return) = 0; virtual ::android::binder::Status returnsLengthOfFooArray(const ::std::vector<::android::aidl::versioned::tests::Foo>& foos, int32_t* _aidl_return) = 0; virtual int32_t getInterfaceVersion() = 0; virtual std::string getInterfaceHash() = 0; }; // class IFooInterface class IFooInterfaceDefault : public IFooInterface { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status originalApi() override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status acceptUnionAndReturnString(const ::android::aidl::versioned::tests::BazUnion& /*u*/, ::std::string* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ignoreParcelablesAndRepeatInt(const ::android::aidl::versioned::tests::Foo& /*inFoo*/, ::android::aidl::versioned::tests::Foo* /*inoutFoo*/, ::android::aidl::versioned::tests::Foo* /*outFoo*/, int32_t /*value*/, int32_t* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status returnsLengthOfFooArray(const ::std::vector<::android::aidl::versioned::tests::Foo>& /*foos*/, int32_t* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } int32_t getInterfaceVersion() override { return 0; } std::string getInterfaceHash() override { return ""; } }; // class IFooInterfaceDefault } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-cpp-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 033072 xustar000000000 0000000 28 mtime=1776853188.6780000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-cpp-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 030004 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-java-source_0100644 0000000 0000000 00000000034 15172120304 030454 xustar000000000 0000000 28 mtime=1776853188.6790000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-java-source/0040755 0000000 0000000 00000000000 15172120304 025461 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-java-source_gen_0100644 0000000 0000000 00000000034 15172120304 031305 xustar000000000 0000000 28 mtime=1776853188.6790000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-java-source/gen/0040755 0000000 0000000 00000000000 15172120304 026232 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-java-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 033005 xustar000000000 0000000 28 mtime=1776853188.6790000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-java-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 027652 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-java-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 033005 xustar000000000 0000000 28 mtime=1776853188.6790000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 030563 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-java-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 033005 xustar000000000 0000000 28 mtime=1776853188.6790000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/0040755 0000000 0000000 00000000000 15172120304 032561 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-java-source_gen_android_0100644 0000000 0000000 00000000217 15172120304 033010 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/tests/ 28 mtime=1776853188.6790000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/t0040755 0000000 0000000 00000000000 15172120304 032745 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-java-source_gen_android_0100644 0000000 0000000 00000000234 15172120304 033007 xustar000000000 0000000 128 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/tests/BazUnion.java 28 mtime=1776853188.6790000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000005776 15172120304 032763 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --rpc --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/tests/BazUnion.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-java-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl */ package android.aidl.versioned.tests; public final class BazUnion implements android.os.Parcelable { // tags for union fields public final static int intNum = 0; // int intNum; private int _tag; private Object _value; public BazUnion() { int _value = 0; this._tag = intNum; this._value = _value; } private BazUnion(android.os.Parcel _aidl_parcel) { readFromParcel(_aidl_parcel); } private BazUnion(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public int getTag() { return _tag; } // int intNum; public static BazUnion intNum(int _value) { return new BazUnion(intNum, _value); } public int getIntNum() { _assertTag(intNum); return (int) _value; } public void setIntNum(int _value) { _set(intNum, _value); } public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public BazUnion createFromParcel(android.os.Parcel _aidl_source) { return new BazUnion(_aidl_source); } @Override public BazUnion[] newArray(int _aidl_size) { return new BazUnion[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { _aidl_parcel.writeInt(_tag); switch (_tag) { case intNum: _aidl_parcel.writeInt(getIntNum()); break; } } public void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_tag; _aidl_tag = _aidl_parcel.readInt(); switch (_aidl_tag) { case intNum: { int _aidl_value; _aidl_value = _aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } } throw new IllegalArgumentException("union: unknown tag: " + _aidl_tag); } @Override public int describeContents() { int _mask = 0; switch (getTag()) { } return _mask; } private void _assertTag(int tag) { if (getTag() != tag) { throw new IllegalStateException("bad access: " + _tagString(tag) + ", " + _tagString(getTag()) + " is available."); } } private String _tagString(int _tag) { switch (_tag) { case intNum: return "intNum"; } throw new IllegalStateException("unknown field: " + _tag); } private void _set(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public static @interface Tag { public static final int intNum = 0; } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-java-source_gen_android_0100644 0000000 0000000 00000000236 15172120304 033011 xustar000000000 0000000 130 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/tests/BazUnion.java.d 28 mtime=1776853188.6790000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000000363 15172120304 032746 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/tests/BazUnion.java : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-java-source_gen_android_0100644 0000000 0000000 00000000227 15172120304 033011 xustar000000000 0000000 123 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/tests/Foo.java 28 mtime=1776853188.6790000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000004161 15172120304 032746 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --rpc --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/tests/Foo.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-java-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl */ package android.aidl.versioned.tests; public class Foo implements android.os.Parcelable { public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public Foo createFromParcel(android.os.Parcel _aidl_source) { Foo _aidl_out = new Foo(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public Foo[] newArray(int _aidl_size) { return new Foo[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-java-source_gen_android_0100644 0000000 0000000 00000000231 15172120304 033004 xustar000000000 0000000 125 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/tests/Foo.java.d 28 mtime=1776853188.6790000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000000351 15172120304 032743 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/tests/Foo.java : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-java-source_gen_android_0100644 0000000 0000000 00000000241 15172120304 033005 xustar000000000 0000000 133 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/tests/IFooInterface.java 28 mtime=1776853188.6790000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000031054 15172120304 032747 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --rpc --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/tests/IFooInterface.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-java-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/IFooInterface.aidl */ package android.aidl.versioned.tests; public interface IFooInterface extends android.os.IInterface { /** * The version of this interface that the caller is built against. * This might be different from what {@link #getInterfaceVersion() * getInterfaceVersion} returns as that is the version of the interface * that the remote object is implementing. */ public static final int VERSION = 1; public static final String HASH = "9e7be1859820c59d9d55dd133e71a3687b5d2e5b"; /** Default implementation for IFooInterface. */ public static class Default implements android.aidl.versioned.tests.IFooInterface { @Override public void originalApi() throws android.os.RemoteException { } @Override public java.lang.String acceptUnionAndReturnString(android.aidl.versioned.tests.BazUnion u) throws android.os.RemoteException { return null; } @Override public int ignoreParcelablesAndRepeatInt(android.aidl.versioned.tests.Foo inFoo, android.aidl.versioned.tests.Foo inoutFoo, android.aidl.versioned.tests.Foo outFoo, int value) throws android.os.RemoteException { return 0; } @Override public int returnsLengthOfFooArray(android.aidl.versioned.tests.Foo[] foos) throws android.os.RemoteException { return 0; } @Override public int getInterfaceVersion() { return 0; } @Override public String getInterfaceHash() { return ""; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.versioned.tests.IFooInterface { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.versioned.tests.IFooInterface interface, * generating a proxy if needed. */ public static android.aidl.versioned.tests.IFooInterface asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.versioned.tests.IFooInterface))) { return ((android.aidl.versioned.tests.IFooInterface)iin); } return new android.aidl.versioned.tests.IFooInterface.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } else if (code == TRANSACTION_getInterfaceVersion) { reply.writeNoException(); reply.writeInt(getInterfaceVersion()); return true; } else if (code == TRANSACTION_getInterfaceHash) { reply.writeNoException(); reply.writeString(getInterfaceHash()); return true; } switch (code) { case TRANSACTION_originalApi: { this.originalApi(); reply.writeNoException(); break; } case TRANSACTION_acceptUnionAndReturnString: { android.aidl.versioned.tests.BazUnion _arg0; _arg0 = data.readTypedObject(android.aidl.versioned.tests.BazUnion.CREATOR); data.enforceNoDataAvail(); java.lang.String _result = this.acceptUnionAndReturnString(_arg0); reply.writeNoException(); reply.writeString(_result); break; } case TRANSACTION_ignoreParcelablesAndRepeatInt: { android.aidl.versioned.tests.Foo _arg0; _arg0 = data.readTypedObject(android.aidl.versioned.tests.Foo.CREATOR); android.aidl.versioned.tests.Foo _arg1; _arg1 = data.readTypedObject(android.aidl.versioned.tests.Foo.CREATOR); android.aidl.versioned.tests.Foo _arg2; _arg2 = new android.aidl.versioned.tests.Foo(); int _arg3; _arg3 = data.readInt(); data.enforceNoDataAvail(); int _result = this.ignoreParcelablesAndRepeatInt(_arg0, _arg1, _arg2, _arg3); reply.writeNoException(); reply.writeInt(_result); reply.writeTypedObject(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); reply.writeTypedObject(_arg2, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_returnsLengthOfFooArray: { android.aidl.versioned.tests.Foo[] _arg0; _arg0 = data.createTypedArray(android.aidl.versioned.tests.Foo.CREATOR); data.enforceNoDataAvail(); int _result = this.returnsLengthOfFooArray(_arg0); reply.writeNoException(); reply.writeInt(_result); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.versioned.tests.IFooInterface { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } private int mCachedVersion = -1; private String mCachedHash = "-1"; @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public void originalApi() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_originalApi, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method originalApi is unimplemented."); } _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } @Override public java.lang.String acceptUnionAndReturnString(android.aidl.versioned.tests.BazUnion u) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.lang.String _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(u, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_acceptUnionAndReturnString, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method acceptUnionAndReturnString is unimplemented."); } _reply.readException(); _result = _reply.readString(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int ignoreParcelablesAndRepeatInt(android.aidl.versioned.tests.Foo inFoo, android.aidl.versioned.tests.Foo inoutFoo, android.aidl.versioned.tests.Foo outFoo, int value) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); int _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(inFoo, 0); _data.writeTypedObject(inoutFoo, 0); _data.writeInt(value); boolean _status = mRemote.transact(Stub.TRANSACTION_ignoreParcelablesAndRepeatInt, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method ignoreParcelablesAndRepeatInt is unimplemented."); } _reply.readException(); _result = _reply.readInt(); if ((0!=_reply.readInt())) { inoutFoo.readFromParcel(_reply); } if ((0!=_reply.readInt())) { outFoo.readFromParcel(_reply); } } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int returnsLengthOfFooArray(android.aidl.versioned.tests.Foo[] foos) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); int _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedArray(foos, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_returnsLengthOfFooArray, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method returnsLengthOfFooArray is unimplemented."); } _reply.readException(); _result = _reply.readInt(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int getInterfaceVersion() throws android.os.RemoteException { if (mCachedVersion == -1) { android.os.Parcel data = android.os.Parcel.obtain(asBinder()); android.os.Parcel reply = android.os.Parcel.obtain(); try { data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getInterfaceVersion, data, reply, 0); reply.readException(); mCachedVersion = reply.readInt(); } finally { reply.recycle(); data.recycle(); } } return mCachedVersion; } @Override public synchronized String getInterfaceHash() throws android.os.RemoteException { if ("-1".equals(mCachedHash)) { android.os.Parcel data = android.os.Parcel.obtain(asBinder()); android.os.Parcel reply = android.os.Parcel.obtain(); try { data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getInterfaceHash, data, reply, 0); reply.readException(); mCachedHash = reply.readString(); } finally { reply.recycle(); data.recycle(); } } return mCachedHash; } } static final int TRANSACTION_originalApi = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); static final int TRANSACTION_acceptUnionAndReturnString = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1); static final int TRANSACTION_ignoreParcelablesAndRepeatInt = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2); static final int TRANSACTION_returnsLengthOfFooArray = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3); static final int TRANSACTION_getInterfaceVersion = (android.os.IBinder.FIRST_CALL_TRANSACTION + 16777214); static final int TRANSACTION_getInterfaceHash = (android.os.IBinder.FIRST_CALL_TRANSACTION + 16777213); } /** @hide */ public static final java.lang.String DESCRIPTOR = "android$aidl$versioned$tests$IFooInterface".replace('$', '.'); public void originalApi() throws android.os.RemoteException; public java.lang.String acceptUnionAndReturnString(android.aidl.versioned.tests.BazUnion u) throws android.os.RemoteException; public int ignoreParcelablesAndRepeatInt(android.aidl.versioned.tests.Foo inFoo, android.aidl.versioned.tests.Foo inoutFoo, android.aidl.versioned.tests.Foo outFoo, int value) throws android.os.RemoteException; public int returnsLengthOfFooArray(android.aidl.versioned.tests.Foo[] foos) throws android.os.RemoteException; public int getInterfaceVersion() throws android.os.RemoteException; public String getInterfaceHash() throws android.os.RemoteException; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-java-source_gen_android_0100644 0000000 0000000 00000000243 15172120304 033007 xustar000000000 0000000 135 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/tests/IFooInterface.java.d 28 mtime=1776853188.6800000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000000714 15172120304 032746 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-java-source/gen/android/aidl/versioned/tests/IFooInterface.java : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/IFooInterface.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-java-source_gen_timestam0100644 0000000 0000000 00000000034 15172120304 033051 xustar000000000 0000000 28 mtime=1776853188.6800000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-java-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 030143 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-ndk-source_0100644 0000000 0000000 00000000034 15172120304 030307 xustar000000000 0000000 28 mtime=1776853188.6800000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/0040755 0000000 0000000 00000000000 15172120304 025314 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-ndk-source_gen_0100644 0000000 0000000 00000000034 15172120304 031140 xustar000000000 0000000 28 mtime=1776853188.6800000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/0040755 0000000 0000000 00000000000 15172120304 026065 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-ndk-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 032640 xustar000000000 0000000 28 mtime=1776853188.6800000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 027505 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-ndk-source_gen_android_a0100644 0000000 0000000 00000000034 15172120304 033001 xustar000000000 0000000 28 mtime=1776853188.6800000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 030416 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-ndk-source_gen_android_a0100644 0000000 0000000 00000000034 15172120304 033001 xustar000000000 0000000 28 mtime=1776853188.6800000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/versioned/0040755 0000000 0000000 00000000000 15172120304 032414 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-ndk-source_gen_android_a0100644 0000000 0000000 00000000216 15172120304 033003 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/versioned/tests/ 28 mtime=1776853188.6800000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/versioned/te0040755 0000000 0000000 00000000000 15172120304 032745 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-ndk-source_gen_android_a0100644 0000000 0000000 00000000232 15172120304 033001 xustar000000000 0000000 126 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/versioned/tests/BazUnion.cpp 28 mtime=1776853188.6800000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000004252 15172120304 032747 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl */ #include "aidl/android/aidl/versioned/tests/BazUnion.h" #include namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { const char* BazUnion::descriptor = "android.aidl.versioned.tests.BazUnion"; binder_status_t BazUnion::readFromParcel(const AParcel* _parcel) { binder_status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_tag)) != STATUS_OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case intNum: { int32_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } } return STATUS_BAD_VALUE; } binder_status_t BazUnion::writeToParcel(AParcel* _parcel) const { binder_status_t _aidl_ret_status = ::ndk::AParcel_writeData(_parcel, static_cast(getTag())); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; switch (getTag()) { case intNum: return ::ndk::AParcel_writeData(_parcel, get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-ndk-source_gen_android_a0100644 0000000 0000000 00000000234 15172120304 033003 xustar000000000 0000000 128 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/versioned/tests/BazUnion.cpp.d 28 mtime=1776853188.6800000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000000361 15172120304 032744 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/versioned/tests/BazUnion.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-ndk-source_gen_android_a0100644 0000000 0000000 00000000225 15172120304 033003 xustar000000000 0000000 121 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/versioned/tests/Foo.cpp 28 mtime=1776853188.6800000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000004336 15172120304 032752 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl */ #include "aidl/android/aidl/versioned/tests/Foo.h" #include namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { const char* Foo::descriptor = "android.aidl.versioned.tests.Foo"; binder_status_t Foo::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t Foo::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-ndk-source_gen_android_a0100644 0000000 0000000 00000000227 15172120304 033005 xustar000000000 0000000 123 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/versioned/tests/Foo.cpp.d 28 mtime=1776853188.6800000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000000347 15172120304 032750 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/versioned/tests/Foo.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-ndk-source_gen_android_a0100644 0000000 0000000 00000000237 15172120304 033006 xustar000000000 0000000 131 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/versioned/tests/IFooInterface.cpp 28 mtime=1776853188.6800000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000050350 15172120304 032747 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/IFooInterface.aidl */ #include "aidl/android/aidl/versioned/tests/IFooInterface.h" #include #include #include namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { static binder_status_t _aidl_android_aidl_versioned_tests_IFooInterface_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*originalApi*/): { ::ndk::ScopedAStatus _aidl_status = _aidl_impl->originalApi(); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } case (FIRST_CALL_TRANSACTION + 1 /*acceptUnionAndReturnString*/): { ::aidl::android::aidl::versioned::tests::BazUnion in_u; std::string _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_u); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->acceptUnionAndReturnString(in_u, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 2 /*ignoreParcelablesAndRepeatInt*/): { ::aidl::android::aidl::versioned::tests::Foo in_inFoo; ::aidl::android::aidl::versioned::tests::Foo in_inoutFoo; ::aidl::android::aidl::versioned::tests::Foo out_outFoo; int32_t in_value; int32_t _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_inFoo); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_inoutFoo); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_value); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ignoreParcelablesAndRepeatInt(in_inFoo, &in_inoutFoo, &out_outFoo, in_value, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, in_inoutFoo); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_outFoo); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 3 /*returnsLengthOfFooArray*/): { std::vector<::aidl::android::aidl::versioned::tests::Foo> in_foos; int32_t _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_foos); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->returnsLengthOfFooArray(in_foos, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 16777214 /*getInterfaceVersion*/): { int32_t _aidl_return; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->getInterfaceVersion(&_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 16777213 /*getInterfaceHash*/): { std::string _aidl_return; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->getInterfaceHash(&_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_versioned_tests_IFooInterface_clazz = ::ndk::ICInterface::defineClass(IFooInterface::descriptor, _aidl_android_aidl_versioned_tests_IFooInterface_onTransact); BpFooInterface::BpFooInterface(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} BpFooInterface::~BpFooInterface() {} ::ndk::ScopedAStatus BpFooInterface::originalApi() { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*originalApi*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->originalApi(); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpFooInterface::acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& in_u, std::string* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_u); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 1 /*acceptUnionAndReturnString*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->acceptUnionAndReturnString(in_u, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpFooInterface::ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& in_inFoo, ::aidl::android::aidl::versioned::tests::Foo* in_inoutFoo, ::aidl::android::aidl::versioned::tests::Foo* out_outFoo, int32_t in_value, int32_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_inFoo); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), *in_inoutFoo); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_value); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 2 /*ignoreParcelablesAndRepeatInt*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->ignoreParcelablesAndRepeatInt(in_inFoo, in_inoutFoo, out_outFoo, in_value, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), in_inoutFoo); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_outFoo); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpFooInterface::returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& in_foos, int32_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_foos); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 3 /*returnsLengthOfFooArray*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->returnsLengthOfFooArray(in_foos, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpFooInterface::getInterfaceVersion(int32_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; if (_aidl_cached_version != -1) { *_aidl_return = _aidl_cached_version; _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); return _aidl_status; } ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 16777214 /*getInterfaceVersion*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->getInterfaceVersion(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_cached_version = *_aidl_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpFooInterface::getInterfaceHash(std::string* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; const std::lock_guard lock(_aidl_cached_hash_mutex); if (_aidl_cached_hash != "-1") { *_aidl_return = _aidl_cached_hash; _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); return _aidl_status; } ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 16777213 /*getInterfaceHash*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->getInterfaceHash(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_cached_hash = *_aidl_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } // Source for BnFooInterface BnFooInterface::BnFooInterface() {} BnFooInterface::~BnFooInterface() {} ::ndk::SpAIBinder BnFooInterface::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_versioned_tests_IFooInterface_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } ::ndk::ScopedAStatus BnFooInterface::getInterfaceVersion(int32_t* _aidl_return) { *_aidl_return = IFooInterface::version; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::ScopedAStatus BnFooInterface::getInterfaceHash(std::string* _aidl_return) { *_aidl_return = IFooInterface::hash; return ::ndk::ScopedAStatus(AStatus_newOk()); } // Source for IFooInterface const char* IFooInterface::descriptor = "android.aidl.versioned.tests.IFooInterface"; IFooInterface::IFooInterface() {} IFooInterface::~IFooInterface() {} std::shared_ptr IFooInterface::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_versioned_tests_IFooInterface_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t IFooInterface::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t IFooInterface::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = IFooInterface::fromBinder(binder); return STATUS_OK; } bool IFooInterface::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!IFooInterface::default_impl); if (impl) { IFooInterface::default_impl = impl; return true; } return false; } const std::shared_ptr& IFooInterface::getDefaultImpl() { return IFooInterface::default_impl; } std::shared_ptr IFooInterface::default_impl = nullptr; ::ndk::ScopedAStatus IFooInterfaceDefault::originalApi() { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus IFooInterfaceDefault::acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& /*in_u*/, std::string* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus IFooInterfaceDefault::ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& /*in_inFoo*/, ::aidl::android::aidl::versioned::tests::Foo* /*in_inoutFoo*/, ::aidl::android::aidl::versioned::tests::Foo* /*out_outFoo*/, int32_t /*in_value*/, int32_t* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus IFooInterfaceDefault::returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& /*in_foos*/, int32_t* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus IFooInterfaceDefault::getInterfaceVersion(int32_t* _aidl_return) { *_aidl_return = 0; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::ScopedAStatus IFooInterfaceDefault::getInterfaceHash(std::string* _aidl_return) { *_aidl_return = ""; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::SpAIBinder IFooInterfaceDefault::asBinder() { return ::ndk::SpAIBinder(); } bool IFooInterfaceDefault::isRemote() { return false; } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-ndk-source_gen_android_a0100644 0000000 0000000 00000000241 15172120304 033001 xustar000000000 0000000 133 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/versioned/tests/IFooInterface.cpp.d 28 mtime=1776853188.6810000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000000712 15172120304 032744 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/android/aidl/versioned/tests/IFooInterface.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/IFooInterface.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-ndk-source_gen_include_0100644 0000000 0000000 00000000034 15172120304 032643 xustar000000000 0000000 28 mtime=1776853188.6810000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/include/0040755 0000000 0000000 00000000000 15172120304 027510 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-ndk-source_gen_include_a0100644 0000000 0000000 00000000034 15172120304 033004 xustar000000000 0000000 28 mtime=1776853188.6810000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/0040755 0000000 0000000 00000000000 15172120304 030421 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-ndk-source_gen_include_a0100644 0000000 0000000 00000000034 15172120304 033004 xustar000000000 0000000 28 mtime=1776853188.6810000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/0040755 0000000 0000000 00000000000 15172120304 032041 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-ndk-source_gen_include_a0100644 0000000 0000000 00000000213 15172120304 033003 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl/ 28 mtime=1776853188.6810000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl0040755 0000000 0000000 00000000000 15172120304 032673 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-ndk-source_gen_include_a0100644 0000000 0000000 00000000225 15172120304 033006 xustar000000000 0000000 121 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl/versioned/ 28 mtime=1776853188.6810000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl0040755 0000000 0000000 00000000000 15172120304 032673 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-ndk-source_gen_include_a0100644 0000000 0000000 00000000233 15172120304 033005 xustar000000000 0000000 127 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl/versioned/tests/ 28 mtime=1776853188.6810000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl0040755 0000000 0000000 00000000000 15172120304 032673 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-ndk-source_gen_include_a0100644 0000000 0000000 00000000245 15172120304 033010 xustar000000000 0000000 137 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BazUnion.h 28 mtime=1776853188.6810000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl0100644 0000000 0000000 00000012233 15172120304 032673 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { class BazUnion { public: typedef std::false_type fixed_size; static const char* descriptor; enum class Tag : int32_t { intNum = 0, }; // Expose tag symbols for legacy code static const inline Tag intNum = Tag::intNum; template static constexpr bool _not_self = !std::is_same_v>, BazUnion>; BazUnion() : _value(std::in_place_index(intNum)>, int32_t(0)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr BazUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit BazUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static BazUnion make(_Tp&&... _args) { return BazUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static BazUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return BazUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } binder_status_t readFromParcel(const AParcel* _parcel); binder_status_t writeToParcel(AParcel* _parcel) const; inline bool operator==(const BazUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const BazUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const BazUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const BazUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const BazUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const BazUnion& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream os; os << "BazUnion{"; switch (getTag()) { case intNum: os << "intNum: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant _value; }; } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { [[nodiscard]] static inline std::string toString(BazUnion::Tag val) { switch(val) { case BazUnion::Tag::intNum: return "intNum"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::versioned::tests::BazUnion::Tag::intNum, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-ndk-source_gen_include_a0100644 0000000 0000000 00000000247 15172120304 033012 xustar000000000 0000000 139 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BnBazUnion.h 28 mtime=1776853188.6810000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl0100644 0000000 0000000 00000001432 15172120304 032672 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-ndk-source_gen_include_a0100644 0000000 0000000 00000000242 15172120304 033005 xustar000000000 0000000 134 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BnFoo.h 28 mtime=1776853188.6810000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl0100644 0000000 0000000 00000001420 15172120304 032667 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-ndk-source_gen_include_a0100644 0000000 0000000 00000000253 15172120304 033007 xustar000000000 0000000 143 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BnFooInterface.h 28 mtime=1776853188.6810000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl0100644 0000000 0000000 00000005765 15172120304 032707 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include "aidl/android/aidl/versioned/tests/IFooInterface.h" #include #include #ifndef __BIONIC__ #ifndef __assert2 #define __assert2(a,b,c,d) ((void)0) #endif #endif namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { class BnFooInterface : public ::ndk::BnCInterface { public: BnFooInterface(); virtual ~BnFooInterface(); ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) final; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) final; protected: ::ndk::SpAIBinder createBinder() override; private: }; class IFooInterfaceDelegator : public BnFooInterface { public: explicit IFooInterfaceDelegator(const std::shared_ptr &impl) : _impl(impl) { int32_t _impl_ver = 0; if (!impl->getInterfaceVersion(&_impl_ver).isOk()) {; __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Delegator failed to get version of the implementation."); } if (_impl_ver != IFooInterface::version) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Mismatched versions of delegator and implementation is not allowed."); } } ::ndk::ScopedAStatus originalApi() override { return _impl->originalApi(); } ::ndk::ScopedAStatus acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& in_u, std::string* _aidl_return) override { return _impl->acceptUnionAndReturnString(in_u, _aidl_return); } ::ndk::ScopedAStatus ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& in_inFoo, ::aidl::android::aidl::versioned::tests::Foo* in_inoutFoo, ::aidl::android::aidl::versioned::tests::Foo* out_outFoo, int32_t in_value, int32_t* _aidl_return) override { return _impl->ignoreParcelablesAndRepeatInt(in_inFoo, in_inoutFoo, out_outFoo, in_value, _aidl_return); } ::ndk::ScopedAStatus returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& in_foos, int32_t* _aidl_return) override { return _impl->returnsLengthOfFooArray(in_foos, _aidl_return); } protected: private: std::shared_ptr _impl; }; } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-ndk-source_gen_include_a0100644 0000000 0000000 00000000247 15172120304 033012 xustar000000000 0000000 139 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BpBazUnion.h 28 mtime=1776853188.6820000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl0100644 0000000 0000000 00000001432 15172120304 032672 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-ndk-source_gen_include_a0100644 0000000 0000000 00000000242 15172120304 033005 xustar000000000 0000000 134 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BpFoo.h 28 mtime=1776853188.6820000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl0100644 0000000 0000000 00000001420 15172120304 032667 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-ndk-source_gen_include_a0100644 0000000 0000000 00000000253 15172120304 033007 xustar000000000 0000000 143 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BpFooInterface.h 28 mtime=1776853188.6820000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl0100644 0000000 0000000 00000004125 15172120304 032674 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include "aidl/android/aidl/versioned/tests/IFooInterface.h" #include namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { class BpFooInterface : public ::ndk::BpCInterface { public: explicit BpFooInterface(const ::ndk::SpAIBinder& binder); virtual ~BpFooInterface(); ::ndk::ScopedAStatus originalApi() override; ::ndk::ScopedAStatus acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& in_u, std::string* _aidl_return) override; ::ndk::ScopedAStatus ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& in_inFoo, ::aidl::android::aidl::versioned::tests::Foo* in_inoutFoo, ::aidl::android::aidl::versioned::tests::Foo* out_outFoo, int32_t in_value, int32_t* _aidl_return) override; ::ndk::ScopedAStatus returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& in_foos, int32_t* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) override; int32_t _aidl_cached_version = -1; std::string _aidl_cached_hash = "-1"; std::mutex _aidl_cached_hash_mutex; }; } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-ndk-source_gen_include_a0100644 0000000 0000000 00000000240 15172120304 033003 xustar000000000 0000000 132 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl/versioned/tests/Foo.h 28 mtime=1776853188.6820000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl0100644 0000000 0000000 00000004245 15172120304 032677 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl */ #pragma once #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { class Foo { public: typedef std::false_type fixed_size; static const char* descriptor; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const Foo&) const { return std::tie() == std::tie(); } inline bool operator<(const Foo&) const { return std::tie() < std::tie(); } inline bool operator!=(const Foo& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Foo& _rhs) const { return _rhs < *this; } inline bool operator>=(const Foo& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Foo& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "Foo{"; _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-ndk-source_gen_include_a0100644 0000000 0000000 00000000252 15172120304 033006 xustar000000000 0000000 142 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl/versioned/tests/IFooInterface.h 28 mtime=1776853188.6820000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/include/aidl/android/aidl0100644 0000000 0000000 00000010432 15172120304 032672 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl::android::aidl::versioned::tests { class Foo; } // namespace aidl::android::aidl::versioned::tests namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { class IFooInterfaceDelegator; class IFooInterface : public ::ndk::ICInterface { public: typedef IFooInterfaceDelegator DefaultDelegator; static const char* descriptor; IFooInterface(); virtual ~IFooInterface(); static inline const int32_t version = 1; static inline const std::string hash = "9e7be1859820c59d9d55dd133e71a3687b5d2e5b"; static constexpr uint32_t TRANSACTION_originalApi = FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_acceptUnionAndReturnString = FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_ignoreParcelablesAndRepeatInt = FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_returnsLengthOfFooArray = FIRST_CALL_TRANSACTION + 3; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus originalApi() = 0; virtual ::ndk::ScopedAStatus acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& in_u, std::string* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& in_inFoo, ::aidl::android::aidl::versioned::tests::Foo* in_inoutFoo, ::aidl::android::aidl::versioned::tests::Foo* out_outFoo, int32_t in_value, int32_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& in_foos, int32_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) = 0; private: static std::shared_ptr default_impl; }; class IFooInterfaceDefault : public IFooInterface { public: ::ndk::ScopedAStatus originalApi() override; ::ndk::ScopedAStatus acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& in_u, std::string* _aidl_return) override; ::ndk::ScopedAStatus ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& in_inFoo, ::aidl::android::aidl::versioned::tests::Foo* in_inoutFoo, ::aidl::android::aidl::versioned::tests::Foo* out_outFoo, int32_t in_value, int32_t* _aidl_return) override; ::ndk::ScopedAStatus returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& in_foos, int32_t* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-ndk-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 033064 xustar000000000 0000000 28 mtime=1776853188.6820000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-ndk-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 027776 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-rust-source_0100644 0000000 0000000 00000000034 15172120304 030530 xustar000000000 0000000 28 mtime=1776853188.6820000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-rust-source/0040755 0000000 0000000 00000000000 15172120304 025535 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-rust-source_gen_0100644 0000000 0000000 00000000034 15172120304 031361 xustar000000000 0000000 28 mtime=1776853188.6820000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-rust-source/gen/0040755 0000000 0000000 00000000000 15172120304 026306 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-rust-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 033061 xustar000000000 0000000 28 mtime=1776853188.6820000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-rust-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 027726 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-rust-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 033061 xustar000000000 0000000 28 mtime=1776853188.6820000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 030637 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-rust-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 033061 xustar000000000 0000000 28 mtime=1776853188.6820000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/0040755 0000000 0000000 00000000000 15172120304 032635 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-rust-source_gen_android_0100644 0000000 0000000 00000000217 15172120304 033064 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/tests/ 28 mtime=1776853188.6820000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/t0040755 0000000 0000000 00000000000 15172120304 033021 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-rust-source_gen_android_0100644 0000000 0000000 00000000232 15172120304 033061 xustar000000000 0000000 126 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/tests/BazUnion.rs 28 mtime=1776853188.6820000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000004030 15172120304 033015 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/tests/BazUnion.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-rust-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub enum r#BazUnion { IntNum(i32), } impl Default for r#BazUnion { fn default() -> Self { Self::IntNum(0) } } impl binder::Parcelable for r#BazUnion { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { match self { Self::IntNum(v) => { parcel.write(&0i32)?; parcel.write(v) } } } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { let tag: i32 = parcel.read()?; match tag { 0 => { let value: i32 = parcel.read()?; *self = Self::IntNum(value); Ok(()) } _ => { Err(binder::StatusCode::BAD_VALUE) } } } } binder::impl_serialize_for_parcelable!(r#BazUnion); binder::impl_deserialize_for_parcelable!(r#BazUnion); impl binder::binder_impl::ParcelableMetadata for r#BazUnion { fn get_descriptor() -> &'static str { "android.aidl.versioned.tests.BazUnion" } } pub mod r#Tag { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#Tag : [i32; 1] { r#intNum = 0, } } } pub(crate) mod mangled { pub use super::r#BazUnion as _7_android_4_aidl_9_versioned_5_tests_8_BazUnion; pub use super::r#Tag::r#Tag as _7_android_4_aidl_9_versioned_5_tests_8_BazUnion_3_Tag; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-rust-source_gen_android_0100644 0000000 0000000 00000000234 15172120304 033063 xustar000000000 0000000 128 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/tests/BazUnion.rs.d 28 mtime=1776853188.6820000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000000361 15172120304 033020 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/tests/BazUnion.rs : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-rust-source_gen_android_0100644 0000000 0000000 00000000225 15172120304 033063 xustar000000000 0000000 121 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/tests/Foo.rs 28 mtime=1776853188.6820000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000002750 15172120304 033024 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/tests/Foo.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-rust-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub struct r#Foo { } impl Default for r#Foo { fn default() -> Self { Self { } } } impl binder::Parcelable for r#Foo { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#Foo); binder::impl_deserialize_for_parcelable!(r#Foo); impl binder::binder_impl::ParcelableMetadata for r#Foo { fn get_descriptor() -> &'static str { "android.aidl.versioned.tests.Foo" } } pub(crate) mod mangled { pub use super::r#Foo as _7_android_4_aidl_9_versioned_5_tests_3_Foo; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-rust-source_gen_android_0100644 0000000 0000000 00000000227 15172120304 033065 xustar000000000 0000000 123 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/tests/Foo.rs.d 28 mtime=1776853188.6820000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000000347 15172120304 033024 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/tests/Foo.rs : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-rust-source_gen_android_0100644 0000000 0000000 00000000237 15172120304 033066 xustar000000000 0000000 131 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/tests/IFooInterface.rs 28 mtime=1776853188.6830000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000063012 15172120304 033022 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust --structured --version 1 --hash 9e7be1859820c59d9d55dd133e71a3687b5d2e5b --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/tests/IFooInterface.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-rust-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/1 system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/IFooInterface.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { IFooInterface["android.aidl.versioned.tests.IFooInterface"] { native: BnFooInterface(on_transact), proxy: BpFooInterface { cached_version: std::sync::atomic::AtomicI32 = std::sync::atomic::AtomicI32::new(-1), cached_hash: std::sync::Mutex> = std::sync::Mutex::new(None) }, async: IFooInterfaceAsync, } } pub trait IFooInterface: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.versioned.tests.IFooInterface" } fn r#originalApi(&self) -> binder::Result<()>; fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result; fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result; fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result; fn r#getInterfaceVersion(&self) -> binder::Result { Ok(VERSION) } fn r#getInterfaceHash(&self) -> binder::Result { Ok(HASH.into()) } fn getDefaultImpl() -> IFooInterfaceDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: IFooInterfaceDefaultRef) -> IFooInterfaceDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait IFooInterfaceAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.versioned.tests.IFooInterface" } fn r#originalApi<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result<()>>; fn r#acceptUnionAndReturnString<'a>(&'a self, _arg_u: &'a crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::BoxFuture<'a, binder::Result>; fn r#ignoreParcelablesAndRepeatInt<'a>(&'a self, _arg_inFoo: &'a crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &'a mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &'a mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::BoxFuture<'a, binder::Result>; fn r#returnsLengthOfFooArray<'a>(&'a self, _arg_foos: &'a [crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::BoxFuture<'a, binder::Result>; fn r#getInterfaceVersion<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { Box::pin(async move { Ok(VERSION) }) } fn r#getInterfaceHash<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { Box::pin(async move { Ok(HASH.into()) }) } } #[::async_trait::async_trait] pub trait IFooInterfaceAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.versioned.tests.IFooInterface" } async fn r#originalApi(&self) -> binder::Result<()>; async fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result; async fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result; async fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result; } impl BnFooInterface { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: IFooInterfaceAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl IFooInterface for Wrapper where T: IFooInterfaceAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#originalApi(&self) -> binder::Result<()> { self._rt.block_on(self._inner.r#originalApi()) } fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result { self._rt.block_on(self._inner.r#acceptUnionAndReturnString(_arg_u)) } fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result { self._rt.block_on(self._inner.r#ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value)) } fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result { self._rt.block_on(self._inner.r#returnsLengthOfFooArray(_arg_foos)) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait IFooInterfaceDefault: Send + Sync { fn r#originalApi(&self) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#originalApi: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; pub const r#acceptUnionAndReturnString: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 1; pub const r#ignoreParcelablesAndRepeatInt: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 2; pub const r#returnsLengthOfFooArray: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 3; pub const r#getInterfaceVersion: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 16777214; pub const r#getInterfaceHash: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 16777213; } pub type IFooInterfaceDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); pub const VERSION: i32 = 1; pub const HASH: &str = "9e7be1859820c59d9d55dd133e71a3687b5d2e5b"; impl BpFooInterface { fn build_parcel_originalApi(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_originalApi(&self, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#originalApi(); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } Ok(()) } fn build_parcel_acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_u)?; Ok(aidl_data) } fn read_response_acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#acceptUnionAndReturnString(_arg_u); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: String = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_inFoo)?; aidl_data.write(_arg_inoutFoo)?; aidl_data.write(&_arg_value)?; Ok(aidl_data) } fn read_response_ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: i32 = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_inoutFoo)?; _aidl_reply.read_onto(_arg_outFoo)?; Ok(_aidl_return) } fn build_parcel_returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_foos)?; Ok(aidl_data) } fn read_response_returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo], _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#returnsLengthOfFooArray(_arg_foos); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: i32 = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_getInterfaceVersion(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_getInterfaceVersion(&self, _aidl_reply: std::result::Result) -> binder::Result { let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: i32 = _aidl_reply.read()?; self.cached_version.store(_aidl_return, std::sync::atomic::Ordering::Relaxed); Ok(_aidl_return) } fn build_parcel_getInterfaceHash(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_getInterfaceHash(&self, _aidl_reply: std::result::Result) -> binder::Result { let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: String = _aidl_reply.read()?; *self.cached_hash.lock().unwrap() = Some(_aidl_return.clone()); Ok(_aidl_return) } } impl IFooInterface for BpFooInterface { fn r#originalApi(&self) -> binder::Result<()> { let _aidl_data = self.build_parcel_originalApi()?; let _aidl_reply = self.binder.submit_transact(transactions::r#originalApi, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_originalApi(_aidl_reply) } fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result { let _aidl_data = self.build_parcel_acceptUnionAndReturnString(_arg_u)?; let _aidl_reply = self.binder.submit_transact(transactions::r#acceptUnionAndReturnString, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_acceptUnionAndReturnString(_arg_u, _aidl_reply) } fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result { let _aidl_data = self.build_parcel_ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ignoreParcelablesAndRepeatInt, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value, _aidl_reply) } fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result { let _aidl_data = self.build_parcel_returnsLengthOfFooArray(_arg_foos)?; let _aidl_reply = self.binder.submit_transact(transactions::r#returnsLengthOfFooArray, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_returnsLengthOfFooArray(_arg_foos, _aidl_reply) } fn r#getInterfaceVersion(&self) -> binder::Result { let _aidl_version = self.cached_version.load(std::sync::atomic::Ordering::Relaxed); if _aidl_version != -1 { return Ok(_aidl_version); } let _aidl_data = self.build_parcel_getInterfaceVersion()?; let _aidl_reply = self.binder.submit_transact(transactions::r#getInterfaceVersion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_getInterfaceVersion(_aidl_reply) } fn r#getInterfaceHash(&self) -> binder::Result { { let _aidl_hash_lock = self.cached_hash.lock().unwrap(); if let Some(ref _aidl_hash) = *_aidl_hash_lock { return Ok(_aidl_hash.clone()); } } let _aidl_data = self.build_parcel_getInterfaceHash()?; let _aidl_reply = self.binder.submit_transact(transactions::r#getInterfaceHash, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_getInterfaceHash(_aidl_reply) } } impl IFooInterfaceAsync

for BpFooInterface { fn r#originalApi<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_originalApi() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#originalApi, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_originalApi(_aidl_reply) } ) } fn r#acceptUnionAndReturnString<'a>(&'a self, _arg_u: &'a crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_acceptUnionAndReturnString(_arg_u) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#acceptUnionAndReturnString, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_acceptUnionAndReturnString(_arg_u, _aidl_reply) } ) } fn r#ignoreParcelablesAndRepeatInt<'a>(&'a self, _arg_inFoo: &'a crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &'a mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &'a mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ignoreParcelablesAndRepeatInt, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value, _aidl_reply) } ) } fn r#returnsLengthOfFooArray<'a>(&'a self, _arg_foos: &'a [crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_returnsLengthOfFooArray(_arg_foos) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#returnsLengthOfFooArray, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_returnsLengthOfFooArray(_arg_foos, _aidl_reply) } ) } fn r#getInterfaceVersion<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { let _aidl_version = self.cached_version.load(std::sync::atomic::Ordering::Relaxed); if _aidl_version != -1 { return Box::pin(std::future::ready(Ok(_aidl_version))); } let _aidl_data = match self.build_parcel_getInterfaceVersion() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#getInterfaceVersion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_getInterfaceVersion(_aidl_reply) } ) } fn r#getInterfaceHash<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { { let _aidl_hash_lock = self.cached_hash.lock().unwrap(); if let Some(ref _aidl_hash) = *_aidl_hash_lock { return Box::pin(std::future::ready(Ok(_aidl_hash.clone()))); } } let _aidl_data = match self.build_parcel_getInterfaceHash() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#getInterfaceHash, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_getInterfaceHash(_aidl_reply) } ) } } impl IFooInterface for binder::binder_impl::Binder { fn r#originalApi(&self) -> binder::Result<()> { self.0.r#originalApi() } fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result { self.0.r#acceptUnionAndReturnString(_arg_u) } fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result { self.0.r#ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value) } fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result { self.0.r#returnsLengthOfFooArray(_arg_foos) } fn r#getInterfaceVersion(&self) -> binder::Result { self.0.r#getInterfaceVersion() } fn r#getInterfaceHash(&self) -> binder::Result { self.0.r#getInterfaceHash() } } fn on_transact(_aidl_service: &dyn IFooInterface, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#originalApi => { let _aidl_return = _aidl_service.r#originalApi(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#acceptUnionAndReturnString => { let _arg_u: crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion = _aidl_data.read()?; let _aidl_return = _aidl_service.r#acceptUnionAndReturnString(&_arg_u); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ignoreParcelablesAndRepeatInt => { let _arg_inFoo: crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo = _aidl_data.read()?; let mut _arg_inoutFoo: crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo = _aidl_data.read()?; let mut _arg_outFoo: crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo = Default::default(); let _arg_value: i32 = _aidl_data.read()?; let _aidl_return = _aidl_service.r#ignoreParcelablesAndRepeatInt(&_arg_inFoo, &mut _arg_inoutFoo, &mut _arg_outFoo, _arg_value); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_inoutFoo)?; _aidl_reply.write(&_arg_outFoo)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#returnsLengthOfFooArray => { let _arg_foos: Vec = _aidl_data.read()?; let _aidl_return = _aidl_service.r#returnsLengthOfFooArray(&_arg_foos); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#getInterfaceVersion => { let _aidl_return = _aidl_service.r#getInterfaceVersion(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#getInterfaceHash => { let _aidl_return = _aidl_service.r#getInterfaceHash(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } pub(crate) mod mangled { pub use super::r#IFooInterface as _7_android_4_aidl_9_versioned_5_tests_13_IFooInterface; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-rust-source_gen_android_0100644 0000000 0000000 00000000241 15172120304 033061 xustar000000000 0000000 133 path=tests/golden_output/frozen/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/tests/IFooInterface.rs.d 28 mtime=1776853188.6830000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000000712 15172120304 033020 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V1-rust-source/gen/android/aidl/versioned/tests/IFooInterface.rs : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/IFooInterface.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/BazUnion.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/1/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V1-rust-source_gen_timestam0100644 0000000 0000000 00000000034 15172120304 033125 xustar000000000 0000000 28 mtime=1776853188.6830000 tests/golden_output/frozen/aidl-test-versioned-interface-V1-rust-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 030217 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-cpp-source_0100644 0000000 0000000 00000000034 15172120304 030316 xustar000000000 0000000 28 mtime=1776853188.6830000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/0040755 0000000 0000000 00000000000 15172120304 025323 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-cpp-source_gen_0100644 0000000 0000000 00000000034 15172120304 031147 xustar000000000 0000000 28 mtime=1776853188.6830000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/0040755 0000000 0000000 00000000000 15172120304 026074 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-cpp-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 032647 xustar000000000 0000000 28 mtime=1776853188.6830000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 027514 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-cpp-source_gen_android_a0100644 0000000 0000000 00000000034 15172120304 033010 xustar000000000 0000000 28 mtime=1776853188.6830000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 030425 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-cpp-source_gen_android_a0100644 0000000 0000000 00000000034 15172120304 033010 xustar000000000 0000000 28 mtime=1776853188.6830000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/versioned/0040755 0000000 0000000 00000000000 15172120304 032423 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-cpp-source_gen_android_a0100644 0000000 0000000 00000000216 15172120304 033012 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/versioned/tests/ 28 mtime=1776853188.6830000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/versioned/te0040755 0000000 0000000 00000000000 15172120304 032754 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-cpp-source_gen_android_a0100644 0000000 0000000 00000000232 15172120304 033010 xustar000000000 0000000 126 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/versioned/tests/BazUnion.cpp 28 mtime=1776853188.6830000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000004755 15172120304 032766 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl */ #include namespace android { namespace aidl { namespace versioned { namespace tests { ::android::status_t BazUnion::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_tag)) != ::android::OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case intNum: { int32_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case longNum: { int64_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt64(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } } return ::android::BAD_VALUE; } ::android::status_t BazUnion::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(getTag())); if (_aidl_ret_status != ::android::OK) return _aidl_ret_status; switch (getTag()) { case intNum: return _aidl_parcel->writeInt32(get()); case longNum: return _aidl_parcel->writeInt64(get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-cpp-source_gen_android_a0100644 0000000 0000000 00000000234 15172120304 033012 xustar000000000 0000000 128 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/versioned/tests/BazUnion.cpp.d 28 mtime=1776853188.6830000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000000361 15172120304 032753 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/versioned/tests/BazUnion.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-cpp-source_gen_android_a0100644 0000000 0000000 00000000225 15172120304 033012 xustar000000000 0000000 121 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/versioned/tests/Foo.cpp 28 mtime=1776853188.6840000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000005114 15172120304 032754 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl */ #include namespace android { namespace aidl { namespace versioned { namespace tests { ::android::status_t Foo::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&intDefault42); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t Foo::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeInt32(intDefault42); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-cpp-source_gen_android_a0100644 0000000 0000000 00000000227 15172120304 033014 xustar000000000 0000000 123 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/versioned/tests/Foo.cpp.d 28 mtime=1776853188.6840000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000000347 15172120304 032757 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/versioned/tests/Foo.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-cpp-source_gen_android_a0100644 0000000 0000000 00000000237 15172120304 033015 xustar000000000 0000000 131 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/versioned/tests/IFooInterface.cpp 28 mtime=1776853188.6840000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000041504 15172120304 032757 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/IFooInterface.aidl */ #include #include namespace android { namespace aidl { namespace versioned { namespace tests { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE(FooInterface, "android.aidl.versioned.tests.IFooInterface") } // namespace tests } // namespace versioned } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace versioned { namespace tests { BpFooInterface::BpFooInterface(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } ::android::binder::Status BpFooInterface::originalApi() { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::originalApi::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnFooInterface::TRANSACTION_originalApi, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) [[unlikely]] { return IFooInterface::getDefaultImpl()->originalApi(); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpFooInterface::acceptUnionAndReturnString(const ::android::aidl::versioned::tests::BazUnion& u, ::std::string* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::acceptUnionAndReturnString::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(u); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnFooInterface::TRANSACTION_acceptUnionAndReturnString, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) [[unlikely]] { return IFooInterface::getDefaultImpl()->acceptUnionAndReturnString(u, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readUtf8FromUtf16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpFooInterface::ignoreParcelablesAndRepeatInt(const ::android::aidl::versioned::tests::Foo& inFoo, ::android::aidl::versioned::tests::Foo* inoutFoo, ::android::aidl::versioned::tests::Foo* outFoo, int32_t value, int32_t* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::ignoreParcelablesAndRepeatInt::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(inFoo); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(*inoutFoo); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeInt32(value); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnFooInterface::TRANSACTION_ignoreParcelablesAndRepeatInt, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) [[unlikely]] { return IFooInterface::getDefaultImpl()->ignoreParcelablesAndRepeatInt(inFoo, inoutFoo, outFoo, value, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readInt32(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readParcelable(inoutFoo); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readParcelable(outFoo); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpFooInterface::returnsLengthOfFooArray(const ::std::vector<::android::aidl::versioned::tests::Foo>& foos, int32_t* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::returnsLengthOfFooArray::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelableVector(foos); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnFooInterface::TRANSACTION_returnsLengthOfFooArray, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) [[unlikely]] { return IFooInterface::getDefaultImpl()->returnsLengthOfFooArray(foos, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readInt32(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpFooInterface::newApi() { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::newApi::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnFooInterface::TRANSACTION_newApi, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) [[unlikely]] { return IFooInterface::getDefaultImpl()->newApi(); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } int32_t BpFooInterface::getInterfaceVersion() { if (cached_version_ == -1) { ::android::Parcel data; ::android::Parcel reply; data.writeInterfaceToken(getInterfaceDescriptor()); ::android::status_t err = remote()->transact(BnFooInterface::TRANSACTION_getInterfaceVersion, data, &reply); if (err == ::android::OK) { ::android::binder::Status _aidl_status; err = _aidl_status.readFromParcel(reply); if (err == ::android::OK && _aidl_status.isOk()) { cached_version_ = reply.readInt32(); } } } return cached_version_; } std::string BpFooInterface::getInterfaceHash() { std::lock_guard lockGuard(cached_hash_mutex_); if (cached_hash_ == "-1") { ::android::Parcel data; ::android::Parcel reply; data.writeInterfaceToken(getInterfaceDescriptor()); ::android::status_t err = remote()->transact(BnFooInterface::TRANSACTION_getInterfaceHash, data, &reply); if (err == ::android::OK) { ::android::binder::Status _aidl_status; err = _aidl_status.readFromParcel(reply); if (err == ::android::OK && _aidl_status.isOk()) { reply.readUtf8FromUtf16(&cached_hash_); } } } return cached_hash_; } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace versioned { namespace tests { BnFooInterface::BnFooInterface() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t BnFooInterface::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnFooInterface::TRANSACTION_originalApi: { if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::originalApi::cppServer"); ::android::binder::Status _aidl_status(originalApi()); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; case BnFooInterface::TRANSACTION_acceptUnionAndReturnString: { ::android::aidl::versioned::tests::BazUnion in_u; ::std::string _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::acceptUnionAndReturnString::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_u); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(acceptUnionAndReturnString(in_u, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeUtf8AsUtf16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnFooInterface::TRANSACTION_ignoreParcelablesAndRepeatInt: { ::android::aidl::versioned::tests::Foo in_inFoo; ::android::aidl::versioned::tests::Foo in_inoutFoo; ::android::aidl::versioned::tests::Foo out_outFoo; int32_t in_value; int32_t _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::ignoreParcelablesAndRepeatInt::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_inFoo); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readParcelable(&in_inoutFoo); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readInt32(&in_value); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ignoreParcelablesAndRepeatInt(in_inFoo, &in_inoutFoo, &out_outFoo, in_value, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeInt32(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(in_inoutFoo); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(out_outFoo); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnFooInterface::TRANSACTION_returnsLengthOfFooArray: { ::std::vector<::android::aidl::versioned::tests::Foo> in_foos; int32_t _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::returnsLengthOfFooArray::cppServer"); _aidl_ret_status = _aidl_data.readParcelableVector(&in_foos); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(returnsLengthOfFooArray(in_foos, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeInt32(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnFooInterface::TRANSACTION_newApi: { if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::newApi::cppServer"); ::android::binder::Status _aidl_status(newApi()); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; case BnFooInterface::TRANSACTION_getInterfaceVersion: { _aidl_data.checkInterface(this); _aidl_reply->writeNoException(); _aidl_reply->writeInt32(IFooInterface::VERSION); } break; case BnFooInterface::TRANSACTION_getInterfaceHash: { _aidl_data.checkInterface(this); _aidl_reply->writeNoException(); _aidl_reply->writeUtf8AsUtf16(IFooInterface::HASH); } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } int32_t BnFooInterface::getInterfaceVersion() { return IFooInterface::VERSION; } std::string BnFooInterface::getInterfaceHash() { return IFooInterface::HASH; } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-cpp-source_gen_android_a0100644 0000000 0000000 00000000241 15172120304 033010 xustar000000000 0000000 133 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/versioned/tests/IFooInterface.cpp.d 28 mtime=1776853188.6840000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000000712 15172120304 032753 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/android/aidl/versioned/tests/IFooInterface.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/IFooInterface.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-cpp-source_gen_include_0100644 0000000 0000000 00000000034 15172120304 032652 xustar000000000 0000000 28 mtime=1776853188.6840000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/include/0040755 0000000 0000000 00000000000 15172120304 027517 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-cpp-source_gen_include_a0100644 0000000 0000000 00000000034 15172120304 033013 xustar000000000 0000000 28 mtime=1776853188.6840000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/0040755 0000000 0000000 00000000000 15172120304 031137 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-cpp-source_gen_include_a0100644 0000000 0000000 00000000034 15172120304 033013 xustar000000000 0000000 28 mtime=1776853188.6840000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/0040755 0000000 0000000 00000000000 15172120304 032050 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-cpp-source_gen_include_a0100644 0000000 0000000 00000000220 15172120304 033010 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/versioned/ 28 mtime=1776853188.6840000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/vers0040755 0000000 0000000 00000000000 15172120304 032750 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-cpp-source_gen_include_a0100644 0000000 0000000 00000000226 15172120304 033016 xustar000000000 0000000 122 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/versioned/tests/ 28 mtime=1776853188.6840000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/vers0040755 0000000 0000000 00000000000 15172120304 032750 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-cpp-source_gen_include_a0100644 0000000 0000000 00000000240 15172120304 033012 xustar000000000 0000000 132 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/versioned/tests/BazUnion.h 28 mtime=1776853188.6840000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/vers0100644 0000000 0000000 00000012470 15172120304 032753 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace android { namespace aidl { namespace versioned { namespace tests { class BazUnion : public ::android::Parcelable { public: enum class Tag : int32_t { intNum = 0, longNum = 1, }; // Expose tag symbols for legacy code static const inline Tag intNum = Tag::intNum; static const inline Tag longNum = Tag::longNum; template static constexpr bool _not_self = !std::is_same_v>, BazUnion>; BazUnion() : _value(std::in_place_index(intNum)>, int32_t(0)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr BazUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit BazUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static BazUnion make(_Tp&&... _args) { return BazUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static BazUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return BazUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } inline bool operator==(const BazUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const BazUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const BazUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const BazUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const BazUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const BazUnion& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.versioned.tests.BazUnion"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream os; os << "BazUnion{"; switch (getTag()) { case intNum: os << "intNum: " << ::android::internal::ToString(get()); break; case longNum: os << "longNum: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant _value; }; // class BazUnion } // namespace tests } // namespace versioned } // namespace aidl } // namespace android namespace android { namespace aidl { namespace versioned { namespace tests { [[nodiscard]] static inline std::string toString(BazUnion::Tag val) { switch(val) { case BazUnion::Tag::intNum: return "intNum"; case BazUnion::Tag::longNum: return "longNum"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::versioned::tests::BazUnion::Tag, 2> enum_values<::android::aidl::versioned::tests::BazUnion::Tag> = { ::android::aidl::versioned::tests::BazUnion::Tag::intNum, ::android::aidl::versioned::tests::BazUnion::Tag::longNum, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-cpp-source_gen_include_a0100644 0000000 0000000 00000000242 15172120304 033014 xustar000000000 0000000 134 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/versioned/tests/BnBazUnion.h 28 mtime=1776853188.6850000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/vers0100644 0000000 0000000 00000001432 15172120304 032747 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-cpp-source_gen_include_a0100644 0000000 0000000 00000000235 15172120304 033016 xustar000000000 0000000 129 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/versioned/tests/BnFoo.h 28 mtime=1776853188.6850000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/vers0100644 0000000 0000000 00000001420 15172120304 032744 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-cpp-source_gen_include_a0100644 0000000 0000000 00000000246 15172120304 033020 xustar000000000 0000000 138 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/versioned/tests/BnFooInterface.h 28 mtime=1776853188.6850000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/vers0100644 0000000 0000000 00000007516 15172120304 032760 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace versioned { namespace tests { class BnFooInterface : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_originalApi = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_acceptUnionAndReturnString = ::android::IBinder::FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_ignoreParcelablesAndRepeatInt = ::android::IBinder::FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_returnsLengthOfFooArray = ::android::IBinder::FIRST_CALL_TRANSACTION + 3; static constexpr uint32_t TRANSACTION_newApi = ::android::IBinder::FIRST_CALL_TRANSACTION + 4; static constexpr uint32_t TRANSACTION_getInterfaceVersion = ::android::IBinder::FIRST_CALL_TRANSACTION + 16777214; static constexpr uint32_t TRANSACTION_getInterfaceHash = ::android::IBinder::FIRST_CALL_TRANSACTION + 16777213; explicit BnFooInterface(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; int32_t getInterfaceVersion(); std::string getInterfaceHash(); }; // class BnFooInterface class IFooInterfaceDelegator : public BnFooInterface { public: explicit IFooInterfaceDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status originalApi() override { return _aidl_delegate->originalApi(); } ::android::binder::Status acceptUnionAndReturnString(const ::android::aidl::versioned::tests::BazUnion& u, ::std::string* _aidl_return) override { return _aidl_delegate->acceptUnionAndReturnString(u, _aidl_return); } ::android::binder::Status ignoreParcelablesAndRepeatInt(const ::android::aidl::versioned::tests::Foo& inFoo, ::android::aidl::versioned::tests::Foo* inoutFoo, ::android::aidl::versioned::tests::Foo* outFoo, int32_t value, int32_t* _aidl_return) override { return _aidl_delegate->ignoreParcelablesAndRepeatInt(inFoo, inoutFoo, outFoo, value, _aidl_return); } ::android::binder::Status returnsLengthOfFooArray(const ::std::vector<::android::aidl::versioned::tests::Foo>& foos, int32_t* _aidl_return) override { return _aidl_delegate->returnsLengthOfFooArray(foos, _aidl_return); } ::android::binder::Status newApi() override { return _aidl_delegate->newApi(); } int32_t getInterfaceVersion() override { int32_t _delegator_ver = BnFooInterface::getInterfaceVersion(); int32_t _impl_ver = _aidl_delegate->getInterfaceVersion(); return _delegator_ver < _impl_ver ? _delegator_ver : _impl_ver; } std::string getInterfaceHash() override { return _aidl_delegate->getInterfaceHash(); } private: ::android::sp _aidl_delegate; }; // class IFooInterfaceDelegator } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-cpp-source_gen_include_a0100644 0000000 0000000 00000000242 15172120304 033014 xustar000000000 0000000 134 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/versioned/tests/BpBazUnion.h 28 mtime=1776853188.6850000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/vers0100644 0000000 0000000 00000001432 15172120304 032747 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-cpp-source_gen_include_a0100644 0000000 0000000 00000000235 15172120304 033016 xustar000000000 0000000 129 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/versioned/tests/BpFoo.h 28 mtime=1776853188.6850000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/vers0100644 0000000 0000000 00000001420 15172120304 032744 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-cpp-source_gen_include_a0100644 0000000 0000000 00000000246 15172120304 033020 xustar000000000 0000000 138 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/versioned/tests/BpFooInterface.h 28 mtime=1776853188.6850000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/vers0100644 0000000 0000000 00000004142 15172120304 032750 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace versioned { namespace tests { class BpFooInterface : public ::android::BpInterface { public: explicit BpFooInterface(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpFooInterface() = default; ::android::binder::Status originalApi() override; ::android::binder::Status acceptUnionAndReturnString(const ::android::aidl::versioned::tests::BazUnion& u, ::std::string* _aidl_return) override; ::android::binder::Status ignoreParcelablesAndRepeatInt(const ::android::aidl::versioned::tests::Foo& inFoo, ::android::aidl::versioned::tests::Foo* inoutFoo, ::android::aidl::versioned::tests::Foo* outFoo, int32_t value, int32_t* _aidl_return) override; ::android::binder::Status returnsLengthOfFooArray(const ::std::vector<::android::aidl::versioned::tests::Foo>& foos, int32_t* _aidl_return) override; ::android::binder::Status newApi() override; int32_t getInterfaceVersion() override; std::string getInterfaceHash() override; private: int32_t cached_version_ = -1; std::string cached_hash_ = "-1"; std::mutex cached_hash_mutex_; }; // class BpFooInterface } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-cpp-source_gen_include_a0100644 0000000 0000000 00000000233 15172120304 033014 xustar000000000 0000000 127 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/versioned/tests/Foo.h 28 mtime=1776853188.6850000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/vers0100644 0000000 0000000 00000004402 15172120304 032747 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl */ #pragma once #include #include #include #include #include #include namespace android { namespace aidl { namespace versioned { namespace tests { class Foo : public ::android::Parcelable { public: int32_t intDefault42 = 42; inline bool operator==(const Foo& _rhs) const { return std::tie(intDefault42) == std::tie(_rhs.intDefault42); } inline bool operator<(const Foo& _rhs) const { return std::tie(intDefault42) < std::tie(_rhs.intDefault42); } inline bool operator!=(const Foo& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Foo& _rhs) const { return _rhs < *this; } inline bool operator>=(const Foo& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Foo& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.versioned.tests.Foo"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "Foo{"; _aidl_os << "intDefault42: " << ::android::internal::ToString(intDefault42); _aidl_os << "}"; return _aidl_os.str(); } }; // class Foo } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-cpp-source_gen_include_a0100644 0000000 0000000 00000000245 15172120304 033017 xustar000000000 0000000 137 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/versioned/tests/IFooInterface.h 28 mtime=1776853188.6860000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/include/android/aidl/vers0100644 0000000 0000000 00000007446 15172120304 032762 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include namespace android::aidl::versioned::tests { class Foo; } // namespace android::aidl::versioned::tests namespace android { namespace aidl { namespace versioned { namespace tests { class IFooInterfaceDelegator; class IFooInterface : public ::android::IInterface { public: typedef IFooInterfaceDelegator DefaultDelegator; DECLARE_META_INTERFACE(FooInterface) static inline const int32_t VERSION = 2; static inline const std::string HASH = "da8c4bc94ca7feff0e0a65563a466787698b5891"; virtual ::android::binder::Status originalApi() = 0; virtual ::android::binder::Status acceptUnionAndReturnString(const ::android::aidl::versioned::tests::BazUnion& u, ::std::string* _aidl_return) = 0; virtual ::android::binder::Status ignoreParcelablesAndRepeatInt(const ::android::aidl::versioned::tests::Foo& inFoo, ::android::aidl::versioned::tests::Foo* inoutFoo, ::android::aidl::versioned::tests::Foo* outFoo, int32_t value, int32_t* _aidl_return) = 0; virtual ::android::binder::Status returnsLengthOfFooArray(const ::std::vector<::android::aidl::versioned::tests::Foo>& foos, int32_t* _aidl_return) = 0; virtual ::android::binder::Status newApi() = 0; virtual int32_t getInterfaceVersion() = 0; virtual std::string getInterfaceHash() = 0; }; // class IFooInterface class IFooInterfaceDefault : public IFooInterface { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status originalApi() override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status acceptUnionAndReturnString(const ::android::aidl::versioned::tests::BazUnion& /*u*/, ::std::string* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ignoreParcelablesAndRepeatInt(const ::android::aidl::versioned::tests::Foo& /*inFoo*/, ::android::aidl::versioned::tests::Foo* /*inoutFoo*/, ::android::aidl::versioned::tests::Foo* /*outFoo*/, int32_t /*value*/, int32_t* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status returnsLengthOfFooArray(const ::std::vector<::android::aidl::versioned::tests::Foo>& /*foos*/, int32_t* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status newApi() override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } int32_t getInterfaceVersion() override { return 0; } std::string getInterfaceHash() override { return ""; } }; // class IFooInterfaceDefault } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-cpp-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 033073 xustar000000000 0000000 28 mtime=1776853188.6860000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-cpp-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 030005 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-java-source_0100644 0000000 0000000 00000000034 15172120304 030455 xustar000000000 0000000 28 mtime=1776853188.6860000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-java-source/0040755 0000000 0000000 00000000000 15172120304 025462 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-java-source_gen_0100644 0000000 0000000 00000000034 15172120304 031306 xustar000000000 0000000 28 mtime=1776853188.6860000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-java-source/gen/0040755 0000000 0000000 00000000000 15172120304 026233 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-java-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 033006 xustar000000000 0000000 28 mtime=1776853188.6860000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-java-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 027653 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-java-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 033006 xustar000000000 0000000 28 mtime=1776853188.6860000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 030564 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-java-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 033006 xustar000000000 0000000 28 mtime=1776853188.6860000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/0040755 0000000 0000000 00000000000 15172120304 032562 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-java-source_gen_android_0100644 0000000 0000000 00000000217 15172120304 033011 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/tests/ 28 mtime=1776853188.6860000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/t0040755 0000000 0000000 00000000000 15172120304 032746 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-java-source_gen_android_0100644 0000000 0000000 00000000234 15172120304 033010 xustar000000000 0000000 128 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/tests/BazUnion.java 28 mtime=1776853188.6860000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000007154 15172120304 032754 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --rpc --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/tests/BazUnion.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-java-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl */ package android.aidl.versioned.tests; public final class BazUnion implements android.os.Parcelable { // tags for union fields public final static int intNum = 0; // int intNum; public final static int longNum = 1; // long longNum; private int _tag; private Object _value; public BazUnion() { int _value = 0; this._tag = intNum; this._value = _value; } private BazUnion(android.os.Parcel _aidl_parcel) { readFromParcel(_aidl_parcel); } private BazUnion(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public int getTag() { return _tag; } // int intNum; public static BazUnion intNum(int _value) { return new BazUnion(intNum, _value); } public int getIntNum() { _assertTag(intNum); return (int) _value; } public void setIntNum(int _value) { _set(intNum, _value); } // long longNum; public static BazUnion longNum(long _value) { return new BazUnion(longNum, _value); } public long getLongNum() { _assertTag(longNum); return (long) _value; } public void setLongNum(long _value) { _set(longNum, _value); } public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public BazUnion createFromParcel(android.os.Parcel _aidl_source) { return new BazUnion(_aidl_source); } @Override public BazUnion[] newArray(int _aidl_size) { return new BazUnion[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { _aidl_parcel.writeInt(_tag); switch (_tag) { case intNum: _aidl_parcel.writeInt(getIntNum()); break; case longNum: _aidl_parcel.writeLong(getLongNum()); break; } } public void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_tag; _aidl_tag = _aidl_parcel.readInt(); switch (_aidl_tag) { case intNum: { int _aidl_value; _aidl_value = _aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } case longNum: { long _aidl_value; _aidl_value = _aidl_parcel.readLong(); _set(_aidl_tag, _aidl_value); return; } } throw new IllegalArgumentException("union: unknown tag: " + _aidl_tag); } @Override public int describeContents() { int _mask = 0; switch (getTag()) { } return _mask; } private void _assertTag(int tag) { if (getTag() != tag) { throw new IllegalStateException("bad access: " + _tagString(tag) + ", " + _tagString(getTag()) + " is available."); } } private String _tagString(int _tag) { switch (_tag) { case intNum: return "intNum"; case longNum: return "longNum"; } throw new IllegalStateException("unknown field: " + _tag); } private void _set(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public static @interface Tag { public static final int intNum = 0; public static final int longNum = 1; } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-java-source_gen_android_0100644 0000000 0000000 00000000236 15172120304 033012 xustar000000000 0000000 130 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/tests/BazUnion.java.d 28 mtime=1776853188.6860000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000000363 15172120304 032747 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/tests/BazUnion.java : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-java-source_gen_android_0100644 0000000 0000000 00000000227 15172120304 033012 xustar000000000 0000000 123 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/tests/Foo.java 28 mtime=1776853188.6870000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000004501 15172120304 032745 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --rpc --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/tests/Foo.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-java-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl */ package android.aidl.versioned.tests; public class Foo implements android.os.Parcelable { public int intDefault42 = 42; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public Foo createFromParcel(android.os.Parcel _aidl_source) { Foo _aidl_out = new Foo(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public Foo[] newArray(int _aidl_size) { return new Foo[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(intDefault42); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; intDefault42 = _aidl_parcel.readInt(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-java-source_gen_android_0100644 0000000 0000000 00000000231 15172120304 033005 xustar000000000 0000000 125 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/tests/Foo.java.d 28 mtime=1776853188.6870000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000000351 15172120304 032744 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/tests/Foo.java : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-java-source_gen_android_0100644 0000000 0000000 00000000241 15172120304 033006 xustar000000000 0000000 133 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/tests/IFooInterface.java 28 mtime=1776853188.6870000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000033005 15172120304 032746 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --rpc --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/tests/IFooInterface.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-java-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/IFooInterface.aidl */ package android.aidl.versioned.tests; public interface IFooInterface extends android.os.IInterface { /** * The version of this interface that the caller is built against. * This might be different from what {@link #getInterfaceVersion() * getInterfaceVersion} returns as that is the version of the interface * that the remote object is implementing. */ public static final int VERSION = 2; public static final String HASH = "da8c4bc94ca7feff0e0a65563a466787698b5891"; /** Default implementation for IFooInterface. */ public static class Default implements android.aidl.versioned.tests.IFooInterface { @Override public void originalApi() throws android.os.RemoteException { } @Override public java.lang.String acceptUnionAndReturnString(android.aidl.versioned.tests.BazUnion u) throws android.os.RemoteException { return null; } @Override public int ignoreParcelablesAndRepeatInt(android.aidl.versioned.tests.Foo inFoo, android.aidl.versioned.tests.Foo inoutFoo, android.aidl.versioned.tests.Foo outFoo, int value) throws android.os.RemoteException { return 0; } @Override public int returnsLengthOfFooArray(android.aidl.versioned.tests.Foo[] foos) throws android.os.RemoteException { return 0; } @Override public void newApi() throws android.os.RemoteException { } @Override public int getInterfaceVersion() { return 0; } @Override public String getInterfaceHash() { return ""; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.versioned.tests.IFooInterface { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.versioned.tests.IFooInterface interface, * generating a proxy if needed. */ public static android.aidl.versioned.tests.IFooInterface asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.versioned.tests.IFooInterface))) { return ((android.aidl.versioned.tests.IFooInterface)iin); } return new android.aidl.versioned.tests.IFooInterface.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } else if (code == TRANSACTION_getInterfaceVersion) { reply.writeNoException(); reply.writeInt(getInterfaceVersion()); return true; } else if (code == TRANSACTION_getInterfaceHash) { reply.writeNoException(); reply.writeString(getInterfaceHash()); return true; } switch (code) { case TRANSACTION_originalApi: { this.originalApi(); reply.writeNoException(); break; } case TRANSACTION_acceptUnionAndReturnString: { android.aidl.versioned.tests.BazUnion _arg0; _arg0 = data.readTypedObject(android.aidl.versioned.tests.BazUnion.CREATOR); data.enforceNoDataAvail(); java.lang.String _result = this.acceptUnionAndReturnString(_arg0); reply.writeNoException(); reply.writeString(_result); break; } case TRANSACTION_ignoreParcelablesAndRepeatInt: { android.aidl.versioned.tests.Foo _arg0; _arg0 = data.readTypedObject(android.aidl.versioned.tests.Foo.CREATOR); android.aidl.versioned.tests.Foo _arg1; _arg1 = data.readTypedObject(android.aidl.versioned.tests.Foo.CREATOR); android.aidl.versioned.tests.Foo _arg2; _arg2 = new android.aidl.versioned.tests.Foo(); int _arg3; _arg3 = data.readInt(); data.enforceNoDataAvail(); int _result = this.ignoreParcelablesAndRepeatInt(_arg0, _arg1, _arg2, _arg3); reply.writeNoException(); reply.writeInt(_result); reply.writeTypedObject(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); reply.writeTypedObject(_arg2, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_returnsLengthOfFooArray: { android.aidl.versioned.tests.Foo[] _arg0; _arg0 = data.createTypedArray(android.aidl.versioned.tests.Foo.CREATOR); data.enforceNoDataAvail(); int _result = this.returnsLengthOfFooArray(_arg0); reply.writeNoException(); reply.writeInt(_result); break; } case TRANSACTION_newApi: { this.newApi(); reply.writeNoException(); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.versioned.tests.IFooInterface { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } private int mCachedVersion = -1; private String mCachedHash = "-1"; @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public void originalApi() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_originalApi, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method originalApi is unimplemented."); } _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } @Override public java.lang.String acceptUnionAndReturnString(android.aidl.versioned.tests.BazUnion u) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.lang.String _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(u, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_acceptUnionAndReturnString, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method acceptUnionAndReturnString is unimplemented."); } _reply.readException(); _result = _reply.readString(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int ignoreParcelablesAndRepeatInt(android.aidl.versioned.tests.Foo inFoo, android.aidl.versioned.tests.Foo inoutFoo, android.aidl.versioned.tests.Foo outFoo, int value) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); int _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(inFoo, 0); _data.writeTypedObject(inoutFoo, 0); _data.writeInt(value); boolean _status = mRemote.transact(Stub.TRANSACTION_ignoreParcelablesAndRepeatInt, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method ignoreParcelablesAndRepeatInt is unimplemented."); } _reply.readException(); _result = _reply.readInt(); if ((0!=_reply.readInt())) { inoutFoo.readFromParcel(_reply); } if ((0!=_reply.readInt())) { outFoo.readFromParcel(_reply); } } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int returnsLengthOfFooArray(android.aidl.versioned.tests.Foo[] foos) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); int _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedArray(foos, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_returnsLengthOfFooArray, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method returnsLengthOfFooArray is unimplemented."); } _reply.readException(); _result = _reply.readInt(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public void newApi() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_newApi, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method newApi is unimplemented."); } _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } @Override public int getInterfaceVersion() throws android.os.RemoteException { if (mCachedVersion == -1) { android.os.Parcel data = android.os.Parcel.obtain(asBinder()); android.os.Parcel reply = android.os.Parcel.obtain(); try { data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getInterfaceVersion, data, reply, 0); reply.readException(); mCachedVersion = reply.readInt(); } finally { reply.recycle(); data.recycle(); } } return mCachedVersion; } @Override public synchronized String getInterfaceHash() throws android.os.RemoteException { if ("-1".equals(mCachedHash)) { android.os.Parcel data = android.os.Parcel.obtain(asBinder()); android.os.Parcel reply = android.os.Parcel.obtain(); try { data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getInterfaceHash, data, reply, 0); reply.readException(); mCachedHash = reply.readString(); } finally { reply.recycle(); data.recycle(); } } return mCachedHash; } } static final int TRANSACTION_originalApi = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); static final int TRANSACTION_acceptUnionAndReturnString = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1); static final int TRANSACTION_ignoreParcelablesAndRepeatInt = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2); static final int TRANSACTION_returnsLengthOfFooArray = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3); static final int TRANSACTION_newApi = (android.os.IBinder.FIRST_CALL_TRANSACTION + 4); static final int TRANSACTION_getInterfaceVersion = (android.os.IBinder.FIRST_CALL_TRANSACTION + 16777214); static final int TRANSACTION_getInterfaceHash = (android.os.IBinder.FIRST_CALL_TRANSACTION + 16777213); } /** @hide */ public static final java.lang.String DESCRIPTOR = "android$aidl$versioned$tests$IFooInterface".replace('$', '.'); public void originalApi() throws android.os.RemoteException; public java.lang.String acceptUnionAndReturnString(android.aidl.versioned.tests.BazUnion u) throws android.os.RemoteException; public int ignoreParcelablesAndRepeatInt(android.aidl.versioned.tests.Foo inFoo, android.aidl.versioned.tests.Foo inoutFoo, android.aidl.versioned.tests.Foo outFoo, int value) throws android.os.RemoteException; public int returnsLengthOfFooArray(android.aidl.versioned.tests.Foo[] foos) throws android.os.RemoteException; public void newApi() throws android.os.RemoteException; public int getInterfaceVersion() throws android.os.RemoteException; public String getInterfaceHash() throws android.os.RemoteException; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-java-source_gen_android_0100644 0000000 0000000 00000000243 15172120304 033010 xustar000000000 0000000 135 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/tests/IFooInterface.java.d 28 mtime=1776853188.6870000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000000714 15172120304 032747 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-java-source/gen/android/aidl/versioned/tests/IFooInterface.java : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/IFooInterface.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-java-source_gen_timestam0100644 0000000 0000000 00000000034 15172120304 033052 xustar000000000 0000000 28 mtime=1776853188.6870000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-java-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 030144 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-ndk-source_0100644 0000000 0000000 00000000034 15172120304 030310 xustar000000000 0000000 28 mtime=1776853188.6870000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/0040755 0000000 0000000 00000000000 15172120304 025315 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-ndk-source_gen_0100644 0000000 0000000 00000000034 15172120304 031141 xustar000000000 0000000 28 mtime=1776853188.6870000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/0040755 0000000 0000000 00000000000 15172120304 026066 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-ndk-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 032641 xustar000000000 0000000 28 mtime=1776853188.6870000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 027506 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-ndk-source_gen_android_a0100644 0000000 0000000 00000000034 15172120304 033002 xustar000000000 0000000 28 mtime=1776853188.6870000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 030417 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-ndk-source_gen_android_a0100644 0000000 0000000 00000000034 15172120304 033002 xustar000000000 0000000 28 mtime=1776853188.6870000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/versioned/0040755 0000000 0000000 00000000000 15172120304 032415 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-ndk-source_gen_android_a0100644 0000000 0000000 00000000216 15172120304 033004 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/versioned/tests/ 28 mtime=1776853188.6870000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/versioned/te0040755 0000000 0000000 00000000000 15172120304 032746 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-ndk-source_gen_android_a0100644 0000000 0000000 00000000232 15172120304 033002 xustar000000000 0000000 126 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/versioned/tests/BazUnion.cpp 28 mtime=1776853188.6870000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000005171 15172120304 032751 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl */ #include "aidl/android/aidl/versioned/tests/BazUnion.h" #include namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { const char* BazUnion::descriptor = "android.aidl.versioned.tests.BazUnion"; binder_status_t BazUnion::readFromParcel(const AParcel* _parcel) { binder_status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_tag)) != STATUS_OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case intNum: { int32_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case longNum: { int64_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } } return STATUS_BAD_VALUE; } binder_status_t BazUnion::writeToParcel(AParcel* _parcel) const { binder_status_t _aidl_ret_status = ::ndk::AParcel_writeData(_parcel, static_cast(getTag())); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; switch (getTag()) { case intNum: return ::ndk::AParcel_writeData(_parcel, get()); case longNum: return ::ndk::AParcel_writeData(_parcel, get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-ndk-source_gen_android_a0100644 0000000 0000000 00000000234 15172120304 033004 xustar000000000 0000000 128 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/versioned/tests/BazUnion.cpp.d 28 mtime=1776853188.6880000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000000361 15172120304 032745 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/versioned/tests/BazUnion.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-ndk-source_gen_android_a0100644 0000000 0000000 00000000225 15172120304 033004 xustar000000000 0000000 121 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/versioned/tests/Foo.cpp 28 mtime=1776853188.6880000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000005301 15172120304 032744 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl */ #include "aidl/android/aidl/versioned/tests/Foo.h" #include namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { const char* Foo::descriptor = "android.aidl.versioned.tests.Foo"; binder_status_t Foo::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &intDefault42); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t Foo::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, intDefault42); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-ndk-source_gen_android_a0100644 0000000 0000000 00000000227 15172120304 033006 xustar000000000 0000000 123 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/versioned/tests/Foo.cpp.d 28 mtime=1776853188.6880000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000000347 15172120304 032751 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/versioned/tests/Foo.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-ndk-source_gen_android_a0100644 0000000 0000000 00000000237 15172120304 033007 xustar000000000 0000000 131 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/versioned/tests/IFooInterface.cpp 28 mtime=1776853188.6880000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000053573 15172120304 032762 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/IFooInterface.aidl */ #include "aidl/android/aidl/versioned/tests/IFooInterface.h" #include #include #include namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { static binder_status_t _aidl_android_aidl_versioned_tests_IFooInterface_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*originalApi*/): { ::ndk::ScopedAStatus _aidl_status = _aidl_impl->originalApi(); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } case (FIRST_CALL_TRANSACTION + 1 /*acceptUnionAndReturnString*/): { ::aidl::android::aidl::versioned::tests::BazUnion in_u; std::string _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_u); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->acceptUnionAndReturnString(in_u, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 2 /*ignoreParcelablesAndRepeatInt*/): { ::aidl::android::aidl::versioned::tests::Foo in_inFoo; ::aidl::android::aidl::versioned::tests::Foo in_inoutFoo; ::aidl::android::aidl::versioned::tests::Foo out_outFoo; int32_t in_value; int32_t _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_inFoo); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_inoutFoo); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_value); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ignoreParcelablesAndRepeatInt(in_inFoo, &in_inoutFoo, &out_outFoo, in_value, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, in_inoutFoo); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_outFoo); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 3 /*returnsLengthOfFooArray*/): { std::vector<::aidl::android::aidl::versioned::tests::Foo> in_foos; int32_t _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_foos); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->returnsLengthOfFooArray(in_foos, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 4 /*newApi*/): { ::ndk::ScopedAStatus _aidl_status = _aidl_impl->newApi(); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } case (FIRST_CALL_TRANSACTION + 16777214 /*getInterfaceVersion*/): { int32_t _aidl_return; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->getInterfaceVersion(&_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 16777213 /*getInterfaceHash*/): { std::string _aidl_return; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->getInterfaceHash(&_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_versioned_tests_IFooInterface_clazz = ::ndk::ICInterface::defineClass(IFooInterface::descriptor, _aidl_android_aidl_versioned_tests_IFooInterface_onTransact); BpFooInterface::BpFooInterface(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} BpFooInterface::~BpFooInterface() {} ::ndk::ScopedAStatus BpFooInterface::originalApi() { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*originalApi*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->originalApi(); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpFooInterface::acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& in_u, std::string* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_u); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 1 /*acceptUnionAndReturnString*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->acceptUnionAndReturnString(in_u, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpFooInterface::ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& in_inFoo, ::aidl::android::aidl::versioned::tests::Foo* in_inoutFoo, ::aidl::android::aidl::versioned::tests::Foo* out_outFoo, int32_t in_value, int32_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_inFoo); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), *in_inoutFoo); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_value); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 2 /*ignoreParcelablesAndRepeatInt*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->ignoreParcelablesAndRepeatInt(in_inFoo, in_inoutFoo, out_outFoo, in_value, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), in_inoutFoo); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_outFoo); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpFooInterface::returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& in_foos, int32_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_foos); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 3 /*returnsLengthOfFooArray*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->returnsLengthOfFooArray(in_foos, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpFooInterface::newApi() { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 4 /*newApi*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->newApi(); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpFooInterface::getInterfaceVersion(int32_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; if (_aidl_cached_version != -1) { *_aidl_return = _aidl_cached_version; _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); return _aidl_status; } ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 16777214 /*getInterfaceVersion*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->getInterfaceVersion(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_cached_version = *_aidl_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpFooInterface::getInterfaceHash(std::string* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; const std::lock_guard lock(_aidl_cached_hash_mutex); if (_aidl_cached_hash != "-1") { *_aidl_return = _aidl_cached_hash; _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); return _aidl_status; } ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 16777213 /*getInterfaceHash*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->getInterfaceHash(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_cached_hash = *_aidl_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } // Source for BnFooInterface BnFooInterface::BnFooInterface() {} BnFooInterface::~BnFooInterface() {} ::ndk::SpAIBinder BnFooInterface::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_versioned_tests_IFooInterface_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } ::ndk::ScopedAStatus BnFooInterface::getInterfaceVersion(int32_t* _aidl_return) { *_aidl_return = IFooInterface::version; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::ScopedAStatus BnFooInterface::getInterfaceHash(std::string* _aidl_return) { *_aidl_return = IFooInterface::hash; return ::ndk::ScopedAStatus(AStatus_newOk()); } // Source for IFooInterface const char* IFooInterface::descriptor = "android.aidl.versioned.tests.IFooInterface"; IFooInterface::IFooInterface() {} IFooInterface::~IFooInterface() {} std::shared_ptr IFooInterface::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_versioned_tests_IFooInterface_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t IFooInterface::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t IFooInterface::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = IFooInterface::fromBinder(binder); return STATUS_OK; } bool IFooInterface::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!IFooInterface::default_impl); if (impl) { IFooInterface::default_impl = impl; return true; } return false; } const std::shared_ptr& IFooInterface::getDefaultImpl() { return IFooInterface::default_impl; } std::shared_ptr IFooInterface::default_impl = nullptr; ::ndk::ScopedAStatus IFooInterfaceDefault::originalApi() { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus IFooInterfaceDefault::acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& /*in_u*/, std::string* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus IFooInterfaceDefault::ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& /*in_inFoo*/, ::aidl::android::aidl::versioned::tests::Foo* /*in_inoutFoo*/, ::aidl::android::aidl::versioned::tests::Foo* /*out_outFoo*/, int32_t /*in_value*/, int32_t* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus IFooInterfaceDefault::returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& /*in_foos*/, int32_t* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus IFooInterfaceDefault::newApi() { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus IFooInterfaceDefault::getInterfaceVersion(int32_t* _aidl_return) { *_aidl_return = 0; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::ScopedAStatus IFooInterfaceDefault::getInterfaceHash(std::string* _aidl_return) { *_aidl_return = ""; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::SpAIBinder IFooInterfaceDefault::asBinder() { return ::ndk::SpAIBinder(); } bool IFooInterfaceDefault::isRemote() { return false; } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-ndk-source_gen_android_a0100644 0000000 0000000 00000000241 15172120304 033002 xustar000000000 0000000 133 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/versioned/tests/IFooInterface.cpp.d 28 mtime=1776853188.6890000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000000712 15172120304 032745 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/android/aidl/versioned/tests/IFooInterface.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/IFooInterface.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-ndk-source_gen_include_0100644 0000000 0000000 00000000034 15172120304 032644 xustar000000000 0000000 28 mtime=1776853188.6890000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/include/0040755 0000000 0000000 00000000000 15172120304 027511 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-ndk-source_gen_include_a0100644 0000000 0000000 00000000034 15172120304 033005 xustar000000000 0000000 28 mtime=1776853188.6890000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/0040755 0000000 0000000 00000000000 15172120304 030422 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-ndk-source_gen_include_a0100644 0000000 0000000 00000000034 15172120304 033005 xustar000000000 0000000 28 mtime=1776853188.6890000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/0040755 0000000 0000000 00000000000 15172120304 032042 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-ndk-source_gen_include_a0100644 0000000 0000000 00000000213 15172120304 033004 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl/ 28 mtime=1776853188.6890000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl0040755 0000000 0000000 00000000000 15172120304 032674 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-ndk-source_gen_include_a0100644 0000000 0000000 00000000225 15172120304 033007 xustar000000000 0000000 121 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl/versioned/ 28 mtime=1776853188.6890000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl0040755 0000000 0000000 00000000000 15172120304 032674 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-ndk-source_gen_include_a0100644 0000000 0000000 00000000233 15172120304 033006 xustar000000000 0000000 127 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl/versioned/tests/ 28 mtime=1776853188.6890000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl0040755 0000000 0000000 00000000000 15172120304 032674 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-ndk-source_gen_include_a0100644 0000000 0000000 00000000245 15172120304 033011 xustar000000000 0000000 137 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BazUnion.h 28 mtime=1776853188.6890000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl0100644 0000000 0000000 00000012672 15172120304 032703 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { class BazUnion { public: typedef std::false_type fixed_size; static const char* descriptor; enum class Tag : int32_t { intNum = 0, longNum = 1, }; // Expose tag symbols for legacy code static const inline Tag intNum = Tag::intNum; static const inline Tag longNum = Tag::longNum; template static constexpr bool _not_self = !std::is_same_v>, BazUnion>; BazUnion() : _value(std::in_place_index(intNum)>, int32_t(0)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr BazUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit BazUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static BazUnion make(_Tp&&... _args) { return BazUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static BazUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return BazUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } binder_status_t readFromParcel(const AParcel* _parcel); binder_status_t writeToParcel(AParcel* _parcel) const; inline bool operator==(const BazUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const BazUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const BazUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const BazUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const BazUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const BazUnion& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream os; os << "BazUnion{"; switch (getTag()) { case intNum: os << "intNum: " << ::android::internal::ToString(get()); break; case longNum: os << "longNum: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant _value; }; } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { [[nodiscard]] static inline std::string toString(BazUnion::Tag val) { switch(val) { case BazUnion::Tag::intNum: return "intNum"; case BazUnion::Tag::longNum: return "longNum"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::versioned::tests::BazUnion::Tag::intNum, aidl::android::aidl::versioned::tests::BazUnion::Tag::longNum, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-ndk-source_gen_include_a0100644 0000000 0000000 00000000247 15172120304 033013 xustar000000000 0000000 139 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BnBazUnion.h 28 mtime=1776853188.6890000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl0100644 0000000 0000000 00000001432 15172120304 032673 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-ndk-source_gen_include_a0100644 0000000 0000000 00000000242 15172120304 033006 xustar000000000 0000000 134 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BnFoo.h 28 mtime=1776853188.6890000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl0100644 0000000 0000000 00000001420 15172120304 032670 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-ndk-source_gen_include_a0100644 0000000 0000000 00000000253 15172120304 033010 xustar000000000 0000000 143 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BnFooInterface.h 28 mtime=1776853188.6900000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl0100644 0000000 0000000 00000006100 15172120304 032670 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include "aidl/android/aidl/versioned/tests/IFooInterface.h" #include #include #ifndef __BIONIC__ #ifndef __assert2 #define __assert2(a,b,c,d) ((void)0) #endif #endif namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { class BnFooInterface : public ::ndk::BnCInterface { public: BnFooInterface(); virtual ~BnFooInterface(); ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) final; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) final; protected: ::ndk::SpAIBinder createBinder() override; private: }; class IFooInterfaceDelegator : public BnFooInterface { public: explicit IFooInterfaceDelegator(const std::shared_ptr &impl) : _impl(impl) { int32_t _impl_ver = 0; if (!impl->getInterfaceVersion(&_impl_ver).isOk()) {; __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Delegator failed to get version of the implementation."); } if (_impl_ver != IFooInterface::version) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Mismatched versions of delegator and implementation is not allowed."); } } ::ndk::ScopedAStatus originalApi() override { return _impl->originalApi(); } ::ndk::ScopedAStatus acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& in_u, std::string* _aidl_return) override { return _impl->acceptUnionAndReturnString(in_u, _aidl_return); } ::ndk::ScopedAStatus ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& in_inFoo, ::aidl::android::aidl::versioned::tests::Foo* in_inoutFoo, ::aidl::android::aidl::versioned::tests::Foo* out_outFoo, int32_t in_value, int32_t* _aidl_return) override { return _impl->ignoreParcelablesAndRepeatInt(in_inFoo, in_inoutFoo, out_outFoo, in_value, _aidl_return); } ::ndk::ScopedAStatus returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& in_foos, int32_t* _aidl_return) override { return _impl->returnsLengthOfFooArray(in_foos, _aidl_return); } ::ndk::ScopedAStatus newApi() override { return _impl->newApi(); } protected: private: std::shared_ptr _impl; }; } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-ndk-source_gen_include_a0100644 0000000 0000000 00000000247 15172120304 033013 xustar000000000 0000000 139 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BpBazUnion.h 28 mtime=1776853188.6900000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl0100644 0000000 0000000 00000001432 15172120304 032673 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-ndk-source_gen_include_a0100644 0000000 0000000 00000000242 15172120304 033006 xustar000000000 0000000 134 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BpFoo.h 28 mtime=1776853188.6900000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl0100644 0000000 0000000 00000001420 15172120304 032670 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-ndk-source_gen_include_a0100644 0000000 0000000 00000000253 15172120304 033010 xustar000000000 0000000 143 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BpFooInterface.h 28 mtime=1776853188.6900000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl0100644 0000000 0000000 00000004177 15172120304 032704 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include "aidl/android/aidl/versioned/tests/IFooInterface.h" #include namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { class BpFooInterface : public ::ndk::BpCInterface { public: explicit BpFooInterface(const ::ndk::SpAIBinder& binder); virtual ~BpFooInterface(); ::ndk::ScopedAStatus originalApi() override; ::ndk::ScopedAStatus acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& in_u, std::string* _aidl_return) override; ::ndk::ScopedAStatus ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& in_inFoo, ::aidl::android::aidl::versioned::tests::Foo* in_inoutFoo, ::aidl::android::aidl::versioned::tests::Foo* out_outFoo, int32_t in_value, int32_t* _aidl_return) override; ::ndk::ScopedAStatus returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& in_foos, int32_t* _aidl_return) override; ::ndk::ScopedAStatus newApi() override; ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) override; int32_t _aidl_cached_version = -1; std::string _aidl_cached_hash = "-1"; std::mutex _aidl_cached_hash_mutex; }; } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-ndk-source_gen_include_a0100644 0000000 0000000 00000000240 15172120304 033004 xustar000000000 0000000 132 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl/versioned/tests/Foo.h 28 mtime=1776853188.6900000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl0100644 0000000 0000000 00000004527 15172120304 032703 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl */ #pragma once #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { class Foo { public: typedef std::false_type fixed_size; static const char* descriptor; int32_t intDefault42 = 42; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const Foo& _rhs) const { return std::tie(intDefault42) == std::tie(_rhs.intDefault42); } inline bool operator<(const Foo& _rhs) const { return std::tie(intDefault42) < std::tie(_rhs.intDefault42); } inline bool operator!=(const Foo& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Foo& _rhs) const { return _rhs < *this; } inline bool operator>=(const Foo& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Foo& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "Foo{"; _aidl_os << "intDefault42: " << ::android::internal::ToString(intDefault42); _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-ndk-source_gen_include_a0100644 0000000 0000000 00000000252 15172120304 033007 xustar000000000 0000000 142 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl/versioned/tests/IFooInterface.h 28 mtime=1776853188.6900000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/include/aidl/android/aidl0100644 0000000 0000000 00000010676 15172120304 032705 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl::android::aidl::versioned::tests { class Foo; } // namespace aidl::android::aidl::versioned::tests namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { class IFooInterfaceDelegator; class IFooInterface : public ::ndk::ICInterface { public: typedef IFooInterfaceDelegator DefaultDelegator; static const char* descriptor; IFooInterface(); virtual ~IFooInterface(); static inline const int32_t version = 2; static inline const std::string hash = "da8c4bc94ca7feff0e0a65563a466787698b5891"; static constexpr uint32_t TRANSACTION_originalApi = FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_acceptUnionAndReturnString = FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_ignoreParcelablesAndRepeatInt = FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_returnsLengthOfFooArray = FIRST_CALL_TRANSACTION + 3; static constexpr uint32_t TRANSACTION_newApi = FIRST_CALL_TRANSACTION + 4; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus originalApi() = 0; virtual ::ndk::ScopedAStatus acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& in_u, std::string* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& in_inFoo, ::aidl::android::aidl::versioned::tests::Foo* in_inoutFoo, ::aidl::android::aidl::versioned::tests::Foo* out_outFoo, int32_t in_value, int32_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& in_foos, int32_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus newApi() = 0; virtual ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) = 0; private: static std::shared_ptr default_impl; }; class IFooInterfaceDefault : public IFooInterface { public: ::ndk::ScopedAStatus originalApi() override; ::ndk::ScopedAStatus acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& in_u, std::string* _aidl_return) override; ::ndk::ScopedAStatus ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& in_inFoo, ::aidl::android::aidl::versioned::tests::Foo* in_inoutFoo, ::aidl::android::aidl::versioned::tests::Foo* out_outFoo, int32_t in_value, int32_t* _aidl_return) override; ::ndk::ScopedAStatus returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& in_foos, int32_t* _aidl_return) override; ::ndk::ScopedAStatus newApi() override; ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-ndk-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 033065 xustar000000000 0000000 28 mtime=1776853188.6900000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-ndk-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 027777 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-rust-source_0100644 0000000 0000000 00000000034 15172120304 030531 xustar000000000 0000000 28 mtime=1776853188.6900000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-rust-source/0040755 0000000 0000000 00000000000 15172120304 025536 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-rust-source_gen_0100644 0000000 0000000 00000000034 15172120304 031362 xustar000000000 0000000 28 mtime=1776853188.6900000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-rust-source/gen/0040755 0000000 0000000 00000000000 15172120304 026307 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-rust-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 033062 xustar000000000 0000000 28 mtime=1776853188.6900000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-rust-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 027727 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-rust-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 033062 xustar000000000 0000000 28 mtime=1776853188.6900000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 030640 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-rust-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 033062 xustar000000000 0000000 28 mtime=1776853188.6900000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/0040755 0000000 0000000 00000000000 15172120304 032636 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-rust-source_gen_android_0100644 0000000 0000000 00000000217 15172120304 033065 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/tests/ 28 mtime=1776853188.6900000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/t0040755 0000000 0000000 00000000000 15172120304 033022 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-rust-source_gen_android_0100644 0000000 0000000 00000000232 15172120304 033062 xustar000000000 0000000 126 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/tests/BazUnion.rs 28 mtime=1776853188.6900000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000004412 15172120304 033022 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/tests/BazUnion.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-rust-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub enum r#BazUnion { IntNum(i32), LongNum(i64), } impl Default for r#BazUnion { fn default() -> Self { Self::IntNum(0) } } impl binder::Parcelable for r#BazUnion { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { match self { Self::IntNum(v) => { parcel.write(&0i32)?; parcel.write(v) } Self::LongNum(v) => { parcel.write(&1i32)?; parcel.write(v) } } } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { let tag: i32 = parcel.read()?; match tag { 0 => { let value: i32 = parcel.read()?; *self = Self::IntNum(value); Ok(()) } 1 => { let value: i64 = parcel.read()?; *self = Self::LongNum(value); Ok(()) } _ => { Err(binder::StatusCode::BAD_VALUE) } } } } binder::impl_serialize_for_parcelable!(r#BazUnion); binder::impl_deserialize_for_parcelable!(r#BazUnion); impl binder::binder_impl::ParcelableMetadata for r#BazUnion { fn get_descriptor() -> &'static str { "android.aidl.versioned.tests.BazUnion" } } pub mod r#Tag { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#Tag : [i32; 2] { r#intNum = 0, r#longNum = 1, } } } pub(crate) mod mangled { pub use super::r#BazUnion as _7_android_4_aidl_9_versioned_5_tests_8_BazUnion; pub use super::r#Tag::r#Tag as _7_android_4_aidl_9_versioned_5_tests_8_BazUnion_3_Tag; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-rust-source_gen_android_0100644 0000000 0000000 00000000234 15172120304 033064 xustar000000000 0000000 128 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/tests/BazUnion.rs.d 28 mtime=1776853188.6910000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000000361 15172120304 033021 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/tests/BazUnion.rs : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-rust-source_gen_android_0100644 0000000 0000000 00000000225 15172120304 033064 xustar000000000 0000000 121 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/tests/Foo.rs 28 mtime=1776853188.6910000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000003251 15172120304 033022 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/tests/Foo.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-rust-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub struct r#Foo { pub r#intDefault42: i32, } impl Default for r#Foo { fn default() -> Self { Self { r#intDefault42: 42, } } } impl binder::Parcelable for r#Foo { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#intDefault42)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#intDefault42 = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#Foo); binder::impl_deserialize_for_parcelable!(r#Foo); impl binder::binder_impl::ParcelableMetadata for r#Foo { fn get_descriptor() -> &'static str { "android.aidl.versioned.tests.Foo" } } pub(crate) mod mangled { pub use super::r#Foo as _7_android_4_aidl_9_versioned_5_tests_3_Foo; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-rust-source_gen_android_0100644 0000000 0000000 00000000227 15172120304 033066 xustar000000000 0000000 123 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/tests/Foo.rs.d 28 mtime=1776853188.6910000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000000347 15172120304 033025 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/tests/Foo.rs : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-rust-source_gen_android_0100644 0000000 0000000 00000000237 15172120304 033067 xustar000000000 0000000 131 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/tests/IFooInterface.rs 28 mtime=1776853188.6910000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000067453 15172120304 033040 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust --structured --version 2 --hash da8c4bc94ca7feff0e0a65563a466787698b5891 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/tests/IFooInterface.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-rust-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/2 system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/IFooInterface.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { IFooInterface["android.aidl.versioned.tests.IFooInterface"] { native: BnFooInterface(on_transact), proxy: BpFooInterface { cached_version: std::sync::atomic::AtomicI32 = std::sync::atomic::AtomicI32::new(-1), cached_hash: std::sync::Mutex> = std::sync::Mutex::new(None) }, async: IFooInterfaceAsync, } } pub trait IFooInterface: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.versioned.tests.IFooInterface" } fn r#originalApi(&self) -> binder::Result<()>; fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result; fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result; fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result; fn r#newApi(&self) -> binder::Result<()>; fn r#getInterfaceVersion(&self) -> binder::Result { Ok(VERSION) } fn r#getInterfaceHash(&self) -> binder::Result { Ok(HASH.into()) } fn getDefaultImpl() -> IFooInterfaceDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: IFooInterfaceDefaultRef) -> IFooInterfaceDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait IFooInterfaceAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.versioned.tests.IFooInterface" } fn r#originalApi<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result<()>>; fn r#acceptUnionAndReturnString<'a>(&'a self, _arg_u: &'a crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::BoxFuture<'a, binder::Result>; fn r#ignoreParcelablesAndRepeatInt<'a>(&'a self, _arg_inFoo: &'a crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &'a mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &'a mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::BoxFuture<'a, binder::Result>; fn r#returnsLengthOfFooArray<'a>(&'a self, _arg_foos: &'a [crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::BoxFuture<'a, binder::Result>; fn r#newApi<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result<()>>; fn r#getInterfaceVersion<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { Box::pin(async move { Ok(VERSION) }) } fn r#getInterfaceHash<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { Box::pin(async move { Ok(HASH.into()) }) } } #[::async_trait::async_trait] pub trait IFooInterfaceAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.versioned.tests.IFooInterface" } async fn r#originalApi(&self) -> binder::Result<()>; async fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result; async fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result; async fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result; async fn r#newApi(&self) -> binder::Result<()>; } impl BnFooInterface { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: IFooInterfaceAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl IFooInterface for Wrapper where T: IFooInterfaceAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#originalApi(&self) -> binder::Result<()> { self._rt.block_on(self._inner.r#originalApi()) } fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result { self._rt.block_on(self._inner.r#acceptUnionAndReturnString(_arg_u)) } fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result { self._rt.block_on(self._inner.r#ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value)) } fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result { self._rt.block_on(self._inner.r#returnsLengthOfFooArray(_arg_foos)) } fn r#newApi(&self) -> binder::Result<()> { self._rt.block_on(self._inner.r#newApi()) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait IFooInterfaceDefault: Send + Sync { fn r#originalApi(&self) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#newApi(&self) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#originalApi: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; pub const r#acceptUnionAndReturnString: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 1; pub const r#ignoreParcelablesAndRepeatInt: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 2; pub const r#returnsLengthOfFooArray: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 3; pub const r#newApi: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 4; pub const r#getInterfaceVersion: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 16777214; pub const r#getInterfaceHash: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 16777213; } pub type IFooInterfaceDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); pub const VERSION: i32 = 2; pub const HASH: &str = "da8c4bc94ca7feff0e0a65563a466787698b5891"; impl BpFooInterface { fn build_parcel_originalApi(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_originalApi(&self, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#originalApi(); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } Ok(()) } fn build_parcel_acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_u)?; Ok(aidl_data) } fn read_response_acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#acceptUnionAndReturnString(_arg_u); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: String = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_inFoo)?; aidl_data.write(_arg_inoutFoo)?; aidl_data.write(&_arg_value)?; Ok(aidl_data) } fn read_response_ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: i32 = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_inoutFoo)?; _aidl_reply.read_onto(_arg_outFoo)?; Ok(_aidl_return) } fn build_parcel_returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_foos)?; Ok(aidl_data) } fn read_response_returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo], _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#returnsLengthOfFooArray(_arg_foos); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: i32 = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_newApi(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_newApi(&self, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#newApi(); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } Ok(()) } fn build_parcel_getInterfaceVersion(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_getInterfaceVersion(&self, _aidl_reply: std::result::Result) -> binder::Result { let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: i32 = _aidl_reply.read()?; self.cached_version.store(_aidl_return, std::sync::atomic::Ordering::Relaxed); Ok(_aidl_return) } fn build_parcel_getInterfaceHash(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_getInterfaceHash(&self, _aidl_reply: std::result::Result) -> binder::Result { let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: String = _aidl_reply.read()?; *self.cached_hash.lock().unwrap() = Some(_aidl_return.clone()); Ok(_aidl_return) } } impl IFooInterface for BpFooInterface { fn r#originalApi(&self) -> binder::Result<()> { let _aidl_data = self.build_parcel_originalApi()?; let _aidl_reply = self.binder.submit_transact(transactions::r#originalApi, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_originalApi(_aidl_reply) } fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result { let _aidl_data = self.build_parcel_acceptUnionAndReturnString(_arg_u)?; let _aidl_reply = self.binder.submit_transact(transactions::r#acceptUnionAndReturnString, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_acceptUnionAndReturnString(_arg_u, _aidl_reply) } fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result { let _aidl_data = self.build_parcel_ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ignoreParcelablesAndRepeatInt, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value, _aidl_reply) } fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result { let _aidl_data = self.build_parcel_returnsLengthOfFooArray(_arg_foos)?; let _aidl_reply = self.binder.submit_transact(transactions::r#returnsLengthOfFooArray, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_returnsLengthOfFooArray(_arg_foos, _aidl_reply) } fn r#newApi(&self) -> binder::Result<()> { let _aidl_data = self.build_parcel_newApi()?; let _aidl_reply = self.binder.submit_transact(transactions::r#newApi, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_newApi(_aidl_reply) } fn r#getInterfaceVersion(&self) -> binder::Result { let _aidl_version = self.cached_version.load(std::sync::atomic::Ordering::Relaxed); if _aidl_version != -1 { return Ok(_aidl_version); } let _aidl_data = self.build_parcel_getInterfaceVersion()?; let _aidl_reply = self.binder.submit_transact(transactions::r#getInterfaceVersion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_getInterfaceVersion(_aidl_reply) } fn r#getInterfaceHash(&self) -> binder::Result { { let _aidl_hash_lock = self.cached_hash.lock().unwrap(); if let Some(ref _aidl_hash) = *_aidl_hash_lock { return Ok(_aidl_hash.clone()); } } let _aidl_data = self.build_parcel_getInterfaceHash()?; let _aidl_reply = self.binder.submit_transact(transactions::r#getInterfaceHash, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_getInterfaceHash(_aidl_reply) } } impl IFooInterfaceAsync

for BpFooInterface { fn r#originalApi<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_originalApi() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#originalApi, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_originalApi(_aidl_reply) } ) } fn r#acceptUnionAndReturnString<'a>(&'a self, _arg_u: &'a crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_acceptUnionAndReturnString(_arg_u) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#acceptUnionAndReturnString, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_acceptUnionAndReturnString(_arg_u, _aidl_reply) } ) } fn r#ignoreParcelablesAndRepeatInt<'a>(&'a self, _arg_inFoo: &'a crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &'a mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &'a mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ignoreParcelablesAndRepeatInt, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value, _aidl_reply) } ) } fn r#returnsLengthOfFooArray<'a>(&'a self, _arg_foos: &'a [crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_returnsLengthOfFooArray(_arg_foos) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#returnsLengthOfFooArray, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_returnsLengthOfFooArray(_arg_foos, _aidl_reply) } ) } fn r#newApi<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_newApi() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#newApi, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_newApi(_aidl_reply) } ) } fn r#getInterfaceVersion<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { let _aidl_version = self.cached_version.load(std::sync::atomic::Ordering::Relaxed); if _aidl_version != -1 { return Box::pin(std::future::ready(Ok(_aidl_version))); } let _aidl_data = match self.build_parcel_getInterfaceVersion() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#getInterfaceVersion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_getInterfaceVersion(_aidl_reply) } ) } fn r#getInterfaceHash<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { { let _aidl_hash_lock = self.cached_hash.lock().unwrap(); if let Some(ref _aidl_hash) = *_aidl_hash_lock { return Box::pin(std::future::ready(Ok(_aidl_hash.clone()))); } } let _aidl_data = match self.build_parcel_getInterfaceHash() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#getInterfaceHash, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_getInterfaceHash(_aidl_reply) } ) } } impl IFooInterface for binder::binder_impl::Binder { fn r#originalApi(&self) -> binder::Result<()> { self.0.r#originalApi() } fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result { self.0.r#acceptUnionAndReturnString(_arg_u) } fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result { self.0.r#ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value) } fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result { self.0.r#returnsLengthOfFooArray(_arg_foos) } fn r#newApi(&self) -> binder::Result<()> { self.0.r#newApi() } fn r#getInterfaceVersion(&self) -> binder::Result { self.0.r#getInterfaceVersion() } fn r#getInterfaceHash(&self) -> binder::Result { self.0.r#getInterfaceHash() } } fn on_transact(_aidl_service: &dyn IFooInterface, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#originalApi => { let _aidl_return = _aidl_service.r#originalApi(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#acceptUnionAndReturnString => { let _arg_u: crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion = _aidl_data.read()?; let _aidl_return = _aidl_service.r#acceptUnionAndReturnString(&_arg_u); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ignoreParcelablesAndRepeatInt => { let _arg_inFoo: crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo = _aidl_data.read()?; let mut _arg_inoutFoo: crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo = _aidl_data.read()?; let mut _arg_outFoo: crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo = Default::default(); let _arg_value: i32 = _aidl_data.read()?; let _aidl_return = _aidl_service.r#ignoreParcelablesAndRepeatInt(&_arg_inFoo, &mut _arg_inoutFoo, &mut _arg_outFoo, _arg_value); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_inoutFoo)?; _aidl_reply.write(&_arg_outFoo)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#returnsLengthOfFooArray => { let _arg_foos: Vec = _aidl_data.read()?; let _aidl_return = _aidl_service.r#returnsLengthOfFooArray(&_arg_foos); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#newApi => { let _aidl_return = _aidl_service.r#newApi(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#getInterfaceVersion => { let _aidl_return = _aidl_service.r#getInterfaceVersion(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#getInterfaceHash => { let _aidl_return = _aidl_service.r#getInterfaceHash(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } pub(crate) mod mangled { pub use super::r#IFooInterface as _7_android_4_aidl_9_versioned_5_tests_13_IFooInterface; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-rust-source_gen_android_0100644 0000000 0000000 00000000241 15172120304 033062 xustar000000000 0000000 133 path=tests/golden_output/frozen/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/tests/IFooInterface.rs.d 28 mtime=1776853188.6910000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000000712 15172120304 033021 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V2-rust-source/gen/android/aidl/versioned/tests/IFooInterface.rs : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/IFooInterface.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/BazUnion.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/2/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V2-rust-source_gen_timestam0100644 0000000 0000000 00000000034 15172120304 033126 xustar000000000 0000000 28 mtime=1776853188.6910000 tests/golden_output/frozen/aidl-test-versioned-interface-V2-rust-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 030220 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-cpp-source_0100644 0000000 0000000 00000000034 15172120304 030317 xustar000000000 0000000 28 mtime=1776853188.6920000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/0040755 0000000 0000000 00000000000 15172120304 025324 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-cpp-source_gen_0100644 0000000 0000000 00000000034 15172120304 031150 xustar000000000 0000000 28 mtime=1776853188.6920000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/0040755 0000000 0000000 00000000000 15172120304 026075 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-cpp-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 032650 xustar000000000 0000000 28 mtime=1776853188.6920000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 027515 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-cpp-source_gen_android_a0100644 0000000 0000000 00000000034 15172120304 033011 xustar000000000 0000000 28 mtime=1776853188.6920000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 030426 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-cpp-source_gen_android_a0100644 0000000 0000000 00000000034 15172120304 033011 xustar000000000 0000000 28 mtime=1776853188.6920000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/versioned/0040755 0000000 0000000 00000000000 15172120304 032424 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-cpp-source_gen_android_a0100644 0000000 0000000 00000000216 15172120304 033013 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/versioned/tests/ 28 mtime=1776853188.6920000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/versioned/te0040755 0000000 0000000 00000000000 15172120304 032755 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-cpp-source_gen_android_a0100644 0000000 0000000 00000000232 15172120304 033011 xustar000000000 0000000 126 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/versioned/tests/BazUnion.cpp 28 mtime=1776853188.6920000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000004755 15172120304 032767 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl */ #include namespace android { namespace aidl { namespace versioned { namespace tests { ::android::status_t BazUnion::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_tag)) != ::android::OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case intNum: { int32_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case longNum: { int64_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt64(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } } return ::android::BAD_VALUE; } ::android::status_t BazUnion::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(getTag())); if (_aidl_ret_status != ::android::OK) return _aidl_ret_status; switch (getTag()) { case intNum: return _aidl_parcel->writeInt32(get()); case longNum: return _aidl_parcel->writeInt64(get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-cpp-source_gen_android_a0100644 0000000 0000000 00000000234 15172120304 033013 xustar000000000 0000000 128 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/versioned/tests/BazUnion.cpp.d 28 mtime=1776853188.6920000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000000361 15172120304 032754 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/versioned/tests/BazUnion.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-cpp-source_gen_android_a0100644 0000000 0000000 00000000225 15172120304 033013 xustar000000000 0000000 121 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/versioned/tests/Foo.cpp 28 mtime=1776853188.6920000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000005114 15172120304 032755 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl */ #include namespace android { namespace aidl { namespace versioned { namespace tests { ::android::status_t Foo::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&intDefault42); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t Foo::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeInt32(intDefault42); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-cpp-source_gen_android_a0100644 0000000 0000000 00000000227 15172120304 033015 xustar000000000 0000000 123 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/versioned/tests/Foo.cpp.d 28 mtime=1776853188.6920000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000000347 15172120304 032760 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/versioned/tests/Foo.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-cpp-source_gen_android_a0100644 0000000 0000000 00000000237 15172120304 033016 xustar000000000 0000000 131 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/versioned/tests/IFooInterface.cpp 28 mtime=1776853188.6920000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000041504 15172120304 032760 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/IFooInterface.aidl */ #include #include namespace android { namespace aidl { namespace versioned { namespace tests { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE(FooInterface, "android.aidl.versioned.tests.IFooInterface") } // namespace tests } // namespace versioned } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace versioned { namespace tests { BpFooInterface::BpFooInterface(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } ::android::binder::Status BpFooInterface::originalApi() { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::originalApi::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnFooInterface::TRANSACTION_originalApi, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) [[unlikely]] { return IFooInterface::getDefaultImpl()->originalApi(); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpFooInterface::acceptUnionAndReturnString(const ::android::aidl::versioned::tests::BazUnion& u, ::std::string* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::acceptUnionAndReturnString::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(u); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnFooInterface::TRANSACTION_acceptUnionAndReturnString, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) [[unlikely]] { return IFooInterface::getDefaultImpl()->acceptUnionAndReturnString(u, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readUtf8FromUtf16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpFooInterface::ignoreParcelablesAndRepeatInt(const ::android::aidl::versioned::tests::Foo& inFoo, ::android::aidl::versioned::tests::Foo* inoutFoo, ::android::aidl::versioned::tests::Foo* outFoo, int32_t value, int32_t* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::ignoreParcelablesAndRepeatInt::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(inFoo); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(*inoutFoo); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeInt32(value); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnFooInterface::TRANSACTION_ignoreParcelablesAndRepeatInt, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) [[unlikely]] { return IFooInterface::getDefaultImpl()->ignoreParcelablesAndRepeatInt(inFoo, inoutFoo, outFoo, value, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readInt32(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readParcelable(inoutFoo); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readParcelable(outFoo); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpFooInterface::returnsLengthOfFooArray(const ::std::vector<::android::aidl::versioned::tests::Foo>& foos, int32_t* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::returnsLengthOfFooArray::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelableVector(foos); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnFooInterface::TRANSACTION_returnsLengthOfFooArray, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) [[unlikely]] { return IFooInterface::getDefaultImpl()->returnsLengthOfFooArray(foos, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readInt32(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } ::android::binder::Status BpFooInterface::newApi() { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::newApi::cppClient"); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnFooInterface::TRANSACTION_newApi, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) [[unlikely]] { return IFooInterface::getDefaultImpl()->newApi(); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); return _aidl_status; } int32_t BpFooInterface::getInterfaceVersion() { if (cached_version_ == -1) { ::android::Parcel data; ::android::Parcel reply; data.writeInterfaceToken(getInterfaceDescriptor()); ::android::status_t err = remote()->transact(BnFooInterface::TRANSACTION_getInterfaceVersion, data, &reply); if (err == ::android::OK) { ::android::binder::Status _aidl_status; err = _aidl_status.readFromParcel(reply); if (err == ::android::OK && _aidl_status.isOk()) { cached_version_ = reply.readInt32(); } } } return cached_version_; } std::string BpFooInterface::getInterfaceHash() { std::lock_guard lockGuard(cached_hash_mutex_); if (cached_hash_ == "-1") { ::android::Parcel data; ::android::Parcel reply; data.writeInterfaceToken(getInterfaceDescriptor()); ::android::status_t err = remote()->transact(BnFooInterface::TRANSACTION_getInterfaceHash, data, &reply); if (err == ::android::OK) { ::android::binder::Status _aidl_status; err = _aidl_status.readFromParcel(reply); if (err == ::android::OK && _aidl_status.isOk()) { reply.readUtf8FromUtf16(&cached_hash_); } } } return cached_hash_; } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android #include #include #include namespace android { namespace aidl { namespace versioned { namespace tests { BnFooInterface::BnFooInterface() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t BnFooInterface::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnFooInterface::TRANSACTION_originalApi: { if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::originalApi::cppServer"); ::android::binder::Status _aidl_status(originalApi()); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; case BnFooInterface::TRANSACTION_acceptUnionAndReturnString: { ::android::aidl::versioned::tests::BazUnion in_u; ::std::string _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::acceptUnionAndReturnString::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_u); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(acceptUnionAndReturnString(in_u, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeUtf8AsUtf16(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnFooInterface::TRANSACTION_ignoreParcelablesAndRepeatInt: { ::android::aidl::versioned::tests::Foo in_inFoo; ::android::aidl::versioned::tests::Foo in_inoutFoo; ::android::aidl::versioned::tests::Foo out_outFoo; int32_t in_value; int32_t _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::ignoreParcelablesAndRepeatInt::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_inFoo); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readParcelable(&in_inoutFoo); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readInt32(&in_value); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(ignoreParcelablesAndRepeatInt(in_inFoo, &in_inoutFoo, &out_outFoo, in_value, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeInt32(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(in_inoutFoo); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(out_outFoo); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnFooInterface::TRANSACTION_returnsLengthOfFooArray: { ::std::vector<::android::aidl::versioned::tests::Foo> in_foos; int32_t _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::returnsLengthOfFooArray::cppServer"); _aidl_ret_status = _aidl_data.readParcelableVector(&in_foos); if (((_aidl_ret_status) != (::android::OK))) { break; } if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(returnsLengthOfFooArray(in_foos, &_aidl_return)); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeInt32(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnFooInterface::TRANSACTION_newApi: { if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IFooInterface::newApi::cppServer"); ::android::binder::Status _aidl_status(newApi()); _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; case BnFooInterface::TRANSACTION_getInterfaceVersion: { _aidl_data.checkInterface(this); _aidl_reply->writeNoException(); _aidl_reply->writeInt32(IFooInterface::VERSION); } break; case BnFooInterface::TRANSACTION_getInterfaceHash: { _aidl_data.checkInterface(this); _aidl_reply->writeNoException(); _aidl_reply->writeUtf8AsUtf16(IFooInterface::HASH); } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } int32_t BnFooInterface::getInterfaceVersion() { return IFooInterface::VERSION; } std::string BnFooInterface::getInterfaceHash() { return IFooInterface::HASH; } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-cpp-source_gen_android_a0100644 0000000 0000000 00000000241 15172120304 033011 xustar000000000 0000000 133 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/versioned/tests/IFooInterface.cpp.d 28 mtime=1776853188.6930000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000000712 15172120304 032754 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/android/aidl/versioned/tests/IFooInterface.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/IFooInterface.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-cpp-source_gen_include_0100644 0000000 0000000 00000000034 15172120304 032653 xustar000000000 0000000 28 mtime=1776853188.6930000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/include/0040755 0000000 0000000 00000000000 15172120304 027520 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-cpp-source_gen_include_a0100644 0000000 0000000 00000000034 15172120304 033014 xustar000000000 0000000 28 mtime=1776853188.6930000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/0040755 0000000 0000000 00000000000 15172120304 031140 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-cpp-source_gen_include_a0100644 0000000 0000000 00000000034 15172120304 033014 xustar000000000 0000000 28 mtime=1776853188.6930000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/0040755 0000000 0000000 00000000000 15172120304 032051 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-cpp-source_gen_include_a0100644 0000000 0000000 00000000220 15172120304 033011 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/versioned/ 28 mtime=1776853188.6930000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/vers0040755 0000000 0000000 00000000000 15172120304 032751 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-cpp-source_gen_include_a0100644 0000000 0000000 00000000226 15172120304 033017 xustar000000000 0000000 122 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/versioned/tests/ 28 mtime=1776853188.6930000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/vers0040755 0000000 0000000 00000000000 15172120304 032751 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-cpp-source_gen_include_a0100644 0000000 0000000 00000000240 15172120304 033013 xustar000000000 0000000 132 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/versioned/tests/BazUnion.h 28 mtime=1776853188.6930000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/vers0100644 0000000 0000000 00000012470 15172120304 032754 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace android { namespace aidl { namespace versioned { namespace tests { class BazUnion : public ::android::Parcelable { public: enum class Tag : int32_t { intNum = 0, longNum = 1, }; // Expose tag symbols for legacy code static const inline Tag intNum = Tag::intNum; static const inline Tag longNum = Tag::longNum; template static constexpr bool _not_self = !std::is_same_v>, BazUnion>; BazUnion() : _value(std::in_place_index(intNum)>, int32_t(0)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr BazUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit BazUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static BazUnion make(_Tp&&... _args) { return BazUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static BazUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return BazUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } inline bool operator==(const BazUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const BazUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const BazUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const BazUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const BazUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const BazUnion& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.versioned.tests.BazUnion"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream os; os << "BazUnion{"; switch (getTag()) { case intNum: os << "intNum: " << ::android::internal::ToString(get()); break; case longNum: os << "longNum: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant _value; }; // class BazUnion } // namespace tests } // namespace versioned } // namespace aidl } // namespace android namespace android { namespace aidl { namespace versioned { namespace tests { [[nodiscard]] static inline std::string toString(BazUnion::Tag val) { switch(val) { case BazUnion::Tag::intNum: return "intNum"; case BazUnion::Tag::longNum: return "longNum"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::versioned::tests::BazUnion::Tag, 2> enum_values<::android::aidl::versioned::tests::BazUnion::Tag> = { ::android::aidl::versioned::tests::BazUnion::Tag::intNum, ::android::aidl::versioned::tests::BazUnion::Tag::longNum, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-cpp-source_gen_include_a0100644 0000000 0000000 00000000242 15172120304 033015 xustar000000000 0000000 134 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/versioned/tests/BnBazUnion.h 28 mtime=1776853188.6930000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/vers0100644 0000000 0000000 00000001432 15172120304 032750 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-cpp-source_gen_include_a0100644 0000000 0000000 00000000235 15172120304 033017 xustar000000000 0000000 129 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/versioned/tests/BnFoo.h 28 mtime=1776853188.6930000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/vers0100644 0000000 0000000 00000001420 15172120304 032745 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-cpp-source_gen_include_a0100644 0000000 0000000 00000000246 15172120304 033021 xustar000000000 0000000 138 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/versioned/tests/BnFooInterface.h 28 mtime=1776853188.6930000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/vers0100644 0000000 0000000 00000007516 15172120304 032761 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace versioned { namespace tests { class BnFooInterface : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_originalApi = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_acceptUnionAndReturnString = ::android::IBinder::FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_ignoreParcelablesAndRepeatInt = ::android::IBinder::FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_returnsLengthOfFooArray = ::android::IBinder::FIRST_CALL_TRANSACTION + 3; static constexpr uint32_t TRANSACTION_newApi = ::android::IBinder::FIRST_CALL_TRANSACTION + 4; static constexpr uint32_t TRANSACTION_getInterfaceVersion = ::android::IBinder::FIRST_CALL_TRANSACTION + 16777214; static constexpr uint32_t TRANSACTION_getInterfaceHash = ::android::IBinder::FIRST_CALL_TRANSACTION + 16777213; explicit BnFooInterface(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; int32_t getInterfaceVersion(); std::string getInterfaceHash(); }; // class BnFooInterface class IFooInterfaceDelegator : public BnFooInterface { public: explicit IFooInterfaceDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status originalApi() override { return _aidl_delegate->originalApi(); } ::android::binder::Status acceptUnionAndReturnString(const ::android::aidl::versioned::tests::BazUnion& u, ::std::string* _aidl_return) override { return _aidl_delegate->acceptUnionAndReturnString(u, _aidl_return); } ::android::binder::Status ignoreParcelablesAndRepeatInt(const ::android::aidl::versioned::tests::Foo& inFoo, ::android::aidl::versioned::tests::Foo* inoutFoo, ::android::aidl::versioned::tests::Foo* outFoo, int32_t value, int32_t* _aidl_return) override { return _aidl_delegate->ignoreParcelablesAndRepeatInt(inFoo, inoutFoo, outFoo, value, _aidl_return); } ::android::binder::Status returnsLengthOfFooArray(const ::std::vector<::android::aidl::versioned::tests::Foo>& foos, int32_t* _aidl_return) override { return _aidl_delegate->returnsLengthOfFooArray(foos, _aidl_return); } ::android::binder::Status newApi() override { return _aidl_delegate->newApi(); } int32_t getInterfaceVersion() override { int32_t _delegator_ver = BnFooInterface::getInterfaceVersion(); int32_t _impl_ver = _aidl_delegate->getInterfaceVersion(); return _delegator_ver < _impl_ver ? _delegator_ver : _impl_ver; } std::string getInterfaceHash() override { return _aidl_delegate->getInterfaceHash(); } private: ::android::sp _aidl_delegate; }; // class IFooInterfaceDelegator } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-cpp-source_gen_include_a0100644 0000000 0000000 00000000242 15172120304 033015 xustar000000000 0000000 134 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/versioned/tests/BpBazUnion.h 28 mtime=1776853188.6940000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/vers0100644 0000000 0000000 00000001432 15172120304 032750 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-cpp-source_gen_include_a0100644 0000000 0000000 00000000235 15172120304 033017 xustar000000000 0000000 129 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/versioned/tests/BpFoo.h 28 mtime=1776853188.6940000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/vers0100644 0000000 0000000 00000001420 15172120304 032745 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-cpp-source_gen_include_a0100644 0000000 0000000 00000000246 15172120304 033021 xustar000000000 0000000 138 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/versioned/tests/BpFooInterface.h 28 mtime=1776853188.6940000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/vers0100644 0000000 0000000 00000004142 15172120304 032751 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace versioned { namespace tests { class BpFooInterface : public ::android::BpInterface { public: explicit BpFooInterface(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpFooInterface() = default; ::android::binder::Status originalApi() override; ::android::binder::Status acceptUnionAndReturnString(const ::android::aidl::versioned::tests::BazUnion& u, ::std::string* _aidl_return) override; ::android::binder::Status ignoreParcelablesAndRepeatInt(const ::android::aidl::versioned::tests::Foo& inFoo, ::android::aidl::versioned::tests::Foo* inoutFoo, ::android::aidl::versioned::tests::Foo* outFoo, int32_t value, int32_t* _aidl_return) override; ::android::binder::Status returnsLengthOfFooArray(const ::std::vector<::android::aidl::versioned::tests::Foo>& foos, int32_t* _aidl_return) override; ::android::binder::Status newApi() override; int32_t getInterfaceVersion() override; std::string getInterfaceHash() override; private: int32_t cached_version_ = -1; std::string cached_hash_ = "-1"; std::mutex cached_hash_mutex_; }; // class BpFooInterface } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-cpp-source_gen_include_a0100644 0000000 0000000 00000000233 15172120304 033015 xustar000000000 0000000 127 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/versioned/tests/Foo.h 28 mtime=1776853188.6940000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/vers0100644 0000000 0000000 00000004402 15172120304 032750 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl */ #pragma once #include #include #include #include #include #include namespace android { namespace aidl { namespace versioned { namespace tests { class Foo : public ::android::Parcelable { public: int32_t intDefault42 = 42; inline bool operator==(const Foo& _rhs) const { return std::tie(intDefault42) == std::tie(_rhs.intDefault42); } inline bool operator<(const Foo& _rhs) const { return std::tie(intDefault42) < std::tie(_rhs.intDefault42); } inline bool operator!=(const Foo& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Foo& _rhs) const { return _rhs < *this; } inline bool operator>=(const Foo& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Foo& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.versioned.tests.Foo"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "Foo{"; _aidl_os << "intDefault42: " << ::android::internal::ToString(intDefault42); _aidl_os << "}"; return _aidl_os.str(); } }; // class Foo } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-cpp-source_gen_include_a0100644 0000000 0000000 00000000245 15172120304 033020 xustar000000000 0000000 137 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/versioned/tests/IFooInterface.h 28 mtime=1776853188.6940000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/include/android/aidl/vers0100644 0000000 0000000 00000007446 15172120304 032763 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 -t --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-cpp-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include namespace android::aidl::versioned::tests { class Foo; } // namespace android::aidl::versioned::tests namespace android { namespace aidl { namespace versioned { namespace tests { class IFooInterfaceDelegator; class IFooInterface : public ::android::IInterface { public: typedef IFooInterfaceDelegator DefaultDelegator; DECLARE_META_INTERFACE(FooInterface) static inline const int32_t VERSION = 3; static inline const std::string HASH = "70d76c61eb0c82288e924862c10b910d1b7d8cf8"; virtual ::android::binder::Status originalApi() = 0; virtual ::android::binder::Status acceptUnionAndReturnString(const ::android::aidl::versioned::tests::BazUnion& u, ::std::string* _aidl_return) = 0; virtual ::android::binder::Status ignoreParcelablesAndRepeatInt(const ::android::aidl::versioned::tests::Foo& inFoo, ::android::aidl::versioned::tests::Foo* inoutFoo, ::android::aidl::versioned::tests::Foo* outFoo, int32_t value, int32_t* _aidl_return) = 0; virtual ::android::binder::Status returnsLengthOfFooArray(const ::std::vector<::android::aidl::versioned::tests::Foo>& foos, int32_t* _aidl_return) = 0; virtual ::android::binder::Status newApi() = 0; virtual int32_t getInterfaceVersion() = 0; virtual std::string getInterfaceHash() = 0; }; // class IFooInterface class IFooInterfaceDefault : public IFooInterface { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status originalApi() override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status acceptUnionAndReturnString(const ::android::aidl::versioned::tests::BazUnion& /*u*/, ::std::string* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status ignoreParcelablesAndRepeatInt(const ::android::aidl::versioned::tests::Foo& /*inFoo*/, ::android::aidl::versioned::tests::Foo* /*inoutFoo*/, ::android::aidl::versioned::tests::Foo* /*outFoo*/, int32_t /*value*/, int32_t* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status returnsLengthOfFooArray(const ::std::vector<::android::aidl::versioned::tests::Foo>& /*foos*/, int32_t* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status newApi() override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } int32_t getInterfaceVersion() override { return 0; } std::string getInterfaceHash() override { return ""; } }; // class IFooInterfaceDefault } // namespace tests } // namespace versioned } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-cpp-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 033074 xustar000000000 0000000 28 mtime=1776853188.6950000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-cpp-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 030006 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-java-source_0100644 0000000 0000000 00000000034 15172120304 030456 xustar000000000 0000000 28 mtime=1776853188.6950000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-java-source/0040755 0000000 0000000 00000000000 15172120304 025463 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-java-source_gen_0100644 0000000 0000000 00000000034 15172120304 031307 xustar000000000 0000000 28 mtime=1776853188.6950000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-java-source/gen/0040755 0000000 0000000 00000000000 15172120304 026234 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-java-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 033007 xustar000000000 0000000 28 mtime=1776853188.6950000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-java-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 027654 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-java-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 033007 xustar000000000 0000000 28 mtime=1776853188.6950000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 030565 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-java-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 033007 xustar000000000 0000000 28 mtime=1776853188.6950000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/0040755 0000000 0000000 00000000000 15172120304 032563 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-java-source_gen_android_0100644 0000000 0000000 00000000217 15172120304 033012 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/tests/ 28 mtime=1776853188.6950000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/t0040755 0000000 0000000 00000000000 15172120304 032747 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-java-source_gen_android_0100644 0000000 0000000 00000000234 15172120304 033011 xustar000000000 0000000 128 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/tests/BazUnion.java 28 mtime=1776853188.6950000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000007154 15172120304 032755 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --rpc --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/tests/BazUnion.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-java-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl */ package android.aidl.versioned.tests; public final class BazUnion implements android.os.Parcelable { // tags for union fields public final static int intNum = 0; // int intNum; public final static int longNum = 1; // long longNum; private int _tag; private Object _value; public BazUnion() { int _value = 0; this._tag = intNum; this._value = _value; } private BazUnion(android.os.Parcel _aidl_parcel) { readFromParcel(_aidl_parcel); } private BazUnion(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public int getTag() { return _tag; } // int intNum; public static BazUnion intNum(int _value) { return new BazUnion(intNum, _value); } public int getIntNum() { _assertTag(intNum); return (int) _value; } public void setIntNum(int _value) { _set(intNum, _value); } // long longNum; public static BazUnion longNum(long _value) { return new BazUnion(longNum, _value); } public long getLongNum() { _assertTag(longNum); return (long) _value; } public void setLongNum(long _value) { _set(longNum, _value); } public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public BazUnion createFromParcel(android.os.Parcel _aidl_source) { return new BazUnion(_aidl_source); } @Override public BazUnion[] newArray(int _aidl_size) { return new BazUnion[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { _aidl_parcel.writeInt(_tag); switch (_tag) { case intNum: _aidl_parcel.writeInt(getIntNum()); break; case longNum: _aidl_parcel.writeLong(getLongNum()); break; } } public void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_tag; _aidl_tag = _aidl_parcel.readInt(); switch (_aidl_tag) { case intNum: { int _aidl_value; _aidl_value = _aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } case longNum: { long _aidl_value; _aidl_value = _aidl_parcel.readLong(); _set(_aidl_tag, _aidl_value); return; } } throw new IllegalArgumentException("union: unknown tag: " + _aidl_tag); } @Override public int describeContents() { int _mask = 0; switch (getTag()) { } return _mask; } private void _assertTag(int tag) { if (getTag() != tag) { throw new IllegalStateException("bad access: " + _tagString(tag) + ", " + _tagString(getTag()) + " is available."); } } private String _tagString(int _tag) { switch (_tag) { case intNum: return "intNum"; case longNum: return "longNum"; } throw new IllegalStateException("unknown field: " + _tag); } private void _set(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public static @interface Tag { public static final int intNum = 0; public static final int longNum = 1; } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-java-source_gen_android_0100644 0000000 0000000 00000000236 15172120304 033013 xustar000000000 0000000 130 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/tests/BazUnion.java.d 28 mtime=1776853188.6950000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000000363 15172120304 032750 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/tests/BazUnion.java : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-java-source_gen_android_0100644 0000000 0000000 00000000227 15172120304 033013 xustar000000000 0000000 123 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/tests/Foo.java 28 mtime=1776853188.6950000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000004566 15172120304 032761 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --rpc --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/tests/Foo.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-java-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl */ package android.aidl.versioned.tests; @android.annotation.SuppressLint(value = {"NewApi"}) public class Foo implements android.os.Parcelable { public int intDefault42 = 42; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public Foo createFromParcel(android.os.Parcel _aidl_source) { Foo _aidl_out = new Foo(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public Foo[] newArray(int _aidl_size) { return new Foo[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(intDefault42); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; intDefault42 = _aidl_parcel.readInt(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-java-source_gen_android_0100644 0000000 0000000 00000000231 15172120304 033006 xustar000000000 0000000 125 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/tests/Foo.java.d 28 mtime=1776853188.6950000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000000351 15172120304 032745 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/tests/Foo.java : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-java-source_gen_android_0100644 0000000 0000000 00000000241 15172120304 033007 xustar000000000 0000000 133 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/tests/IFooInterface.java 28 mtime=1776853188.6960000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000036024 15172120304 032753 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --rpc --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/tests/IFooInterface.java.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-java-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/IFooInterface.aidl */ package android.aidl.versioned.tests; public interface IFooInterface extends android.os.IInterface { /** * The version of this interface that the caller is built against. * This might be different from what {@link #getInterfaceVersion() * getInterfaceVersion} returns as that is the version of the interface * that the remote object is implementing. */ public static final int VERSION = 3; public static final String HASH = "70d76c61eb0c82288e924862c10b910d1b7d8cf8"; /** Default implementation for IFooInterface. */ public static class Default implements android.aidl.versioned.tests.IFooInterface { @Override public void originalApi() throws android.os.RemoteException { } @Override public java.lang.String acceptUnionAndReturnString(android.aidl.versioned.tests.BazUnion u) throws android.os.RemoteException { return null; } @Override public int ignoreParcelablesAndRepeatInt(android.aidl.versioned.tests.Foo inFoo, android.aidl.versioned.tests.Foo inoutFoo, android.aidl.versioned.tests.Foo outFoo, int value) throws android.os.RemoteException { return 0; } @Override public int returnsLengthOfFooArray(android.aidl.versioned.tests.Foo[] foos) throws android.os.RemoteException { return 0; } @Override public void newApi() throws android.os.RemoteException { } @Override public int getInterfaceVersion() { return 0; } @Override public String getInterfaceHash() { return ""; } @Override public android.os.IBinder asBinder() { return null; } } /** Delegator implementation for IFooInterface. */ public static class Delegator extends android.aidl.versioned.tests.IFooInterface.Stub { public Delegator(android.aidl.versioned.tests.IFooInterface impl) { this.mImpl = impl; } @Override public String getInterfaceHash() throws android.os.RemoteException { return mImpl.getInterfaceHash(); } @Override public int getInterfaceVersion() throws android.os.RemoteException { int implVer = mImpl.getInterfaceVersion(); return VERSION < implVer ? VERSION : implVer; } @Override public void originalApi() throws android.os.RemoteException { mImpl.originalApi(); } @Override public java.lang.String acceptUnionAndReturnString(android.aidl.versioned.tests.BazUnion u) throws android.os.RemoteException { return mImpl.acceptUnionAndReturnString(u); } @Override public int ignoreParcelablesAndRepeatInt(android.aidl.versioned.tests.Foo inFoo, android.aidl.versioned.tests.Foo inoutFoo, android.aidl.versioned.tests.Foo outFoo, int value) throws android.os.RemoteException { return mImpl.ignoreParcelablesAndRepeatInt(inFoo,inoutFoo,outFoo,value); } @Override public int returnsLengthOfFooArray(android.aidl.versioned.tests.Foo[] foos) throws android.os.RemoteException { return mImpl.returnsLengthOfFooArray(foos); } @Override public void newApi() throws android.os.RemoteException { mImpl.newApi(); } android.aidl.versioned.tests.IFooInterface mImpl; } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.versioned.tests.IFooInterface { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.versioned.tests.IFooInterface interface, * generating a proxy if needed. */ public static android.aidl.versioned.tests.IFooInterface asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.versioned.tests.IFooInterface))) { return ((android.aidl.versioned.tests.IFooInterface)iin); } return new android.aidl.versioned.tests.IFooInterface.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } else if (code == TRANSACTION_getInterfaceVersion) { reply.writeNoException(); reply.writeInt(getInterfaceVersion()); return true; } else if (code == TRANSACTION_getInterfaceHash) { reply.writeNoException(); reply.writeString(getInterfaceHash()); return true; } switch (code) { case TRANSACTION_originalApi: { this.originalApi(); reply.writeNoException(); break; } case TRANSACTION_acceptUnionAndReturnString: { android.aidl.versioned.tests.BazUnion _arg0; _arg0 = data.readTypedObject(android.aidl.versioned.tests.BazUnion.CREATOR); data.enforceNoDataAvail(); java.lang.String _result = this.acceptUnionAndReturnString(_arg0); reply.writeNoException(); reply.writeString(_result); break; } case TRANSACTION_ignoreParcelablesAndRepeatInt: { android.aidl.versioned.tests.Foo _arg0; _arg0 = data.readTypedObject(android.aidl.versioned.tests.Foo.CREATOR); android.aidl.versioned.tests.Foo _arg1; _arg1 = data.readTypedObject(android.aidl.versioned.tests.Foo.CREATOR); android.aidl.versioned.tests.Foo _arg2; _arg2 = new android.aidl.versioned.tests.Foo(); int _arg3; _arg3 = data.readInt(); data.enforceNoDataAvail(); int _result = this.ignoreParcelablesAndRepeatInt(_arg0, _arg1, _arg2, _arg3); reply.writeNoException(); reply.writeInt(_result); reply.writeTypedObject(_arg1, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); reply.writeTypedObject(_arg2, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_returnsLengthOfFooArray: { android.aidl.versioned.tests.Foo[] _arg0; _arg0 = data.createTypedArray(android.aidl.versioned.tests.Foo.CREATOR); data.enforceNoDataAvail(); int _result = this.returnsLengthOfFooArray(_arg0); reply.writeNoException(); reply.writeInt(_result); break; } case TRANSACTION_newApi: { this.newApi(); reply.writeNoException(); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.versioned.tests.IFooInterface { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } private int mCachedVersion = -1; private String mCachedHash = "-1"; @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public void originalApi() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_originalApi, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method originalApi is unimplemented."); } _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } @Override public java.lang.String acceptUnionAndReturnString(android.aidl.versioned.tests.BazUnion u) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.lang.String _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(u, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_acceptUnionAndReturnString, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method acceptUnionAndReturnString is unimplemented."); } _reply.readException(); _result = _reply.readString(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int ignoreParcelablesAndRepeatInt(android.aidl.versioned.tests.Foo inFoo, android.aidl.versioned.tests.Foo inoutFoo, android.aidl.versioned.tests.Foo outFoo, int value) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); int _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(inFoo, 0); _data.writeTypedObject(inoutFoo, 0); _data.writeInt(value); boolean _status = mRemote.transact(Stub.TRANSACTION_ignoreParcelablesAndRepeatInt, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method ignoreParcelablesAndRepeatInt is unimplemented."); } _reply.readException(); _result = _reply.readInt(); if ((0!=_reply.readInt())) { inoutFoo.readFromParcel(_reply); } if ((0!=_reply.readInt())) { outFoo.readFromParcel(_reply); } } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int returnsLengthOfFooArray(android.aidl.versioned.tests.Foo[] foos) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); int _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedArray(foos, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_returnsLengthOfFooArray, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method returnsLengthOfFooArray is unimplemented."); } _reply.readException(); _result = _reply.readInt(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public void newApi() throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_newApi, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method newApi is unimplemented."); } _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } @Override public int getInterfaceVersion() throws android.os.RemoteException { if (mCachedVersion == -1) { android.os.Parcel data = android.os.Parcel.obtain(asBinder()); android.os.Parcel reply = android.os.Parcel.obtain(); try { data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getInterfaceVersion, data, reply, 0); reply.readException(); mCachedVersion = reply.readInt(); } finally { reply.recycle(); data.recycle(); } } return mCachedVersion; } @Override public synchronized String getInterfaceHash() throws android.os.RemoteException { if ("-1".equals(mCachedHash)) { android.os.Parcel data = android.os.Parcel.obtain(asBinder()); android.os.Parcel reply = android.os.Parcel.obtain(); try { data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getInterfaceHash, data, reply, 0); reply.readException(); mCachedHash = reply.readString(); } finally { reply.recycle(); data.recycle(); } } return mCachedHash; } } static final int TRANSACTION_originalApi = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); static final int TRANSACTION_acceptUnionAndReturnString = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1); static final int TRANSACTION_ignoreParcelablesAndRepeatInt = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2); static final int TRANSACTION_returnsLengthOfFooArray = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3); static final int TRANSACTION_newApi = (android.os.IBinder.FIRST_CALL_TRANSACTION + 4); static final int TRANSACTION_getInterfaceVersion = (android.os.IBinder.FIRST_CALL_TRANSACTION + 16777214); static final int TRANSACTION_getInterfaceHash = (android.os.IBinder.FIRST_CALL_TRANSACTION + 16777213); } /** @hide */ public static final java.lang.String DESCRIPTOR = "android$aidl$versioned$tests$IFooInterface".replace('$', '.'); public void originalApi() throws android.os.RemoteException; public java.lang.String acceptUnionAndReturnString(android.aidl.versioned.tests.BazUnion u) throws android.os.RemoteException; public int ignoreParcelablesAndRepeatInt(android.aidl.versioned.tests.Foo inFoo, android.aidl.versioned.tests.Foo inoutFoo, android.aidl.versioned.tests.Foo outFoo, int value) throws android.os.RemoteException; public int returnsLengthOfFooArray(android.aidl.versioned.tests.Foo[] foos) throws android.os.RemoteException; public void newApi() throws android.os.RemoteException; public int getInterfaceVersion() throws android.os.RemoteException; public String getInterfaceHash() throws android.os.RemoteException; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-java-source_gen_android_0100644 0000000 0000000 00000000243 15172120304 033011 xustar000000000 0000000 135 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/tests/IFooInterface.java.d 28 mtime=1776853188.6960000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000000714 15172120304 032750 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-java-source/gen/android/aidl/versioned/tests/IFooInterface.java : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/IFooInterface.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-java-source_gen_timestam0100644 0000000 0000000 00000000034 15172120304 033053 xustar000000000 0000000 28 mtime=1776853188.6960000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-java-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 030145 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-ndk-source_0100644 0000000 0000000 00000000034 15172120304 030311 xustar000000000 0000000 28 mtime=1776853188.6960000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/0040755 0000000 0000000 00000000000 15172120304 025316 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-ndk-source_gen_0100644 0000000 0000000 00000000034 15172120304 031142 xustar000000000 0000000 28 mtime=1776853188.6960000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/0040755 0000000 0000000 00000000000 15172120304 026067 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-ndk-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 032642 xustar000000000 0000000 28 mtime=1776853188.6960000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 027507 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-ndk-source_gen_android_a0100644 0000000 0000000 00000000034 15172120304 033003 xustar000000000 0000000 28 mtime=1776853188.6960000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 030420 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-ndk-source_gen_android_a0100644 0000000 0000000 00000000034 15172120304 033003 xustar000000000 0000000 28 mtime=1776853188.6960000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/versioned/0040755 0000000 0000000 00000000000 15172120304 032416 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-ndk-source_gen_android_a0100644 0000000 0000000 00000000216 15172120304 033005 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/versioned/tests/ 28 mtime=1776853188.6960000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/versioned/te0040755 0000000 0000000 00000000000 15172120304 032747 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-ndk-source_gen_android_a0100644 0000000 0000000 00000000232 15172120304 033003 xustar000000000 0000000 126 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/versioned/tests/BazUnion.cpp 28 mtime=1776853188.6960000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000005171 15172120304 032752 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl */ #include "aidl/android/aidl/versioned/tests/BazUnion.h" #include namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { const char* BazUnion::descriptor = "android.aidl.versioned.tests.BazUnion"; binder_status_t BazUnion::readFromParcel(const AParcel* _parcel) { binder_status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_tag)) != STATUS_OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case intNum: { int32_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case longNum: { int64_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } } return STATUS_BAD_VALUE; } binder_status_t BazUnion::writeToParcel(AParcel* _parcel) const { binder_status_t _aidl_ret_status = ::ndk::AParcel_writeData(_parcel, static_cast(getTag())); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; switch (getTag()) { case intNum: return ::ndk::AParcel_writeData(_parcel, get()); case longNum: return ::ndk::AParcel_writeData(_parcel, get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-ndk-source_gen_android_a0100644 0000000 0000000 00000000234 15172120304 033005 xustar000000000 0000000 128 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/versioned/tests/BazUnion.cpp.d 28 mtime=1776853188.6960000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000000361 15172120304 032746 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/versioned/tests/BazUnion.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-ndk-source_gen_android_a0100644 0000000 0000000 00000000225 15172120304 033005 xustar000000000 0000000 121 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/versioned/tests/Foo.cpp 28 mtime=1776853188.6970000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000005301 15172120304 032745 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl */ #include "aidl/android/aidl/versioned/tests/Foo.h" #include namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { const char* Foo::descriptor = "android.aidl.versioned.tests.Foo"; binder_status_t Foo::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &intDefault42); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t Foo::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, intDefault42); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-ndk-source_gen_android_a0100644 0000000 0000000 00000000227 15172120304 033007 xustar000000000 0000000 123 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/versioned/tests/Foo.cpp.d 28 mtime=1776853188.6970000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000000347 15172120304 032752 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/versioned/tests/Foo.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-ndk-source_gen_android_a0100644 0000000 0000000 00000000237 15172120304 033010 xustar000000000 0000000 131 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/versioned/tests/IFooInterface.cpp 28 mtime=1776853188.6970000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000053573 15172120304 032763 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/IFooInterface.aidl */ #include "aidl/android/aidl/versioned/tests/IFooInterface.h" #include #include #include namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { static binder_status_t _aidl_android_aidl_versioned_tests_IFooInterface_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*originalApi*/): { ::ndk::ScopedAStatus _aidl_status = _aidl_impl->originalApi(); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } case (FIRST_CALL_TRANSACTION + 1 /*acceptUnionAndReturnString*/): { ::aidl::android::aidl::versioned::tests::BazUnion in_u; std::string _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_u); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->acceptUnionAndReturnString(in_u, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 2 /*ignoreParcelablesAndRepeatInt*/): { ::aidl::android::aidl::versioned::tests::Foo in_inFoo; ::aidl::android::aidl::versioned::tests::Foo in_inoutFoo; ::aidl::android::aidl::versioned::tests::Foo out_outFoo; int32_t in_value; int32_t _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_inFoo); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_inoutFoo); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_value); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->ignoreParcelablesAndRepeatInt(in_inFoo, &in_inoutFoo, &out_outFoo, in_value, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, in_inoutFoo); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, out_outFoo); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 3 /*returnsLengthOfFooArray*/): { std::vector<::aidl::android::aidl::versioned::tests::Foo> in_foos; int32_t _aidl_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_foos); if (_aidl_ret_status != STATUS_OK) break; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->returnsLengthOfFooArray(in_foos, &_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 4 /*newApi*/): { ::ndk::ScopedAStatus _aidl_status = _aidl_impl->newApi(); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } case (FIRST_CALL_TRANSACTION + 16777214 /*getInterfaceVersion*/): { int32_t _aidl_return; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->getInterfaceVersion(&_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 16777213 /*getInterfaceHash*/): { std::string _aidl_return; ::ndk::ScopedAStatus _aidl_status = _aidl_impl->getInterfaceHash(&_aidl_return); _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_versioned_tests_IFooInterface_clazz = ::ndk::ICInterface::defineClass(IFooInterface::descriptor, _aidl_android_aidl_versioned_tests_IFooInterface_onTransact); BpFooInterface::BpFooInterface(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} BpFooInterface::~BpFooInterface() {} ::ndk::ScopedAStatus BpFooInterface::originalApi() { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*originalApi*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->originalApi(); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpFooInterface::acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& in_u, std::string* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_u); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 1 /*acceptUnionAndReturnString*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->acceptUnionAndReturnString(in_u, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpFooInterface::ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& in_inFoo, ::aidl::android::aidl::versioned::tests::Foo* in_inoutFoo, ::aidl::android::aidl::versioned::tests::Foo* out_outFoo, int32_t in_value, int32_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_inFoo); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), *in_inoutFoo); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_value); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 2 /*ignoreParcelablesAndRepeatInt*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->ignoreParcelablesAndRepeatInt(in_inFoo, in_inoutFoo, out_outFoo, in_value, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), in_inoutFoo); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), out_outFoo); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpFooInterface::returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& in_foos, int32_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_foos); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 3 /*returnsLengthOfFooArray*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->returnsLengthOfFooArray(in_foos, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpFooInterface::newApi() { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 4 /*newApi*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->newApi(); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpFooInterface::getInterfaceVersion(int32_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; if (_aidl_cached_version != -1) { *_aidl_return = _aidl_cached_version; _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); return _aidl_status; } ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 16777214 /*getInterfaceVersion*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->getInterfaceVersion(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_cached_version = *_aidl_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } ::ndk::ScopedAStatus BpFooInterface::getInterfaceHash(std::string* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; const std::lock_guard lock(_aidl_cached_hash_mutex); if (_aidl_cached_hash != "-1") { *_aidl_return = _aidl_cached_hash; _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); return _aidl_status; } ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 16777213 /*getInterfaceHash*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IFooInterface::getDefaultImpl()) { _aidl_status = IFooInterface::getDefaultImpl()->getInterfaceHash(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_cached_hash = *_aidl_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: return _aidl_status; } // Source for BnFooInterface BnFooInterface::BnFooInterface() {} BnFooInterface::~BnFooInterface() {} ::ndk::SpAIBinder BnFooInterface::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_versioned_tests_IFooInterface_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } ::ndk::ScopedAStatus BnFooInterface::getInterfaceVersion(int32_t* _aidl_return) { *_aidl_return = IFooInterface::version; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::ScopedAStatus BnFooInterface::getInterfaceHash(std::string* _aidl_return) { *_aidl_return = IFooInterface::hash; return ::ndk::ScopedAStatus(AStatus_newOk()); } // Source for IFooInterface const char* IFooInterface::descriptor = "android.aidl.versioned.tests.IFooInterface"; IFooInterface::IFooInterface() {} IFooInterface::~IFooInterface() {} std::shared_ptr IFooInterface::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_versioned_tests_IFooInterface_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t IFooInterface::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t IFooInterface::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = IFooInterface::fromBinder(binder); return STATUS_OK; } bool IFooInterface::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!IFooInterface::default_impl); if (impl) { IFooInterface::default_impl = impl; return true; } return false; } const std::shared_ptr& IFooInterface::getDefaultImpl() { return IFooInterface::default_impl; } std::shared_ptr IFooInterface::default_impl = nullptr; ::ndk::ScopedAStatus IFooInterfaceDefault::originalApi() { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus IFooInterfaceDefault::acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& /*in_u*/, std::string* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus IFooInterfaceDefault::ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& /*in_inFoo*/, ::aidl::android::aidl::versioned::tests::Foo* /*in_inoutFoo*/, ::aidl::android::aidl::versioned::tests::Foo* /*out_outFoo*/, int32_t /*in_value*/, int32_t* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus IFooInterfaceDefault::returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& /*in_foos*/, int32_t* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus IFooInterfaceDefault::newApi() { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus IFooInterfaceDefault::getInterfaceVersion(int32_t* _aidl_return) { *_aidl_return = 0; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::ScopedAStatus IFooInterfaceDefault::getInterfaceHash(std::string* _aidl_return) { *_aidl_return = ""; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::SpAIBinder IFooInterfaceDefault::asBinder() { return ::ndk::SpAIBinder(); } bool IFooInterfaceDefault::isRemote() { return false; } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-ndk-source_gen_android_a0100644 0000000 0000000 00000000241 15172120304 033003 xustar000000000 0000000 133 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/versioned/tests/IFooInterface.cpp.d 28 mtime=1776853188.6970000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/versioned/te0100644 0000000 0000000 00000000712 15172120304 032746 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/android/aidl/versioned/tests/IFooInterface.cpp : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/IFooInterface.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-ndk-source_gen_include_0100644 0000000 0000000 00000000034 15172120304 032645 xustar000000000 0000000 28 mtime=1776853188.6970000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/include/0040755 0000000 0000000 00000000000 15172120304 027512 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-ndk-source_gen_include_a0100644 0000000 0000000 00000000034 15172120304 033006 xustar000000000 0000000 28 mtime=1776853188.6970000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/0040755 0000000 0000000 00000000000 15172120304 030423 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-ndk-source_gen_include_a0100644 0000000 0000000 00000000034 15172120304 033006 xustar000000000 0000000 28 mtime=1776853188.6970000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/0040755 0000000 0000000 00000000000 15172120304 032043 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-ndk-source_gen_include_a0100644 0000000 0000000 00000000213 15172120304 033005 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl/ 28 mtime=1776853188.6970000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl0040755 0000000 0000000 00000000000 15172120304 032675 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-ndk-source_gen_include_a0100644 0000000 0000000 00000000225 15172120304 033010 xustar000000000 0000000 121 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl/versioned/ 28 mtime=1776853188.6970000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl0040755 0000000 0000000 00000000000 15172120304 032675 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-ndk-source_gen_include_a0100644 0000000 0000000 00000000233 15172120304 033007 xustar000000000 0000000 127 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl/versioned/tests/ 28 mtime=1776853188.6970000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl0040755 0000000 0000000 00000000000 15172120304 032675 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-ndk-source_gen_include_a0100644 0000000 0000000 00000000245 15172120304 033012 xustar000000000 0000000 137 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BazUnion.h 28 mtime=1776853188.6970000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl0100644 0000000 0000000 00000012672 15172120304 032704 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { class BazUnion { public: typedef std::false_type fixed_size; static const char* descriptor; enum class Tag : int32_t { intNum = 0, longNum = 1, }; // Expose tag symbols for legacy code static const inline Tag intNum = Tag::intNum; static const inline Tag longNum = Tag::longNum; template static constexpr bool _not_self = !std::is_same_v>, BazUnion>; BazUnion() : _value(std::in_place_index(intNum)>, int32_t(0)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr BazUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit BazUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static BazUnion make(_Tp&&... _args) { return BazUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static BazUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return BazUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } binder_status_t readFromParcel(const AParcel* _parcel); binder_status_t writeToParcel(AParcel* _parcel) const; inline bool operator==(const BazUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const BazUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const BazUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const BazUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const BazUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const BazUnion& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream os; os << "BazUnion{"; switch (getTag()) { case intNum: os << "intNum: " << ::android::internal::ToString(get()); break; case longNum: os << "longNum: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant _value; }; } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { [[nodiscard]] static inline std::string toString(BazUnion::Tag val) { switch(val) { case BazUnion::Tag::intNum: return "intNum"; case BazUnion::Tag::longNum: return "longNum"; default: return std::to_string(static_cast(val)); } } } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::versioned::tests::BazUnion::Tag::intNum, aidl::android::aidl::versioned::tests::BazUnion::Tag::longNum, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-ndk-source_gen_include_a0100644 0000000 0000000 00000000247 15172120304 033014 xustar000000000 0000000 139 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BnBazUnion.h 28 mtime=1776853188.6980000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl0100644 0000000 0000000 00000001432 15172120304 032674 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-ndk-source_gen_include_a0100644 0000000 0000000 00000000242 15172120304 033007 xustar000000000 0000000 134 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BnFoo.h 28 mtime=1776853188.6980000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl0100644 0000000 0000000 00000001420 15172120304 032671 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-ndk-source_gen_include_a0100644 0000000 0000000 00000000253 15172120304 033011 xustar000000000 0000000 143 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BnFooInterface.h 28 mtime=1776853188.6990000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl0100644 0000000 0000000 00000006100 15172120304 032671 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include "aidl/android/aidl/versioned/tests/IFooInterface.h" #include #include #ifndef __BIONIC__ #ifndef __assert2 #define __assert2(a,b,c,d) ((void)0) #endif #endif namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { class BnFooInterface : public ::ndk::BnCInterface { public: BnFooInterface(); virtual ~BnFooInterface(); ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) final; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) final; protected: ::ndk::SpAIBinder createBinder() override; private: }; class IFooInterfaceDelegator : public BnFooInterface { public: explicit IFooInterfaceDelegator(const std::shared_ptr &impl) : _impl(impl) { int32_t _impl_ver = 0; if (!impl->getInterfaceVersion(&_impl_ver).isOk()) {; __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Delegator failed to get version of the implementation."); } if (_impl_ver != IFooInterface::version) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Mismatched versions of delegator and implementation is not allowed."); } } ::ndk::ScopedAStatus originalApi() override { return _impl->originalApi(); } ::ndk::ScopedAStatus acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& in_u, std::string* _aidl_return) override { return _impl->acceptUnionAndReturnString(in_u, _aidl_return); } ::ndk::ScopedAStatus ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& in_inFoo, ::aidl::android::aidl::versioned::tests::Foo* in_inoutFoo, ::aidl::android::aidl::versioned::tests::Foo* out_outFoo, int32_t in_value, int32_t* _aidl_return) override { return _impl->ignoreParcelablesAndRepeatInt(in_inFoo, in_inoutFoo, out_outFoo, in_value, _aidl_return); } ::ndk::ScopedAStatus returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& in_foos, int32_t* _aidl_return) override { return _impl->returnsLengthOfFooArray(in_foos, _aidl_return); } ::ndk::ScopedAStatus newApi() override { return _impl->newApi(); } protected: private: std::shared_ptr _impl; }; } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-ndk-source_gen_include_a0100644 0000000 0000000 00000000247 15172120304 033014 xustar000000000 0000000 139 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BpBazUnion.h 28 mtime=1776853188.6990000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl0100644 0000000 0000000 00000001432 15172120304 032674 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging/android/aidl/versioned/tests/BazUnion.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-ndk-source_gen_include_a0100644 0000000 0000000 00000000242 15172120304 033007 xustar000000000 0000000 134 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BpFoo.h 28 mtime=1776853188.6990000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl0100644 0000000 0000000 00000001420 15172120304 032671 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-ndk-source_gen_include_a0100644 0000000 0000000 00000000253 15172120304 033011 xustar000000000 0000000 143 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl/versioned/tests/BpFooInterface.h 28 mtime=1776853188.6990000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl0100644 0000000 0000000 00000004177 15172120304 032705 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include "aidl/android/aidl/versioned/tests/IFooInterface.h" #include namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { class BpFooInterface : public ::ndk::BpCInterface { public: explicit BpFooInterface(const ::ndk::SpAIBinder& binder); virtual ~BpFooInterface(); ::ndk::ScopedAStatus originalApi() override; ::ndk::ScopedAStatus acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& in_u, std::string* _aidl_return) override; ::ndk::ScopedAStatus ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& in_inFoo, ::aidl::android::aidl::versioned::tests::Foo* in_inoutFoo, ::aidl::android::aidl::versioned::tests::Foo* out_outFoo, int32_t in_value, int32_t* _aidl_return) override; ::ndk::ScopedAStatus returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& in_foos, int32_t* _aidl_return) override; ::ndk::ScopedAStatus newApi() override; ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) override; int32_t _aidl_cached_version = -1; std::string _aidl_cached_hash = "-1"; std::mutex _aidl_cached_hash_mutex; }; } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-ndk-source_gen_include_a0100644 0000000 0000000 00000000240 15172120304 033005 xustar000000000 0000000 132 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl/versioned/tests/Foo.h 28 mtime=1776853188.6990000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl0100644 0000000 0000000 00000004527 15172120304 032704 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging/android/aidl/versioned/tests/Foo.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl */ #pragma once #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { class Foo { public: typedef std::false_type fixed_size; static const char* descriptor; int32_t intDefault42 = 42; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const Foo& _rhs) const { return std::tie(intDefault42) == std::tie(_rhs.intDefault42); } inline bool operator<(const Foo& _rhs) const { return std::tie(intDefault42) < std::tie(_rhs.intDefault42); } inline bool operator!=(const Foo& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Foo& _rhs) const { return _rhs < *this; } inline bool operator>=(const Foo& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Foo& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "Foo{"; _aidl_os << "intDefault42: " << ::android::internal::ToString(intDefault42); _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-ndk-source_gen_include_a0100644 0000000 0000000 00000000252 15172120304 033010 xustar000000000 0000000 142 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl/versioned/tests/IFooInterface.h 28 mtime=1776853188.6990000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/include/aidl/android/aidl0100644 0000000 0000000 00000010676 15172120304 032706 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging/android/aidl/versioned/tests/IFooInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-ndk-source/gen/staging -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/IFooInterface.aidl */ #pragma once #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl::android::aidl::versioned::tests { class Foo; } // namespace aidl::android::aidl::versioned::tests namespace aidl { namespace android { namespace aidl { namespace versioned { namespace tests { class IFooInterfaceDelegator; class IFooInterface : public ::ndk::ICInterface { public: typedef IFooInterfaceDelegator DefaultDelegator; static const char* descriptor; IFooInterface(); virtual ~IFooInterface(); static inline const int32_t version = 3; static inline const std::string hash = "70d76c61eb0c82288e924862c10b910d1b7d8cf8"; static constexpr uint32_t TRANSACTION_originalApi = FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_acceptUnionAndReturnString = FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_ignoreParcelablesAndRepeatInt = FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_returnsLengthOfFooArray = FIRST_CALL_TRANSACTION + 3; static constexpr uint32_t TRANSACTION_newApi = FIRST_CALL_TRANSACTION + 4; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus originalApi() = 0; virtual ::ndk::ScopedAStatus acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& in_u, std::string* _aidl_return) = 0; virtual ::ndk::ScopedAStatus ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& in_inFoo, ::aidl::android::aidl::versioned::tests::Foo* in_inoutFoo, ::aidl::android::aidl::versioned::tests::Foo* out_outFoo, int32_t in_value, int32_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& in_foos, int32_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus newApi() = 0; virtual ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) = 0; private: static std::shared_ptr default_impl; }; class IFooInterfaceDefault : public IFooInterface { public: ::ndk::ScopedAStatus originalApi() override; ::ndk::ScopedAStatus acceptUnionAndReturnString(const ::aidl::android::aidl::versioned::tests::BazUnion& in_u, std::string* _aidl_return) override; ::ndk::ScopedAStatus ignoreParcelablesAndRepeatInt(const ::aidl::android::aidl::versioned::tests::Foo& in_inFoo, ::aidl::android::aidl::versioned::tests::Foo* in_inoutFoo, ::aidl::android::aidl::versioned::tests::Foo* out_outFoo, int32_t in_value, int32_t* _aidl_return) override; ::ndk::ScopedAStatus returnsLengthOfFooArray(const std::vector<::aidl::android::aidl::versioned::tests::Foo>& in_foos, int32_t* _aidl_return) override; ::ndk::ScopedAStatus newApi() override; ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; } // namespace tests } // namespace versioned } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-ndk-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 033066 xustar000000000 0000000 28 mtime=1776853188.6990000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-ndk-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 030000 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-rust-source_0100644 0000000 0000000 00000000034 15172120304 030532 xustar000000000 0000000 28 mtime=1776853188.6990000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-rust-source/0040755 0000000 0000000 00000000000 15172120304 025537 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-rust-source_gen_0100644 0000000 0000000 00000000034 15172120304 031363 xustar000000000 0000000 28 mtime=1776853188.6990000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-rust-source/gen/0040755 0000000 0000000 00000000000 15172120304 026310 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-rust-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 033063 xustar000000000 0000000 28 mtime=1776853188.6990000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-rust-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 027730 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-rust-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 033063 xustar000000000 0000000 28 mtime=1776853188.6990000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 030641 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-rust-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 033063 xustar000000000 0000000 28 mtime=1776853188.6990000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/0040755 0000000 0000000 00000000000 15172120304 032637 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-rust-source_gen_android_0100644 0000000 0000000 00000000217 15172120304 033066 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/tests/ 28 mtime=1776853188.6990000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/t0040755 0000000 0000000 00000000000 15172120304 033023 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-rust-source_gen_android_0100644 0000000 0000000 00000000232 15172120304 033063 xustar000000000 0000000 126 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/tests/BazUnion.rs 28 mtime=1776853188.6990000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000004412 15172120304 033023 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/tests/BazUnion.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-rust-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub enum r#BazUnion { IntNum(i32), LongNum(i64), } impl Default for r#BazUnion { fn default() -> Self { Self::IntNum(0) } } impl binder::Parcelable for r#BazUnion { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { match self { Self::IntNum(v) => { parcel.write(&0i32)?; parcel.write(v) } Self::LongNum(v) => { parcel.write(&1i32)?; parcel.write(v) } } } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { let tag: i32 = parcel.read()?; match tag { 0 => { let value: i32 = parcel.read()?; *self = Self::IntNum(value); Ok(()) } 1 => { let value: i64 = parcel.read()?; *self = Self::LongNum(value); Ok(()) } _ => { Err(binder::StatusCode::BAD_VALUE) } } } } binder::impl_serialize_for_parcelable!(r#BazUnion); binder::impl_deserialize_for_parcelable!(r#BazUnion); impl binder::binder_impl::ParcelableMetadata for r#BazUnion { fn get_descriptor() -> &'static str { "android.aidl.versioned.tests.BazUnion" } } pub mod r#Tag { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#Tag : [i32; 2] { r#intNum = 0, r#longNum = 1, } } } pub(crate) mod mangled { pub use super::r#BazUnion as _7_android_4_aidl_9_versioned_5_tests_8_BazUnion; pub use super::r#Tag::r#Tag as _7_android_4_aidl_9_versioned_5_tests_8_BazUnion_3_Tag; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-rust-source_gen_android_0100644 0000000 0000000 00000000234 15172120304 033065 xustar000000000 0000000 128 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/tests/BazUnion.rs.d 28 mtime=1776853188.6990000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000000361 15172120304 033022 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/tests/BazUnion.rs : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-rust-source_gen_android_0100644 0000000 0000000 00000000225 15172120304 033065 xustar000000000 0000000 121 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/tests/Foo.rs 28 mtime=1776853188.7000000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000003251 15172120304 033023 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/tests/Foo.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-rust-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #[derive(Debug)] pub struct r#Foo { pub r#intDefault42: i32, } impl Default for r#Foo { fn default() -> Self { Self { r#intDefault42: 42, } } } impl binder::Parcelable for r#Foo { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#intDefault42)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#intDefault42 = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#Foo); binder::impl_deserialize_for_parcelable!(r#Foo); impl binder::binder_impl::ParcelableMetadata for r#Foo { fn get_descriptor() -> &'static str { "android.aidl.versioned.tests.Foo" } } pub(crate) mod mangled { pub use super::r#Foo as _7_android_4_aidl_9_versioned_5_tests_3_Foo; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-rust-source_gen_android_0100644 0000000 0000000 00000000227 15172120304 033067 xustar000000000 0000000 123 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/tests/Foo.rs.d 28 mtime=1776853188.7000000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000000347 15172120304 033026 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/tests/Foo.rs : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-rust-source_gen_android_0100644 0000000 0000000 00000000237 15172120304 033070 xustar000000000 0000000 131 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/tests/IFooInterface.rs 28 mtime=1776853188.7000000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000067453 15172120304 033041 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust --structured --version 3 --hash 70d76c61eb0c82288e924862c10b910d1b7d8cf8 --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/tests/IFooInterface.rs.d -o out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-rust-source/gen -Nsystem/tools/aidl/aidl_api/aidl-test-versioned-interface/3 system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/IFooInterface.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { IFooInterface["android.aidl.versioned.tests.IFooInterface"] { native: BnFooInterface(on_transact), proxy: BpFooInterface { cached_version: std::sync::atomic::AtomicI32 = std::sync::atomic::AtomicI32::new(-1), cached_hash: std::sync::Mutex> = std::sync::Mutex::new(None) }, async: IFooInterfaceAsync, } } pub trait IFooInterface: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.versioned.tests.IFooInterface" } fn r#originalApi(&self) -> binder::Result<()>; fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result; fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result; fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result; fn r#newApi(&self) -> binder::Result<()>; fn r#getInterfaceVersion(&self) -> binder::Result { Ok(VERSION) } fn r#getInterfaceHash(&self) -> binder::Result { Ok(HASH.into()) } fn getDefaultImpl() -> IFooInterfaceDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: IFooInterfaceDefaultRef) -> IFooInterfaceDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait IFooInterfaceAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.versioned.tests.IFooInterface" } fn r#originalApi<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result<()>>; fn r#acceptUnionAndReturnString<'a>(&'a self, _arg_u: &'a crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::BoxFuture<'a, binder::Result>; fn r#ignoreParcelablesAndRepeatInt<'a>(&'a self, _arg_inFoo: &'a crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &'a mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &'a mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::BoxFuture<'a, binder::Result>; fn r#returnsLengthOfFooArray<'a>(&'a self, _arg_foos: &'a [crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::BoxFuture<'a, binder::Result>; fn r#newApi<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result<()>>; fn r#getInterfaceVersion<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { Box::pin(async move { Ok(VERSION) }) } fn r#getInterfaceHash<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { Box::pin(async move { Ok(HASH.into()) }) } } #[::async_trait::async_trait] pub trait IFooInterfaceAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.versioned.tests.IFooInterface" } async fn r#originalApi(&self) -> binder::Result<()>; async fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result; async fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result; async fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result; async fn r#newApi(&self) -> binder::Result<()>; } impl BnFooInterface { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: IFooInterfaceAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl IFooInterface for Wrapper where T: IFooInterfaceAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#originalApi(&self) -> binder::Result<()> { self._rt.block_on(self._inner.r#originalApi()) } fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result { self._rt.block_on(self._inner.r#acceptUnionAndReturnString(_arg_u)) } fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result { self._rt.block_on(self._inner.r#ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value)) } fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result { self._rt.block_on(self._inner.r#returnsLengthOfFooArray(_arg_foos)) } fn r#newApi(&self) -> binder::Result<()> { self._rt.block_on(self._inner.r#newApi()) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait IFooInterfaceDefault: Send + Sync { fn r#originalApi(&self) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#newApi(&self) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#originalApi: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; pub const r#acceptUnionAndReturnString: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 1; pub const r#ignoreParcelablesAndRepeatInt: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 2; pub const r#returnsLengthOfFooArray: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 3; pub const r#newApi: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 4; pub const r#getInterfaceVersion: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 16777214; pub const r#getInterfaceHash: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 16777213; } pub type IFooInterfaceDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); pub const VERSION: i32 = 3; pub const HASH: &str = "70d76c61eb0c82288e924862c10b910d1b7d8cf8"; impl BpFooInterface { fn build_parcel_originalApi(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_originalApi(&self, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#originalApi(); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } Ok(()) } fn build_parcel_acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_u)?; Ok(aidl_data) } fn read_response_acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#acceptUnionAndReturnString(_arg_u); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: String = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_inFoo)?; aidl_data.write(_arg_inoutFoo)?; aidl_data.write(&_arg_value)?; Ok(aidl_data) } fn read_response_ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: i32 = _aidl_reply.read()?; _aidl_reply.read_onto(_arg_inoutFoo)?; _aidl_reply.read_onto(_arg_outFoo)?; Ok(_aidl_return) } fn build_parcel_returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_foos)?; Ok(aidl_data) } fn read_response_returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo], _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#returnsLengthOfFooArray(_arg_foos); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: i32 = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_newApi(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_newApi(&self, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#newApi(); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } Ok(()) } fn build_parcel_getInterfaceVersion(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_getInterfaceVersion(&self, _aidl_reply: std::result::Result) -> binder::Result { let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: i32 = _aidl_reply.read()?; self.cached_version.store(_aidl_return, std::sync::atomic::Ordering::Relaxed); Ok(_aidl_return) } fn build_parcel_getInterfaceHash(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_getInterfaceHash(&self, _aidl_reply: std::result::Result) -> binder::Result { let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: String = _aidl_reply.read()?; *self.cached_hash.lock().unwrap() = Some(_aidl_return.clone()); Ok(_aidl_return) } } impl IFooInterface for BpFooInterface { fn r#originalApi(&self) -> binder::Result<()> { let _aidl_data = self.build_parcel_originalApi()?; let _aidl_reply = self.binder.submit_transact(transactions::r#originalApi, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_originalApi(_aidl_reply) } fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result { let _aidl_data = self.build_parcel_acceptUnionAndReturnString(_arg_u)?; let _aidl_reply = self.binder.submit_transact(transactions::r#acceptUnionAndReturnString, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_acceptUnionAndReturnString(_arg_u, _aidl_reply) } fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result { let _aidl_data = self.build_parcel_ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value)?; let _aidl_reply = self.binder.submit_transact(transactions::r#ignoreParcelablesAndRepeatInt, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value, _aidl_reply) } fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result { let _aidl_data = self.build_parcel_returnsLengthOfFooArray(_arg_foos)?; let _aidl_reply = self.binder.submit_transact(transactions::r#returnsLengthOfFooArray, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_returnsLengthOfFooArray(_arg_foos, _aidl_reply) } fn r#newApi(&self) -> binder::Result<()> { let _aidl_data = self.build_parcel_newApi()?; let _aidl_reply = self.binder.submit_transact(transactions::r#newApi, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_newApi(_aidl_reply) } fn r#getInterfaceVersion(&self) -> binder::Result { let _aidl_version = self.cached_version.load(std::sync::atomic::Ordering::Relaxed); if _aidl_version != -1 { return Ok(_aidl_version); } let _aidl_data = self.build_parcel_getInterfaceVersion()?; let _aidl_reply = self.binder.submit_transact(transactions::r#getInterfaceVersion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_getInterfaceVersion(_aidl_reply) } fn r#getInterfaceHash(&self) -> binder::Result { { let _aidl_hash_lock = self.cached_hash.lock().unwrap(); if let Some(ref _aidl_hash) = *_aidl_hash_lock { return Ok(_aidl_hash.clone()); } } let _aidl_data = self.build_parcel_getInterfaceHash()?; let _aidl_reply = self.binder.submit_transact(transactions::r#getInterfaceHash, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_getInterfaceHash(_aidl_reply) } } impl IFooInterfaceAsync

for BpFooInterface { fn r#originalApi<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_originalApi() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#originalApi, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_originalApi(_aidl_reply) } ) } fn r#acceptUnionAndReturnString<'a>(&'a self, _arg_u: &'a crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_acceptUnionAndReturnString(_arg_u) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#acceptUnionAndReturnString, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_acceptUnionAndReturnString(_arg_u, _aidl_reply) } ) } fn r#ignoreParcelablesAndRepeatInt<'a>(&'a self, _arg_inFoo: &'a crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &'a mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &'a mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#ignoreParcelablesAndRepeatInt, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value, _aidl_reply) } ) } fn r#returnsLengthOfFooArray<'a>(&'a self, _arg_foos: &'a [crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_returnsLengthOfFooArray(_arg_foos) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#returnsLengthOfFooArray, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_returnsLengthOfFooArray(_arg_foos, _aidl_reply) } ) } fn r#newApi<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_newApi() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#newApi, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_newApi(_aidl_reply) } ) } fn r#getInterfaceVersion<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { let _aidl_version = self.cached_version.load(std::sync::atomic::Ordering::Relaxed); if _aidl_version != -1 { return Box::pin(std::future::ready(Ok(_aidl_version))); } let _aidl_data = match self.build_parcel_getInterfaceVersion() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#getInterfaceVersion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_getInterfaceVersion(_aidl_reply) } ) } fn r#getInterfaceHash<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { { let _aidl_hash_lock = self.cached_hash.lock().unwrap(); if let Some(ref _aidl_hash) = *_aidl_hash_lock { return Box::pin(std::future::ready(Ok(_aidl_hash.clone()))); } } let _aidl_data = match self.build_parcel_getInterfaceHash() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#getInterfaceHash, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_getInterfaceHash(_aidl_reply) } ) } } impl IFooInterface for binder::binder_impl::Binder { fn r#originalApi(&self) -> binder::Result<()> { self.0.r#originalApi() } fn r#acceptUnionAndReturnString(&self, _arg_u: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion) -> binder::Result { self.0.r#acceptUnionAndReturnString(_arg_u) } fn r#ignoreParcelablesAndRepeatInt(&self, _arg_inFoo: &crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_inoutFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_outFoo: &mut crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo, _arg_value: i32) -> binder::Result { self.0.r#ignoreParcelablesAndRepeatInt(_arg_inFoo, _arg_inoutFoo, _arg_outFoo, _arg_value) } fn r#returnsLengthOfFooArray(&self, _arg_foos: &[crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo]) -> binder::Result { self.0.r#returnsLengthOfFooArray(_arg_foos) } fn r#newApi(&self) -> binder::Result<()> { self.0.r#newApi() } fn r#getInterfaceVersion(&self) -> binder::Result { self.0.r#getInterfaceVersion() } fn r#getInterfaceHash(&self) -> binder::Result { self.0.r#getInterfaceHash() } } fn on_transact(_aidl_service: &dyn IFooInterface, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#originalApi => { let _aidl_return = _aidl_service.r#originalApi(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#acceptUnionAndReturnString => { let _arg_u: crate::mangled::_7_android_4_aidl_9_versioned_5_tests_8_BazUnion = _aidl_data.read()?; let _aidl_return = _aidl_service.r#acceptUnionAndReturnString(&_arg_u); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#ignoreParcelablesAndRepeatInt => { let _arg_inFoo: crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo = _aidl_data.read()?; let mut _arg_inoutFoo: crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo = _aidl_data.read()?; let mut _arg_outFoo: crate::mangled::_7_android_4_aidl_9_versioned_5_tests_3_Foo = Default::default(); let _arg_value: i32 = _aidl_data.read()?; let _aidl_return = _aidl_service.r#ignoreParcelablesAndRepeatInt(&_arg_inFoo, &mut _arg_inoutFoo, &mut _arg_outFoo, _arg_value); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; _aidl_reply.write(&_arg_inoutFoo)?; _aidl_reply.write(&_arg_outFoo)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#returnsLengthOfFooArray => { let _arg_foos: Vec = _aidl_data.read()?; let _aidl_return = _aidl_service.r#returnsLengthOfFooArray(&_arg_foos); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#newApi => { let _aidl_return = _aidl_service.r#newApi(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#getInterfaceVersion => { let _aidl_return = _aidl_service.r#getInterfaceVersion(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#getInterfaceHash => { let _aidl_return = _aidl_service.r#getInterfaceHash(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } pub(crate) mod mangled { pub use super::r#IFooInterface as _7_android_4_aidl_9_versioned_5_tests_13_IFooInterface; } ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-rust-source_gen_android_0100644 0000000 0000000 00000000241 15172120304 033063 xustar000000000 0000000 133 path=tests/golden_output/frozen/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/tests/IFooInterface.rs.d 28 mtime=1776853188.7010000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/t0100644 0000000 0000000 00000000712 15172120304 033022 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl-test-versioned-interface-V3-rust-source/gen/android/aidl/versioned/tests/IFooInterface.rs : \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/IFooInterface.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/BazUnion.aidl \ system/tools/aidl/aidl_api/aidl-test-versioned-interface/3/android/aidl/versioned/tests/Foo.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl-test-versioned-interface-V3-rust-source_gen_timestam0100644 0000000 0000000 00000000034 15172120304 033127 xustar000000000 0000000 28 mtime=1776853188.7010000 tests/golden_output/frozen/aidl-test-versioned-interface-V3-rust-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 030221 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-cpp-source_0100644 0000000 0000000 00000000034 15172120304 030035 xustar000000000 0000000 28 mtime=1776853188.7010000 tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/0040755 0000000 0000000 00000000000 15172120304 025042 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-cpp-source_gen_0100644 0000000 0000000 00000000034 15172120304 030666 xustar000000000 0000000 28 mtime=1776853188.7010000 tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/0040755 0000000 0000000 00000000000 15172120304 025613 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-cpp-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 032366 xustar000000000 0000000 28 mtime=1776853188.7010000 tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 027233 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-cpp-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 033357 xustar000000000 0000000 28 mtime=1776853188.7010000 tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 030144 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-cpp-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 033357 xustar000000000 0000000 28 mtime=1776853188.7010000 tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/0040755 0000000 0000000 00000000000 15172120304 031720 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-cpp-source_gen_android_aidl_0100644 0000000 0000000 00000000213 15172120304 033356 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/Data.cpp 28 mtime=1776853188.7010000 tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/Data.cp0100644 0000000 0000000 00000007546 15172120304 033126 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging/android/aidl/loggable/Data.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Data.aidl */ #include namespace android { namespace aidl { namespace loggable { ::android::status_t Data::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&num); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readUtf8FromUtf16(&str); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readParcelable(&nestedUnion); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readByte(reinterpret_cast(&nestedEnum)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t Data::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeInt32(num); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeUtf8AsUtf16(str); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeParcelable(nestedUnion); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeByte(static_cast(nestedEnum)); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace loggable } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-cpp-source_gen_android_aidl_0100644 0000000 0000000 00000000215 15172120304 033360 xustar000000000 0000000 113 path=tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/Data.cpp.d 28 mtime=1776853188.7010000 tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/Data.cp0100644 0000000 0000000 00000000455 15172120304 033116 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/Data.cpp : \ system/tools/aidl/tests/android/aidl/loggable/Data.aidl \ system/tools/aidl/tests/android/aidl/loggable/Enum.aidl \ system/tools/aidl/tests/android/aidl/loggable/Union.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-cpp-source_gen_android_aidl_0100644 0000000 0000000 00000000213 15172120304 033356 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/Enum.cpp 28 mtime=1776853188.7010000 tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/Enum.cp0100644 0000000 0000000 00000001272 15172120304 033147 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging/android/aidl/loggable/Enum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Enum.aidl */ // This file is intentionally left blank as placeholder for enum declaration. ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-cpp-source_gen_android_aidl_0100644 0000000 0000000 00000000215 15172120304 033360 xustar000000000 0000000 113 path=tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/Enum.cpp.d 28 mtime=1776853188.7010000 tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/Enum.cp0100644 0000000 0000000 00000000264 15172120304 033147 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/Enum.cpp : \ system/tools/aidl/tests/android/aidl/loggable/Enum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-cpp-source_gen_android_aidl_0100644 0000000 0000000 00000000231 15172120304 033356 xustar000000000 0000000 125 path=tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/ILoggableInterface.cpp 28 mtime=1776853188.7010000 tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/ILoggab0100644 0000000 0000000 00000074524 15172120304 033160 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging/android/aidl/loggable/ILoggableInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/ILoggableInterface.aidl */ #include #include namespace android { namespace aidl { namespace loggable { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE(LoggableInterface, "android.aidl.loggable.ILoggableInterface") } // namespace loggable } // namespace aidl } // namespace android #include #include #include #include #include namespace android { namespace aidl { namespace loggable { BpLoggableInterface::BpLoggableInterface(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } std::function BpLoggableInterface::logFunc; ::android::binder::Status BpLoggableInterface::LogThis(bool boolValue, ::std::vector* boolArray, int8_t byteValue, ::std::vector* byteArray, char16_t charValue, ::std::vector* charArray, int32_t intValue, ::std::vector* intArray, int64_t longValue, ::std::vector* longArray, float floatValue, ::std::vector* floatArray, double doubleValue, ::std::vector* doubleArray, const ::android::String16& stringValue, ::std::vector<::android::String16>* stringArray, ::std::vector<::android::String16>* listValue, const ::android::aidl::loggable::Data& dataValue, const ::android::sp<::android::IBinder>& binderValue, ::std::optional<::android::os::ParcelFileDescriptor>* pfdValue, ::std::vector<::android::os::ParcelFileDescriptor>* pfdArray, ::std::vector<::android::String16>* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ILoggableInterface::LogThis::cppClient"); BpLoggableInterface::TransactionLog _transaction_log; if (BpLoggableInterface::logFunc != nullptr) { _transaction_log.input_args.emplace_back("boolValue", ::android::internal::ToString(boolValue)); _transaction_log.input_args.emplace_back("boolArray", ::android::internal::ToString(*boolArray)); _transaction_log.input_args.emplace_back("byteValue", ::android::internal::ToString(byteValue)); _transaction_log.input_args.emplace_back("byteArray", ::android::internal::ToString(*byteArray)); _transaction_log.input_args.emplace_back("charValue", ::android::internal::ToString(charValue)); _transaction_log.input_args.emplace_back("charArray", ::android::internal::ToString(*charArray)); _transaction_log.input_args.emplace_back("intValue", ::android::internal::ToString(intValue)); _transaction_log.input_args.emplace_back("intArray", ::android::internal::ToString(*intArray)); _transaction_log.input_args.emplace_back("longValue", ::android::internal::ToString(longValue)); _transaction_log.input_args.emplace_back("longArray", ::android::internal::ToString(*longArray)); _transaction_log.input_args.emplace_back("floatValue", ::android::internal::ToString(floatValue)); _transaction_log.input_args.emplace_back("floatArray", ::android::internal::ToString(*floatArray)); _transaction_log.input_args.emplace_back("doubleValue", ::android::internal::ToString(doubleValue)); _transaction_log.input_args.emplace_back("doubleArray", ::android::internal::ToString(*doubleArray)); _transaction_log.input_args.emplace_back("stringValue", ::android::internal::ToString(stringValue)); _transaction_log.input_args.emplace_back("stringArray", ::android::internal::ToString(*stringArray)); _transaction_log.input_args.emplace_back("listValue", ::android::internal::ToString(*listValue)); _transaction_log.input_args.emplace_back("dataValue", ::android::internal::ToString(dataValue)); _transaction_log.input_args.emplace_back("binderValue", ::android::internal::ToString(binderValue)); _transaction_log.input_args.emplace_back("pfdValue", ::android::internal::ToString(*pfdValue)); _transaction_log.input_args.emplace_back("pfdArray", ::android::internal::ToString(*pfdArray)); } auto _log_start = std::chrono::steady_clock::now(); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeBool(boolValue); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeBoolVector(*boolArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeByte(byteValue); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeByteVector(*byteArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeChar(charValue); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeCharVector(*charArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeInt32(intValue); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeInt32Vector(*intArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeInt64(longValue); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeInt64Vector(*longArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeFloat(floatValue); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeFloatVector(*floatArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeDouble(doubleValue); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeDoubleVector(*doubleArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeString16(stringValue); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeString16Vector(*stringArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeString16Vector(*listValue); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(dataValue); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinder(binderValue); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeNullableParcelable(*pfdValue); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelableVector(*pfdArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnLoggableInterface::TRANSACTION_LogThis, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ILoggableInterface::getDefaultImpl()) [[unlikely]] { return ILoggableInterface::getDefaultImpl()->LogThis(boolValue, boolArray, byteValue, byteArray, charValue, charArray, intValue, intArray, longValue, longArray, floatValue, floatArray, doubleValue, doubleArray, stringValue, stringArray, listValue, dataValue, binderValue, pfdValue, pfdArray, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readString16Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readBoolVector(boolArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readByteVector(byteArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readCharVector(charArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readInt32Vector(intArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readInt64Vector(longArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readFloatVector(floatArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readDoubleVector(doubleArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readString16Vector(stringArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readString16Vector(listValue); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readParcelable(pfdValue); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_reply.readParcelableVector(pfdArray); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (BpLoggableInterface::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.loggable.ILoggableInterface"; _transaction_log.method_name = "LogThis"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.output_args.emplace_back("boolArray", ::android::internal::ToString(*boolArray)); _transaction_log.output_args.emplace_back("byteArray", ::android::internal::ToString(*byteArray)); _transaction_log.output_args.emplace_back("charArray", ::android::internal::ToString(*charArray)); _transaction_log.output_args.emplace_back("intArray", ::android::internal::ToString(*intArray)); _transaction_log.output_args.emplace_back("longArray", ::android::internal::ToString(*longArray)); _transaction_log.output_args.emplace_back("floatArray", ::android::internal::ToString(*floatArray)); _transaction_log.output_args.emplace_back("doubleArray", ::android::internal::ToString(*doubleArray)); _transaction_log.output_args.emplace_back("stringArray", ::android::internal::ToString(*stringArray)); _transaction_log.output_args.emplace_back("listValue", ::android::internal::ToString(*listValue)); _transaction_log.output_args.emplace_back("pfdValue", ::android::internal::ToString(*pfdValue)); _transaction_log.output_args.emplace_back("pfdArray", ::android::internal::ToString(*pfdArray)); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpLoggableInterface::logFunc(_transaction_log); } return _aidl_status; } } // namespace loggable } // namespace aidl } // namespace android #include #include #include #include #include namespace android { namespace aidl { namespace loggable { BnLoggableInterface::BnLoggableInterface() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t BnLoggableInterface::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnLoggableInterface::TRANSACTION_LogThis: { bool in_boolValue; ::std::vector in_boolArray; int8_t in_byteValue; ::std::vector in_byteArray; char16_t in_charValue; ::std::vector in_charArray; int32_t in_intValue; ::std::vector in_intArray; int64_t in_longValue; ::std::vector in_longArray; float in_floatValue; ::std::vector in_floatArray; double in_doubleValue; ::std::vector in_doubleArray; ::android::String16 in_stringValue; ::std::vector<::android::String16> in_stringArray; ::std::vector<::android::String16> in_listValue; ::android::aidl::loggable::Data in_dataValue; ::android::sp<::android::IBinder> in_binderValue; ::std::optional<::android::os::ParcelFileDescriptor> in_pfdValue; ::std::vector<::android::os::ParcelFileDescriptor> in_pfdArray; ::std::vector<::android::String16> _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ILoggableInterface::LogThis::cppServer"); _aidl_ret_status = _aidl_data.readBool(&in_boolValue); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readBoolVector(&in_boolArray); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readByte(&in_byteValue); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readByteVector(&in_byteArray); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readChar(&in_charValue); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readCharVector(&in_charArray); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readInt32(&in_intValue); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readInt32Vector(&in_intArray); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readInt64(&in_longValue); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readInt64Vector(&in_longArray); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readFloat(&in_floatValue); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readFloatVector(&in_floatArray); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readDouble(&in_doubleValue); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readDoubleVector(&in_doubleArray); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readString16(&in_stringValue); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readString16Vector(&in_stringArray); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readString16Vector(&in_listValue); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readParcelable(&in_dataValue); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readNullableStrongBinder(&in_binderValue); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readParcelable(&in_pfdValue); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_data.readParcelableVector(&in_pfdArray); if (((_aidl_ret_status) != (::android::OK))) { break; } BnLoggableInterface::TransactionLog _transaction_log; if (BnLoggableInterface::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_boolValue", ::android::internal::ToString(in_boolValue)); _transaction_log.input_args.emplace_back("in_boolArray", ::android::internal::ToString(in_boolArray)); _transaction_log.input_args.emplace_back("in_byteValue", ::android::internal::ToString(in_byteValue)); _transaction_log.input_args.emplace_back("in_byteArray", ::android::internal::ToString(in_byteArray)); _transaction_log.input_args.emplace_back("in_charValue", ::android::internal::ToString(in_charValue)); _transaction_log.input_args.emplace_back("in_charArray", ::android::internal::ToString(in_charArray)); _transaction_log.input_args.emplace_back("in_intValue", ::android::internal::ToString(in_intValue)); _transaction_log.input_args.emplace_back("in_intArray", ::android::internal::ToString(in_intArray)); _transaction_log.input_args.emplace_back("in_longValue", ::android::internal::ToString(in_longValue)); _transaction_log.input_args.emplace_back("in_longArray", ::android::internal::ToString(in_longArray)); _transaction_log.input_args.emplace_back("in_floatValue", ::android::internal::ToString(in_floatValue)); _transaction_log.input_args.emplace_back("in_floatArray", ::android::internal::ToString(in_floatArray)); _transaction_log.input_args.emplace_back("in_doubleValue", ::android::internal::ToString(in_doubleValue)); _transaction_log.input_args.emplace_back("in_doubleArray", ::android::internal::ToString(in_doubleArray)); _transaction_log.input_args.emplace_back("in_stringValue", ::android::internal::ToString(in_stringValue)); _transaction_log.input_args.emplace_back("in_stringArray", ::android::internal::ToString(in_stringArray)); _transaction_log.input_args.emplace_back("in_listValue", ::android::internal::ToString(in_listValue)); _transaction_log.input_args.emplace_back("in_dataValue", ::android::internal::ToString(in_dataValue)); _transaction_log.input_args.emplace_back("in_binderValue", ::android::internal::ToString(in_binderValue)); _transaction_log.input_args.emplace_back("in_pfdValue", ::android::internal::ToString(in_pfdValue)); _transaction_log.input_args.emplace_back("in_pfdArray", ::android::internal::ToString(in_pfdArray)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(LogThis(in_boolValue, &in_boolArray, in_byteValue, &in_byteArray, in_charValue, &in_charArray, in_intValue, &in_intArray, in_longValue, &in_longArray, in_floatValue, &in_floatArray, in_doubleValue, &in_doubleArray, in_stringValue, &in_stringArray, &in_listValue, in_dataValue, in_binderValue, &in_pfdValue, &in_pfdArray, &_aidl_return)); if (BnLoggableInterface::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.loggable.ILoggableInterface"; _transaction_log.method_name = "LogThis"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.output_args.emplace_back("in_boolArray", ::android::internal::ToString(in_boolArray)); _transaction_log.output_args.emplace_back("in_byteArray", ::android::internal::ToString(in_byteArray)); _transaction_log.output_args.emplace_back("in_charArray", ::android::internal::ToString(in_charArray)); _transaction_log.output_args.emplace_back("in_intArray", ::android::internal::ToString(in_intArray)); _transaction_log.output_args.emplace_back("in_longArray", ::android::internal::ToString(in_longArray)); _transaction_log.output_args.emplace_back("in_floatArray", ::android::internal::ToString(in_floatArray)); _transaction_log.output_args.emplace_back("in_doubleArray", ::android::internal::ToString(in_doubleArray)); _transaction_log.output_args.emplace_back("in_stringArray", ::android::internal::ToString(in_stringArray)); _transaction_log.output_args.emplace_back("in_listValue", ::android::internal::ToString(in_listValue)); _transaction_log.output_args.emplace_back("in_pfdValue", ::android::internal::ToString(in_pfdValue)); _transaction_log.output_args.emplace_back("in_pfdArray", ::android::internal::ToString(in_pfdArray)); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnLoggableInterface::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeString16Vector(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeBoolVector(in_boolArray); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeByteVector(in_byteArray); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeCharVector(in_charArray); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeInt32Vector(in_intArray); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeInt64Vector(in_longArray); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeFloatVector(in_floatArray); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeDoubleVector(in_doubleArray); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeString16Vector(in_stringArray); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeString16Vector(in_listValue); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeNullableParcelable(in_pfdValue); if (((_aidl_ret_status) != (::android::OK))) { break; } _aidl_ret_status = _aidl_reply->writeParcelableVector(in_pfdArray); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } std::function BnLoggableInterface::logFunc; } // namespace loggable } // namespace aidl } // namespace android #include #include namespace android { namespace aidl { namespace loggable { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_NESTED_INTERFACE(ILoggableInterface, Sub, "android.aidl.loggable.ILoggableInterface.ISub") } // namespace loggable } // namespace aidl } // namespace android #include #include #include #include #include namespace android { namespace aidl { namespace loggable { ILoggableInterface::BpSub::BpSub(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } std::function ILoggableInterface::BpSub::logFunc; ::android::binder::Status ILoggableInterface::BpSub::Log(int32_t value) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ISub::Log::cppClient"); ILoggableInterface::BpSub::TransactionLog _transaction_log; if (ILoggableInterface::BpSub::logFunc != nullptr) { _transaction_log.input_args.emplace_back("value", ::android::internal::ToString(value)); } auto _log_start = std::chrono::steady_clock::now(); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeInt32(value); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(ILoggableInterface::BnSub::TRANSACTION_Log, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ISub::getDefaultImpl()) [[unlikely]] { return ISub::getDefaultImpl()->Log(value); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (ILoggableInterface::BpSub::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.loggable.ILoggableInterface.ISub"; _transaction_log.method_name = "Log"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); ILoggableInterface::BpSub::logFunc(_transaction_log); } return _aidl_status; } } // namespace loggable } // namespace aidl } // namespace android #include #include #include #include #include namespace android { namespace aidl { namespace loggable { ILoggableInterface::BnSub::BnSub() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t ILoggableInterface::BnSub::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnSub::TRANSACTION_Log: { int32_t in_value; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ISub::Log::cppServer"); _aidl_ret_status = _aidl_data.readInt32(&in_value); if (((_aidl_ret_status) != (::android::OK))) { break; } ILoggableInterface::BnSub::TransactionLog _transaction_log; if (ILoggableInterface::BnSub::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_value", ::android::internal::ToString(in_value)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(Log(in_value)); if (ILoggableInterface::BnSub::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.loggable.ILoggableInterface.ISub"; _transaction_log.method_name = "Log"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); ILoggableInterface::BnSub::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } std::function ILoggableInterface::BnSub::logFunc; } // namespace loggable } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-cpp-source_gen_android_aidl_0100644 0000000 0000000 00000000233 15172120304 033360 xustar000000000 0000000 127 path=tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/ILoggableInterface.cpp.d 28 mtime=1776853188.7020000 tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/ILoggab0100644 0000000 0000000 00000000605 15172120304 033145 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/ILoggableInterface.cpp : \ system/tools/aidl/tests/android/aidl/loggable/ILoggableInterface.aidl \ system/tools/aidl/tests/android/aidl/loggable/Data.aidl \ system/tools/aidl/tests/android/aidl/loggable/Union.aidl \ system/tools/aidl/tests/android/aidl/loggable/Enum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-cpp-source_gen_android_aidl_0100644 0000000 0000000 00000000214 15172120304 033357 xustar000000000 0000000 112 path=tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/Union.cpp 28 mtime=1776853188.7020000 tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/Union.c0100644 0000000 0000000 00000004471 15172120304 033157 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging/android/aidl/loggable/Union.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Union.aidl */ #include namespace android { namespace aidl { namespace loggable { ::android::status_t Union::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_tag)) != ::android::OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case num: { int32_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case str: { ::std::string _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readUtf8FromUtf16(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v<::std::string>) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } } return ::android::BAD_VALUE; } ::android::status_t Union::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(getTag())); if (_aidl_ret_status != ::android::OK) return _aidl_ret_status; switch (getTag()) { case num: return _aidl_parcel->writeInt32(get()); case str: return _aidl_parcel->writeUtf8AsUtf16(get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace loggable } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-cpp-source_gen_android_aidl_0100644 0000000 0000000 00000000216 15172120304 033361 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/Union.cpp.d 28 mtime=1776853188.7020000 tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/Union.c0100644 0000000 0000000 00000000266 15172120304 033155 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/android/aidl/loggable/Union.cpp : \ system/tools/aidl/tests/android/aidl/loggable/Union.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-cpp-source_gen_include_0100644 0000000 0000000 00000000034 15172120304 032371 xustar000000000 0000000 28 mtime=1776853188.7020000 tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/include/0040755 0000000 0000000 00000000000 15172120304 027236 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-cpp-source_gen_include_andro0100644 0000000 0000000 00000000034 15172120304 033415 xustar000000000 0000000 28 mtime=1776853188.7020000 tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/include/android/0040755 0000000 0000000 00000000000 15172120304 030656 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-cpp-source_gen_include_andro0100644 0000000 0000000 00000000034 15172120304 033415 xustar000000000 0000000 28 mtime=1776853188.7020000 tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/0040755 0000000 0000000 00000000000 15172120304 031567 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-cpp-source_gen_include_andro0100644 0000000 0000000 00000000213 15172120304 033414 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/ 28 mtime=1776853188.7030000 tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable0040755 0000000 0000000 00000000000 15172120304 033264 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-cpp-source_gen_include_andro0100644 0000000 0000000 00000000223 15172120304 033415 xustar000000000 0000000 119 path=tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/BnData.h 28 mtime=1776853188.7030000 tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable0100644 0000000 0000000 00000001247 15172120304 033267 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging/android/aidl/loggable/Data.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Data.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-cpp-source_gen_include_andro0100644 0000000 0000000 00000000223 15172120304 033415 xustar000000000 0000000 119 path=tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/BnEnum.h 28 mtime=1776853188.7030000 tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable0100644 0000000 0000000 00000001241 15172120304 033261 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging/android/aidl/loggable/Enum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Enum.aidl */ #error TODO(b/111362593) enums do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-cpp-source_gen_include_andro0100644 0000000 0000000 00000000240 15172120304 033414 xustar000000000 0000000 132 path=tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/BnLoggableInterface.h 28 mtime=1776853188.7030000 tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable0100644 0000000 0000000 00000006654 15172120304 033276 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging/android/aidl/loggable/ILoggableInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/ILoggableInterface.aidl */ #pragma once #include #include #include #include #include #include #include namespace android { namespace aidl { namespace loggable { class BnLoggableInterface : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_LogThis = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; explicit BnLoggableInterface(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; }; // class BnLoggableInterface class ILoggableInterfaceDelegator : public BnLoggableInterface { public: explicit ILoggableInterfaceDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status LogThis(bool boolValue, ::std::vector* boolArray, int8_t byteValue, ::std::vector* byteArray, char16_t charValue, ::std::vector* charArray, int32_t intValue, ::std::vector* intArray, int64_t longValue, ::std::vector* longArray, float floatValue, ::std::vector* floatArray, double doubleValue, ::std::vector* doubleArray, const ::android::String16& stringValue, ::std::vector<::android::String16>* stringArray, ::std::vector<::android::String16>* listValue, const ::android::aidl::loggable::Data& dataValue, const ::android::sp<::android::IBinder>& binderValue, ::std::optional<::android::os::ParcelFileDescriptor>* pfdValue, ::std::vector<::android::os::ParcelFileDescriptor>* pfdArray, ::std::vector<::android::String16>* _aidl_return) override { return _aidl_delegate->LogThis(boolValue, boolArray, byteValue, byteArray, charValue, charArray, intValue, intArray, longValue, longArray, floatValue, floatArray, doubleValue, doubleArray, stringValue, stringArray, listValue, dataValue, binderValue, pfdValue, pfdArray, _aidl_return); } private: ::android::sp _aidl_delegate; }; // class ILoggableInterfaceDelegator } // namespace loggable } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-cpp-source_gen_include_andro0100644 0000000 0000000 00000000224 15172120304 033416 xustar000000000 0000000 120 path=tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/BnUnion.h 28 mtime=1776853188.7030000 tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable0100644 0000000 0000000 00000001251 15172120304 033262 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging/android/aidl/loggable/Union.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Union.aidl */ #error TODO(b/111362593) parcelables do not have bn classes./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-cpp-source_gen_include_andro0100644 0000000 0000000 00000000223 15172120304 033415 xustar000000000 0000000 119 path=tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/BpData.h 28 mtime=1776853188.7030000 tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable0100644 0000000 0000000 00000001247 15172120304 033267 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging/android/aidl/loggable/Data.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Data.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-cpp-source_gen_include_andro0100644 0000000 0000000 00000000223 15172120304 033415 xustar000000000 0000000 119 path=tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/BpEnum.h 28 mtime=1776853188.7030000 tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable0100644 0000000 0000000 00000001241 15172120304 033261 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging/android/aidl/loggable/Enum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Enum.aidl */ #error TODO(b/111362593) enums do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-cpp-source_gen_include_andro0100644 0000000 0000000 00000000240 15172120304 033414 xustar000000000 0000000 132 path=tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/BpLoggableInterface.h 28 mtime=1776853188.7030000 tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable0100644 0000000 0000000 00000005051 15172120304 033264 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging/android/aidl/loggable/ILoggableInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/ILoggableInterface.aidl */ #pragma once #include #include #include #include #include #include namespace android { namespace aidl { namespace loggable { class BpLoggableInterface : public ::android::BpInterface { public: explicit BpLoggableInterface(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpLoggableInterface() = default; ::android::binder::Status LogThis(bool boolValue, ::std::vector* boolArray, int8_t byteValue, ::std::vector* byteArray, char16_t charValue, ::std::vector* charArray, int32_t intValue, ::std::vector* intArray, int64_t longValue, ::std::vector* longArray, float floatValue, ::std::vector* floatArray, double doubleValue, ::std::vector* doubleArray, const ::android::String16& stringValue, ::std::vector<::android::String16>* stringArray, ::std::vector<::android::String16>* listValue, const ::android::aidl::loggable::Data& dataValue, const ::android::sp<::android::IBinder>& binderValue, ::std::optional<::android::os::ParcelFileDescriptor>* pfdValue, ::std::vector<::android::os::ParcelFileDescriptor>* pfdArray, ::std::vector<::android::String16>* _aidl_return) override; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; }; // class BpLoggableInterface } // namespace loggable } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-cpp-source_gen_include_andro0100644 0000000 0000000 00000000224 15172120304 033416 xustar000000000 0000000 120 path=tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/BpUnion.h 28 mtime=1776853188.7030000 tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable0100644 0000000 0000000 00000001251 15172120304 033262 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging/android/aidl/loggable/Union.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Union.aidl */ #error TODO(b/111362593) parcelables do not have bp classes./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-cpp-source_gen_include_andro0100644 0000000 0000000 00000000221 15172120304 033413 xustar000000000 0000000 117 path=tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/Data.h 28 mtime=1776853188.7030000 tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable0100644 0000000 0000000 00000005246 15172120304 033272 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging/android/aidl/loggable/Data.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Data.aidl */ #pragma once #include #include #include #include #include #include #include #include #include namespace android { namespace aidl { namespace loggable { class Data : public ::android::Parcelable { public: int32_t num = 0; ::std::string str; ::android::aidl::loggable::Union nestedUnion; ::android::aidl::loggable::Enum nestedEnum = ::android::aidl::loggable::Enum::FOO; inline bool operator==(const Data& _rhs) const { return std::tie(num, str, nestedUnion, nestedEnum) == std::tie(_rhs.num, _rhs.str, _rhs.nestedUnion, _rhs.nestedEnum); } inline bool operator<(const Data& _rhs) const { return std::tie(num, str, nestedUnion, nestedEnum) < std::tie(_rhs.num, _rhs.str, _rhs.nestedUnion, _rhs.nestedEnum); } inline bool operator!=(const Data& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Data& _rhs) const { return _rhs < *this; } inline bool operator>=(const Data& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Data& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.loggable.Data"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "Data{"; _aidl_os << "num: " << ::android::internal::ToString(num); _aidl_os << ", str: " << ::android::internal::ToString(str); _aidl_os << ", nestedUnion: " << ::android::internal::ToString(nestedUnion); _aidl_os << ", nestedEnum: " << ::android::internal::ToString(nestedEnum); _aidl_os << "}"; return _aidl_os.str(); } }; // class Data } // namespace loggable } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-cpp-source_gen_include_andro0100644 0000000 0000000 00000000221 15172120304 033413 xustar000000000 0000000 117 path=tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/Enum.h 28 mtime=1776853188.7030000 tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable0100644 0000000 0000000 00000003037 15172120304 033266 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging/android/aidl/loggable/Enum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Enum.aidl */ #pragma once #include #include #include #include namespace android { namespace aidl { namespace loggable { enum class Enum : int8_t { FOO = 42, }; } // namespace loggable } // namespace aidl } // namespace android namespace android { namespace aidl { namespace loggable { [[nodiscard]] static inline std::string toString(Enum val) { switch(val) { case Enum::FOO: return "FOO"; default: return std::to_string(static_cast(val)); } } } // namespace loggable } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::loggable::Enum, 1> enum_values<::android::aidl::loggable::Enum> = { ::android::aidl::loggable::Enum::FOO, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-cpp-source_gen_include_andro0100644 0000000 0000000 00000000237 15172120304 033422 xustar000000000 0000000 131 path=tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/ILoggableInterface.h 28 mtime=1776853188.7030000 tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable0100644 0000000 0000000 00000014057 15172120304 033272 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging/android/aidl/loggable/ILoggableInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/ILoggableInterface.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace android::aidl::loggable { class Data; } // namespace android::aidl::loggable namespace android { namespace aidl { namespace loggable { class ILoggableInterfaceDelegator; class ILoggableInterface : public ::android::IInterface { public: typedef ILoggableInterfaceDelegator DefaultDelegator; DECLARE_META_INTERFACE(LoggableInterface) class ISubDelegator; class ISub : public ::android::IInterface { public: typedef ISubDelegator DefaultDelegator; DECLARE_META_INTERFACE(Sub) virtual ::android::binder::Status Log(int32_t value) = 0; }; // class ISub class ISubDefault : public ISub { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status Log(int32_t /*value*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } }; // class ISubDefault class BpSub : public ::android::BpInterface { public: explicit BpSub(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpSub() = default; ::android::binder::Status Log(int32_t value) override; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; }; // class BpSub class BnSub : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_Log = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; explicit BnSub(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; }; // class BnSub class ISubDelegator : public BnSub { public: explicit ISubDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status Log(int32_t value) override { return _aidl_delegate->Log(value); } private: ::android::sp _aidl_delegate; }; // class ISubDelegator virtual ::android::binder::Status LogThis(bool boolValue, ::std::vector* boolArray, int8_t byteValue, ::std::vector* byteArray, char16_t charValue, ::std::vector* charArray, int32_t intValue, ::std::vector* intArray, int64_t longValue, ::std::vector* longArray, float floatValue, ::std::vector* floatArray, double doubleValue, ::std::vector* doubleArray, const ::android::String16& stringValue, ::std::vector<::android::String16>* stringArray, ::std::vector<::android::String16>* listValue, const ::android::aidl::loggable::Data& dataValue, const ::android::sp<::android::IBinder>& binderValue, ::std::optional<::android::os::ParcelFileDescriptor>* pfdValue, ::std::vector<::android::os::ParcelFileDescriptor>* pfdArray, ::std::vector<::android::String16>* _aidl_return) = 0; }; // class ILoggableInterface class ILoggableInterfaceDefault : public ILoggableInterface { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status LogThis(bool /*boolValue*/, ::std::vector* /*boolArray*/, int8_t /*byteValue*/, ::std::vector* /*byteArray*/, char16_t /*charValue*/, ::std::vector* /*charArray*/, int32_t /*intValue*/, ::std::vector* /*intArray*/, int64_t /*longValue*/, ::std::vector* /*longArray*/, float /*floatValue*/, ::std::vector* /*floatArray*/, double /*doubleValue*/, ::std::vector* /*doubleArray*/, const ::android::String16& /*stringValue*/, ::std::vector<::android::String16>* /*stringArray*/, ::std::vector<::android::String16>* /*listValue*/, const ::android::aidl::loggable::Data& /*dataValue*/, const ::android::sp<::android::IBinder>& /*binderValue*/, ::std::optional<::android::os::ParcelFileDescriptor>* /*pfdValue*/, ::std::vector<::android::os::ParcelFileDescriptor>* /*pfdArray*/, ::std::vector<::android::String16>* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } }; // class ILoggableInterfaceDefault } // namespace loggable } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-cpp-source_gen_include_andro0100644 0000000 0000000 00000000222 15172120304 033414 xustar000000000 0000000 118 path=tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable/Union.h 28 mtime=1776853188.7040000 tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/include/android/aidl/loggable0100644 0000000 0000000 00000011706 15172120304 033270 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging/android/aidl/loggable/Union.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-cpp-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Union.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace android { namespace aidl { namespace loggable { class Union : public ::android::Parcelable { public: enum class Tag : int32_t { num = 0, str = 1, }; // Expose tag symbols for legacy code static const inline Tag num = Tag::num; static const inline Tag str = Tag::str; template static constexpr bool _not_self = !std::is_same_v>, Union>; Union() : _value(std::in_place_index(num)>, int32_t(43)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr Union(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit Union(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static Union make(_Tp&&... _args) { return Union(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static Union make(std::initializer_list<_Tp> _il, _Up&&... _args) { return Union(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } inline bool operator==(const Union& _rhs) const { return _value == _rhs._value; } inline bool operator<(const Union& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const Union& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Union& _rhs) const { return _rhs < *this; } inline bool operator>=(const Union& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Union& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.loggable.Union"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream os; os << "Union{"; switch (getTag()) { case num: os << "num: " << ::android::internal::ToString(get()); break; case str: os << "str: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant _value; }; // class Union } // namespace loggable } // namespace aidl } // namespace android namespace android { namespace aidl { namespace loggable { [[nodiscard]] static inline std::string toString(Union::Tag val) { switch(val) { case Union::Tag::num: return "num"; case Union::Tag::str: return "str"; default: return std::to_string(static_cast(val)); } } } // namespace loggable } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::loggable::Union::Tag, 2> enum_values<::android::aidl::loggable::Union::Tag> = { ::android::aidl::loggable::Union::Tag::num, ::android::aidl::loggable::Union::Tag::str, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-cpp-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 032612 xustar000000000 0000000 28 mtime=1776853188.7040000 tests/golden_output/frozen/aidl_test_loggable_interface-cpp-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 027524 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-java-source_0100644 0000000 0000000 00000000034 15172120304 030174 xustar000000000 0000000 28 mtime=1776853188.7040000 tests/golden_output/frozen/aidl_test_loggable_interface-java-source/0040755 0000000 0000000 00000000000 15172120304 025201 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-java-source_gen_0100644 0000000 0000000 00000000034 15172120304 031025 xustar000000000 0000000 28 mtime=1776853188.7040000 tests/golden_output/frozen/aidl_test_loggable_interface-java-source/gen/0040755 0000000 0000000 00000000000 15172120304 025752 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-java-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 032525 xustar000000000 0000000 28 mtime=1776853188.7040000 tests/golden_output/frozen/aidl_test_loggable_interface-java-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 027372 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-java-source_gen_android_aidl0100644 0000000 0000000 00000000034 15172120304 033357 xustar000000000 0000000 28 mtime=1776853188.7040000 tests/golden_output/frozen/aidl_test_loggable_interface-java-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 030303 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-java-source_gen_android_aidl0100644 0000000 0000000 00000000034 15172120304 033357 xustar000000000 0000000 28 mtime=1776853188.7040000 tests/golden_output/frozen/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/0040755 0000000 0000000 00000000000 15172120304 032057 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-java-source_gen_android_aidl0100644 0000000 0000000 00000000215 15172120304 033360 xustar000000000 0000000 113 path=tests/golden_output/frozen/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/Data.java 28 mtime=1776853188.7040000 tests/golden_output/frozen/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/Data.j0100644 0000000 0000000 00000006204 15172120304 033102 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/Data.java.d -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Data.aidl */ package android.aidl.loggable; public class Data implements android.os.Parcelable { public int num = 0; public java.lang.String str; public android.aidl.loggable.Union nestedUnion; public byte nestedEnum = android.aidl.loggable.Enum.FOO; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public Data createFromParcel(android.os.Parcel _aidl_source) { Data _aidl_out = new Data(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public Data[] newArray(int _aidl_size) { return new Data[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(num); _aidl_parcel.writeString(str); _aidl_parcel.writeTypedObject(nestedUnion, _aidl_flag); _aidl_parcel.writeByte(nestedEnum); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; num = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; str = _aidl_parcel.readString(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; nestedUnion = _aidl_parcel.readTypedObject(android.aidl.loggable.Union.CREATOR); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; nestedEnum = _aidl_parcel.readByte(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; _mask |= describeContents(nestedUnion); return _mask; } private int describeContents(Object _v) { if (_v == null) return 0; if (_v instanceof android.os.Parcelable) { return ((android.os.Parcelable) _v).describeContents(); } return 0; } } ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-java-source_gen_android_aidl0100644 0000000 0000000 00000000217 15172120304 033362 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/Data.java.d 28 mtime=1776853188.7040000 tests/golden_output/frozen/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/Data.j0100644 0000000 0000000 00000000457 15172120304 033106 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/Data.java : \ system/tools/aidl/tests/android/aidl/loggable/Data.aidl \ system/tools/aidl/tests/android/aidl/loggable/Enum.aidl \ system/tools/aidl/tests/android/aidl/loggable/Union.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-java-source_gen_android_aidl0100644 0000000 0000000 00000000215 15172120304 033360 xustar000000000 0000000 113 path=tests/golden_output/frozen/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/Enum.java 28 mtime=1776853188.7040000 tests/golden_output/frozen/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/Enum.j0100644 0000000 0000000 00000001125 15172120304 033132 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/Enum.java.d -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Enum.aidl */ package android.aidl.loggable; public @interface Enum { public static final byte FOO = 42; } ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-java-source_gen_android_aidl0100644 0000000 0000000 00000000217 15172120304 033362 xustar000000000 0000000 115 path=tests/golden_output/frozen/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/Enum.java.d 28 mtime=1776853188.7040000 tests/golden_output/frozen/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/Enum.j0100644 0000000 0000000 00000000266 15172120304 033137 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/Enum.java : \ system/tools/aidl/tests/android/aidl/loggable/Enum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-java-source_gen_android_aidl0100644 0000000 0000000 00000000233 15172120304 033360 xustar000000000 0000000 127 path=tests/golden_output/frozen/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/ILoggableInterface.java 28 mtime=1776853188.7040000 tests/golden_output/frozen/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/ILogga0100644 0000000 0000000 00000034140 15172120304 033143 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/ILoggableInterface.java.d -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/ILoggableInterface.aidl */ package android.aidl.loggable; public interface ILoggableInterface extends android.os.IInterface { /** Default implementation for ILoggableInterface. */ public static class Default implements android.aidl.loggable.ILoggableInterface { @Override public java.lang.String[] LogThis(boolean boolValue, boolean[] boolArray, byte byteValue, byte[] byteArray, char charValue, char[] charArray, int intValue, int[] intArray, long longValue, long[] longArray, float floatValue, float[] floatArray, double doubleValue, double[] doubleArray, java.lang.String stringValue, java.lang.String[] stringArray, java.util.List listValue, android.aidl.loggable.Data dataValue, android.os.IBinder binderValue, android.os.ParcelFileDescriptor pfdValue, android.os.ParcelFileDescriptor[] pfdArray) throws android.os.RemoteException { return null; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.loggable.ILoggableInterface { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.loggable.ILoggableInterface interface, * generating a proxy if needed. */ public static android.aidl.loggable.ILoggableInterface asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.loggable.ILoggableInterface))) { return ((android.aidl.loggable.ILoggableInterface)iin); } return new android.aidl.loggable.ILoggableInterface.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_LogThis: { return "LogThis"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_LogThis: { boolean _arg0; _arg0 = data.readBoolean(); boolean[] _arg1; _arg1 = data.createBooleanArray(); byte _arg2; _arg2 = data.readByte(); byte[] _arg3; _arg3 = data.createByteArray(); char _arg4; _arg4 = (char)data.readInt(); char[] _arg5; _arg5 = data.createCharArray(); int _arg6; _arg6 = data.readInt(); int[] _arg7; _arg7 = data.createIntArray(); long _arg8; _arg8 = data.readLong(); long[] _arg9; _arg9 = data.createLongArray(); float _arg10; _arg10 = data.readFloat(); float[] _arg11; _arg11 = data.createFloatArray(); double _arg12; _arg12 = data.readDouble(); double[] _arg13; _arg13 = data.createDoubleArray(); java.lang.String _arg14; _arg14 = data.readString(); java.lang.String[] _arg15; _arg15 = data.createStringArray(); java.util.List _arg16; _arg16 = data.createStringArrayList(); android.aidl.loggable.Data _arg17; _arg17 = data.readTypedObject(android.aidl.loggable.Data.CREATOR); android.os.IBinder _arg18; _arg18 = data.readStrongBinder(); android.os.ParcelFileDescriptor _arg19; _arg19 = data.readTypedObject(android.os.ParcelFileDescriptor.CREATOR); android.os.ParcelFileDescriptor[] _arg20; _arg20 = data.createTypedArray(android.os.ParcelFileDescriptor.CREATOR); data.enforceNoDataAvail(); java.lang.String[] _result = this.LogThis(_arg0, _arg1, _arg2, _arg3, _arg4, _arg5, _arg6, _arg7, _arg8, _arg9, _arg10, _arg11, _arg12, _arg13, _arg14, _arg15, _arg16, _arg17, _arg18, _arg19, _arg20); reply.writeNoException(); reply.writeStringArray(_result); reply.writeBooleanArray(_arg1); reply.writeByteArray(_arg3); reply.writeCharArray(_arg5); reply.writeIntArray(_arg7); reply.writeLongArray(_arg9); reply.writeFloatArray(_arg11); reply.writeDoubleArray(_arg13); reply.writeStringArray(_arg15); reply.writeStringList(_arg16); reply.writeTypedObject(_arg19, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); reply.writeTypedArray(_arg20, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.loggable.ILoggableInterface { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public java.lang.String[] LogThis(boolean boolValue, boolean[] boolArray, byte byteValue, byte[] byteArray, char charValue, char[] charArray, int intValue, int[] intArray, long longValue, long[] longArray, float floatValue, float[] floatArray, double doubleValue, double[] doubleArray, java.lang.String stringValue, java.lang.String[] stringArray, java.util.List listValue, android.aidl.loggable.Data dataValue, android.os.IBinder binderValue, android.os.ParcelFileDescriptor pfdValue, android.os.ParcelFileDescriptor[] pfdArray) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); java.lang.String[] _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeBoolean(boolValue); _data.writeBooleanArray(boolArray); _data.writeByte(byteValue); _data.writeByteArray(byteArray); _data.writeInt(((int)charValue)); _data.writeCharArray(charArray); _data.writeInt(intValue); _data.writeIntArray(intArray); _data.writeLong(longValue); _data.writeLongArray(longArray); _data.writeFloat(floatValue); _data.writeFloatArray(floatArray); _data.writeDouble(doubleValue); _data.writeDoubleArray(doubleArray); _data.writeString(stringValue); _data.writeStringArray(stringArray); _data.writeStringList(listValue); _data.writeTypedObject(dataValue, 0); _data.writeStrongBinder(binderValue); _data.writeTypedObject(pfdValue, 0); _data.writeTypedArray(pfdArray, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_LogThis, _data, _reply, 0); _reply.readException(); _result = _reply.createStringArray(); _reply.readBooleanArray(boolArray); _reply.readByteArray(byteArray); _reply.readCharArray(charArray); _reply.readIntArray(intArray); _reply.readLongArray(longArray); _reply.readFloatArray(floatArray); _reply.readDoubleArray(doubleArray); _reply.readStringArray(stringArray); _reply.readStringList(listValue); if ((0!=_reply.readInt())) { pfdValue = android.os.ParcelFileDescriptor.CREATOR.createFromParcel(_reply); } _reply.readTypedArray(pfdArray, android.os.ParcelFileDescriptor.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } } static final int TRANSACTION_LogThis = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.loggable.ILoggableInterface"; public java.lang.String[] LogThis(boolean boolValue, boolean[] boolArray, byte byteValue, byte[] byteArray, char charValue, char[] charArray, int intValue, int[] intArray, long longValue, long[] longArray, float floatValue, float[] floatArray, double doubleValue, double[] doubleArray, java.lang.String stringValue, java.lang.String[] stringArray, java.util.List listValue, android.aidl.loggable.Data dataValue, android.os.IBinder binderValue, android.os.ParcelFileDescriptor pfdValue, android.os.ParcelFileDescriptor[] pfdArray) throws android.os.RemoteException; public interface ISub extends android.os.IInterface { /** Default implementation for ISub. */ public static class Default implements android.aidl.loggable.ILoggableInterface.ISub { @Override public void Log(int value) throws android.os.RemoteException { } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.loggable.ILoggableInterface.ISub { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.loggable.ILoggableInterface.ISub interface, * generating a proxy if needed. */ public static android.aidl.loggable.ILoggableInterface.ISub asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.loggable.ILoggableInterface.ISub))) { return ((android.aidl.loggable.ILoggableInterface.ISub)iin); } return new android.aidl.loggable.ILoggableInterface.ISub.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_Log: { return "Log"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } switch (code) { case TRANSACTION_Log: { int _arg0; _arg0 = data.readInt(); data.enforceNoDataAvail(); this.Log(_arg0); reply.writeNoException(); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.loggable.ILoggableInterface.ISub { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public void Log(int value) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeInt(value); boolean _status = mRemote.transact(Stub.TRANSACTION_Log, _data, _reply, 0); _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } } static final int TRANSACTION_Log = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); /** @hide */ public int getMaxTransactionId() { return 0; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android.aidl.loggable.ILoggableInterface.ISub"; public void Log(int value) throws android.os.RemoteException; } } ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-java-source_gen_android_aidl0100644 0000000 0000000 00000000235 15172120304 033362 xustar000000000 0000000 129 path=tests/golden_output/frozen/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/ILoggableInterface.java.d 28 mtime=1776853188.7050000 tests/golden_output/frozen/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/ILogga0100644 0000000 0000000 00000000607 15172120304 033144 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/ILoggableInterface.java : \ system/tools/aidl/tests/android/aidl/loggable/ILoggableInterface.aidl \ system/tools/aidl/tests/android/aidl/loggable/Data.aidl \ system/tools/aidl/tests/android/aidl/loggable/Union.aidl \ system/tools/aidl/tests/android/aidl/loggable/Enum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-java-source_gen_android_aidl0100644 0000000 0000000 00000000216 15172120304 033361 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/Union.java 28 mtime=1776853188.7050000 tests/golden_output/frozen/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/Union.0100644 0000000 0000000 00000006644 15172120304 033157 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/Union.java.d -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-java-source/gen -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Union.aidl */ package android.aidl.loggable; public final class Union implements android.os.Parcelable { // tags for union fields public final static int num = 0; // int num; public final static int str = 1; // String str; private int _tag; private Object _value; public Union() { int _value = 43; this._tag = num; this._value = _value; } private Union(android.os.Parcel _aidl_parcel) { readFromParcel(_aidl_parcel); } private Union(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public int getTag() { return _tag; } // int num; public static Union num(int _value) { return new Union(num, _value); } public int getNum() { _assertTag(num); return (int) _value; } public void setNum(int _value) { _set(num, _value); } // String str; public static Union str(java.lang.String _value) { return new Union(str, _value); } public java.lang.String getStr() { _assertTag(str); return (java.lang.String) _value; } public void setStr(java.lang.String _value) { _set(str, _value); } public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public Union createFromParcel(android.os.Parcel _aidl_source) { return new Union(_aidl_source); } @Override public Union[] newArray(int _aidl_size) { return new Union[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { _aidl_parcel.writeInt(_tag); switch (_tag) { case num: _aidl_parcel.writeInt(getNum()); break; case str: _aidl_parcel.writeString(getStr()); break; } } public void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_tag; _aidl_tag = _aidl_parcel.readInt(); switch (_aidl_tag) { case num: { int _aidl_value; _aidl_value = _aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } case str: { java.lang.String _aidl_value; _aidl_value = _aidl_parcel.readString(); _set(_aidl_tag, _aidl_value); return; } } throw new IllegalArgumentException("union: unknown tag: " + _aidl_tag); } @Override public int describeContents() { int _mask = 0; switch (getTag()) { } return _mask; } private void _assertTag(int tag) { if (getTag() != tag) { throw new IllegalStateException("bad access: " + _tagString(tag) + ", " + _tagString(getTag()) + " is available."); } } private String _tagString(int _tag) { switch (_tag) { case num: return "num"; case str: return "str"; } throw new IllegalStateException("unknown field: " + _tag); } private void _set(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public static @interface Tag { public static final int num = 0; public static final int str = 1; } } ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-java-source_gen_android_aidl0100644 0000000 0000000 00000000220 15172120304 033354 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/Union.java.d 28 mtime=1776853188.7050000 tests/golden_output/frozen/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/Union.0100644 0000000 0000000 00000000270 15172120304 033144 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-java-source/gen/android/aidl/loggable/Union.java : \ system/tools/aidl/tests/android/aidl/loggable/Union.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-java-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 032751 xustar000000000 0000000 28 mtime=1776853188.7050000 tests/golden_output/frozen/aidl_test_loggable_interface-java-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 027663 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-ndk-source_0100644 0000000 0000000 00000000034 15172120304 030027 xustar000000000 0000000 28 mtime=1776853188.7050000 tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/0040755 0000000 0000000 00000000000 15172120304 025034 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-ndk-source_gen_0100644 0000000 0000000 00000000034 15172120304 030660 xustar000000000 0000000 28 mtime=1776853188.7050000 tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/0040755 0000000 0000000 00000000000 15172120304 025605 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-ndk-source_gen_android_0100644 0000000 0000000 00000000034 15172120304 032360 xustar000000000 0000000 28 mtime=1776853188.7050000 tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 027225 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-ndk-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 033351 xustar000000000 0000000 28 mtime=1776853188.7050000 tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 030136 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-ndk-source_gen_android_aidl_0100644 0000000 0000000 00000000034 15172120304 033351 xustar000000000 0000000 28 mtime=1776853188.7050000 tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/0040755 0000000 0000000 00000000000 15172120304 031712 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-ndk-source_gen_android_aidl_0100644 0000000 0000000 00000000213 15172120304 033350 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/Data.cpp 28 mtime=1776853188.7060000 tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/Data.cp0100644 0000000 0000000 00000007647 15172120304 033122 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging/android/aidl/loggable/Data.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Data.aidl */ #include "aidl/android/aidl/loggable/Data.h" #include namespace aidl { namespace android { namespace aidl { namespace loggable { const char* Data::descriptor = "android.aidl.loggable.Data"; binder_status_t Data::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &num); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &str); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &nestedUnion); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &nestedEnum); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t Data::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, num); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, str); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, nestedUnion); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, nestedEnum); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace loggable } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-ndk-source_gen_android_aidl_0100644 0000000 0000000 00000000215 15172120304 033352 xustar000000000 0000000 113 path=tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/Data.cpp.d 28 mtime=1776853188.7060000 tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/Data.cp0100644 0000000 0000000 00000000455 15172120304 033110 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/Data.cpp : \ system/tools/aidl/tests/android/aidl/loggable/Data.aidl \ system/tools/aidl/tests/android/aidl/loggable/Enum.aidl \ system/tools/aidl/tests/android/aidl/loggable/Union.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-ndk-source_gen_android_aidl_0100644 0000000 0000000 00000000213 15172120304 033350 xustar000000000 0000000 111 path=tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/Enum.cpp 28 mtime=1776853188.7060000 tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/Enum.cp0100644 0000000 0000000 00000001272 15172120304 033141 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging/android/aidl/loggable/Enum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Enum.aidl */ // This file is intentionally left blank as placeholder for enum declaration. ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-ndk-source_gen_android_aidl_0100644 0000000 0000000 00000000215 15172120304 033352 xustar000000000 0000000 113 path=tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/Enum.cpp.d 28 mtime=1776853188.7060000 tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/Enum.cp0100644 0000000 0000000 00000000264 15172120304 033141 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/Enum.cpp : \ system/tools/aidl/tests/android/aidl/loggable/Enum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-ndk-source_gen_android_aidl_0100644 0000000 0000000 00000000231 15172120304 033350 xustar000000000 0000000 125 path=tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/ILoggableInterface.cpp 28 mtime=1776853188.7060000 tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/ILoggab0100644 0000000 0000000 00000107025 15172120304 033143 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging/android/aidl/loggable/ILoggableInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/ILoggableInterface.aidl */ #include "aidl/android/aidl/loggable/ILoggableInterface.h" #include #include #include #include namespace { struct ScopedTrace { inline explicit ScopedTrace(const char* name) { ATrace_beginSection(name); } inline ~ScopedTrace() { ATrace_endSection(); } }; } // namespace namespace aidl { namespace android { namespace aidl { namespace loggable { static binder_status_t _aidl_android_aidl_loggable_ILoggableInterface_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*LogThis*/): { bool in_boolValue; std::vector in_boolArray; int8_t in_byteValue; std::vector in_byteArray; char16_t in_charValue; std::vector in_charArray; int32_t in_intValue; std::vector in_intArray; int64_t in_longValue; std::vector in_longArray; float in_floatValue; std::vector in_floatArray; double in_doubleValue; std::vector in_doubleArray; std::string in_stringValue; std::vector in_stringArray; std::vector in_listValue; ::aidl::android::aidl::loggable::Data in_dataValue; ::ndk::SpAIBinder in_binderValue; ::ndk::ScopedFileDescriptor in_pfdValue; std::vector<::ndk::ScopedFileDescriptor> in_pfdArray; std::vector _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::ILoggableInterface::LogThis::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_boolValue); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_boolArray); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_byteValue); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_byteArray); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_charValue); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_charArray); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_intValue); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_intArray); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_longValue); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_longArray); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_floatValue); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_floatArray); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_doubleValue); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_doubleArray); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_stringValue); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_stringArray); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_listValue); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_dataValue); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_binderValue); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_in, &in_pfdValue); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_pfdArray); if (_aidl_ret_status != STATUS_OK) break; BnLoggableInterface::TransactionLog _transaction_log; if (BnLoggableInterface::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_boolValue", ::android::internal::ToString(in_boolValue)); _transaction_log.input_args.emplace_back("in_boolArray", ::android::internal::ToString(in_boolArray)); _transaction_log.input_args.emplace_back("in_byteValue", ::android::internal::ToString(in_byteValue)); _transaction_log.input_args.emplace_back("in_byteArray", ::android::internal::ToString(in_byteArray)); _transaction_log.input_args.emplace_back("in_charValue", ::android::internal::ToString(in_charValue)); _transaction_log.input_args.emplace_back("in_charArray", ::android::internal::ToString(in_charArray)); _transaction_log.input_args.emplace_back("in_intValue", ::android::internal::ToString(in_intValue)); _transaction_log.input_args.emplace_back("in_intArray", ::android::internal::ToString(in_intArray)); _transaction_log.input_args.emplace_back("in_longValue", ::android::internal::ToString(in_longValue)); _transaction_log.input_args.emplace_back("in_longArray", ::android::internal::ToString(in_longArray)); _transaction_log.input_args.emplace_back("in_floatValue", ::android::internal::ToString(in_floatValue)); _transaction_log.input_args.emplace_back("in_floatArray", ::android::internal::ToString(in_floatArray)); _transaction_log.input_args.emplace_back("in_doubleValue", ::android::internal::ToString(in_doubleValue)); _transaction_log.input_args.emplace_back("in_doubleArray", ::android::internal::ToString(in_doubleArray)); _transaction_log.input_args.emplace_back("in_stringValue", ::android::internal::ToString(in_stringValue)); _transaction_log.input_args.emplace_back("in_stringArray", ::android::internal::ToString(in_stringArray)); _transaction_log.input_args.emplace_back("in_listValue", ::android::internal::ToString(in_listValue)); _transaction_log.input_args.emplace_back("in_dataValue", ::android::internal::ToString(in_dataValue)); _transaction_log.input_args.emplace_back("in_binderValue", ::android::internal::ToString(in_binderValue)); _transaction_log.input_args.emplace_back("in_pfdValue", ::android::internal::ToString(in_pfdValue)); _transaction_log.input_args.emplace_back("in_pfdArray", ::android::internal::ToString(in_pfdArray)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->LogThis(in_boolValue, &in_boolArray, in_byteValue, &in_byteArray, in_charValue, &in_charArray, in_intValue, &in_intArray, in_longValue, &in_longArray, in_floatValue, &in_floatArray, in_doubleValue, &in_doubleArray, in_stringValue, &in_stringArray, &in_listValue, in_dataValue, in_binderValue, &in_pfdValue, &in_pfdArray, &_aidl_return); if (BnLoggableInterface::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.loggable.ILoggableInterface"; _transaction_log.method_name = "LogThis"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.output_args.emplace_back("in_boolArray", ::android::internal::ToString(in_boolArray)); _transaction_log.output_args.emplace_back("in_byteArray", ::android::internal::ToString(in_byteArray)); _transaction_log.output_args.emplace_back("in_charArray", ::android::internal::ToString(in_charArray)); _transaction_log.output_args.emplace_back("in_intArray", ::android::internal::ToString(in_intArray)); _transaction_log.output_args.emplace_back("in_longArray", ::android::internal::ToString(in_longArray)); _transaction_log.output_args.emplace_back("in_floatArray", ::android::internal::ToString(in_floatArray)); _transaction_log.output_args.emplace_back("in_doubleArray", ::android::internal::ToString(in_doubleArray)); _transaction_log.output_args.emplace_back("in_stringArray", ::android::internal::ToString(in_stringArray)); _transaction_log.output_args.emplace_back("in_listValue", ::android::internal::ToString(in_listValue)); _transaction_log.output_args.emplace_back("in_pfdValue", ::android::internal::ToString(in_pfdValue)); _transaction_log.output_args.emplace_back("in_pfdArray", ::android::internal::ToString(in_pfdArray)); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnLoggableInterface::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, in_boolArray); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, in_byteArray); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, in_charArray); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, in_intArray); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, in_longArray); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, in_floatArray); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, in_doubleArray); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, in_stringArray); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, in_listValue); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_out, in_pfdValue); if (_aidl_ret_status != STATUS_OK) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, in_pfdArray); if (_aidl_ret_status != STATUS_OK) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_loggable_ILoggableInterface_clazz = ::ndk::ICInterface::defineClass(ILoggableInterface::descriptor, _aidl_android_aidl_loggable_ILoggableInterface_onTransact); BpLoggableInterface::BpLoggableInterface(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} BpLoggableInterface::~BpLoggableInterface() {} std::function BpLoggableInterface::logFunc; ::ndk::ScopedAStatus BpLoggableInterface::LogThis(bool in_boolValue, std::vector* in_boolArray, int8_t in_byteValue, std::vector* in_byteArray, char16_t in_charValue, std::vector* in_charArray, int32_t in_intValue, std::vector* in_intArray, int64_t in_longValue, std::vector* in_longArray, float in_floatValue, std::vector* in_floatArray, double in_doubleValue, std::vector* in_doubleArray, const std::string& in_stringValue, std::vector* in_stringArray, std::vector* in_listValue, const ::aidl::android::aidl::loggable::Data& in_dataValue, const ::ndk::SpAIBinder& in_binderValue, ::ndk::ScopedFileDescriptor* in_pfdValue, std::vector<::ndk::ScopedFileDescriptor>* in_pfdArray, std::vector* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; BpLoggableInterface::TransactionLog _transaction_log; if (BpLoggableInterface::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_boolValue", ::android::internal::ToString(in_boolValue)); _transaction_log.input_args.emplace_back("in_boolArray", ::android::internal::ToString(*in_boolArray)); _transaction_log.input_args.emplace_back("in_byteValue", ::android::internal::ToString(in_byteValue)); _transaction_log.input_args.emplace_back("in_byteArray", ::android::internal::ToString(*in_byteArray)); _transaction_log.input_args.emplace_back("in_charValue", ::android::internal::ToString(in_charValue)); _transaction_log.input_args.emplace_back("in_charArray", ::android::internal::ToString(*in_charArray)); _transaction_log.input_args.emplace_back("in_intValue", ::android::internal::ToString(in_intValue)); _transaction_log.input_args.emplace_back("in_intArray", ::android::internal::ToString(*in_intArray)); _transaction_log.input_args.emplace_back("in_longValue", ::android::internal::ToString(in_longValue)); _transaction_log.input_args.emplace_back("in_longArray", ::android::internal::ToString(*in_longArray)); _transaction_log.input_args.emplace_back("in_floatValue", ::android::internal::ToString(in_floatValue)); _transaction_log.input_args.emplace_back("in_floatArray", ::android::internal::ToString(*in_floatArray)); _transaction_log.input_args.emplace_back("in_doubleValue", ::android::internal::ToString(in_doubleValue)); _transaction_log.input_args.emplace_back("in_doubleArray", ::android::internal::ToString(*in_doubleArray)); _transaction_log.input_args.emplace_back("in_stringValue", ::android::internal::ToString(in_stringValue)); _transaction_log.input_args.emplace_back("in_stringArray", ::android::internal::ToString(*in_stringArray)); _transaction_log.input_args.emplace_back("in_listValue", ::android::internal::ToString(*in_listValue)); _transaction_log.input_args.emplace_back("in_dataValue", ::android::internal::ToString(in_dataValue)); _transaction_log.input_args.emplace_back("in_binderValue", ::android::internal::ToString(in_binderValue)); _transaction_log.input_args.emplace_back("in_pfdValue", ::android::internal::ToString(*in_pfdValue)); _transaction_log.input_args.emplace_back("in_pfdArray", ::android::internal::ToString(*in_pfdArray)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::ILoggableInterface::LogThis::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_boolValue); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), *in_boolArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_byteValue); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), *in_byteArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_charValue); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), *in_charArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_intValue); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), *in_intArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_longValue); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), *in_longArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_floatValue); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), *in_floatArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_doubleValue); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), *in_doubleArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_stringValue); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), *in_stringArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), *in_listValue); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_dataValue); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), in_binderValue); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeNullableData(_aidl_in.get(), *in_pfdValue); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), *in_pfdArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*LogThis*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ILoggableInterface::getDefaultImpl()) { _aidl_status = ILoggableInterface::getDefaultImpl()->LogThis(in_boolValue, in_boolArray, in_byteValue, in_byteArray, in_charValue, in_charArray, in_intValue, in_intArray, in_longValue, in_longArray, in_floatValue, in_floatArray, in_doubleValue, in_doubleArray, in_stringValue, in_stringArray, in_listValue, in_dataValue, in_binderValue, in_pfdValue, in_pfdArray, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), in_boolArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), in_byteArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), in_charArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), in_intArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), in_longArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), in_floatArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), in_doubleArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), in_stringArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), in_listValue); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readNullableData(_aidl_out.get(), in_pfdValue); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), in_pfdArray); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (BpLoggableInterface::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.loggable.ILoggableInterface"; _transaction_log.method_name = "LogThis"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.output_args.emplace_back("in_boolArray", ::android::internal::ToString(*in_boolArray)); _transaction_log.output_args.emplace_back("in_byteArray", ::android::internal::ToString(*in_byteArray)); _transaction_log.output_args.emplace_back("in_charArray", ::android::internal::ToString(*in_charArray)); _transaction_log.output_args.emplace_back("in_intArray", ::android::internal::ToString(*in_intArray)); _transaction_log.output_args.emplace_back("in_longArray", ::android::internal::ToString(*in_longArray)); _transaction_log.output_args.emplace_back("in_floatArray", ::android::internal::ToString(*in_floatArray)); _transaction_log.output_args.emplace_back("in_doubleArray", ::android::internal::ToString(*in_doubleArray)); _transaction_log.output_args.emplace_back("in_stringArray", ::android::internal::ToString(*in_stringArray)); _transaction_log.output_args.emplace_back("in_listValue", ::android::internal::ToString(*in_listValue)); _transaction_log.output_args.emplace_back("in_pfdValue", ::android::internal::ToString(*in_pfdValue)); _transaction_log.output_args.emplace_back("in_pfdArray", ::android::internal::ToString(*in_pfdArray)); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpLoggableInterface::logFunc(_transaction_log); } return _aidl_status; } // Source for BnLoggableInterface BnLoggableInterface::BnLoggableInterface() {} BnLoggableInterface::~BnLoggableInterface() {} std::function BnLoggableInterface::logFunc; ::ndk::SpAIBinder BnLoggableInterface::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_loggable_ILoggableInterface_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for ILoggableInterface const char* ILoggableInterface::descriptor = "android.aidl.loggable.ILoggableInterface"; ILoggableInterface::ILoggableInterface() {} ILoggableInterface::~ILoggableInterface() {} std::shared_ptr ILoggableInterface::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_loggable_ILoggableInterface_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t ILoggableInterface::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t ILoggableInterface::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = ILoggableInterface::fromBinder(binder); return STATUS_OK; } bool ILoggableInterface::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!ILoggableInterface::default_impl); if (impl) { ILoggableInterface::default_impl = impl; return true; } return false; } const std::shared_ptr& ILoggableInterface::getDefaultImpl() { return ILoggableInterface::default_impl; } std::shared_ptr ILoggableInterface::default_impl = nullptr; ::ndk::ScopedAStatus ILoggableInterfaceDefault::LogThis(bool /*in_boolValue*/, std::vector* /*in_boolArray*/, int8_t /*in_byteValue*/, std::vector* /*in_byteArray*/, char16_t /*in_charValue*/, std::vector* /*in_charArray*/, int32_t /*in_intValue*/, std::vector* /*in_intArray*/, int64_t /*in_longValue*/, std::vector* /*in_longArray*/, float /*in_floatValue*/, std::vector* /*in_floatArray*/, double /*in_doubleValue*/, std::vector* /*in_doubleArray*/, const std::string& /*in_stringValue*/, std::vector* /*in_stringArray*/, std::vector* /*in_listValue*/, const ::aidl::android::aidl::loggable::Data& /*in_dataValue*/, const ::ndk::SpAIBinder& /*in_binderValue*/, ::ndk::ScopedFileDescriptor* /*in_pfdValue*/, std::vector<::ndk::ScopedFileDescriptor>* /*in_pfdArray*/, std::vector* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::SpAIBinder ILoggableInterfaceDefault::asBinder() { return ::ndk::SpAIBinder(); } bool ILoggableInterfaceDefault::isRemote() { return false; } } // namespace loggable } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace loggable { static binder_status_t _aidl_android_aidl_loggable_ILoggableInterface_ISub_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*Log*/): { int32_t in_value; ScopedTrace _aidl_trace("AIDL::ndk::ISub::Log::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_value); if (_aidl_ret_status != STATUS_OK) break; ILoggableInterface::BnSub::TransactionLog _transaction_log; if (ILoggableInterface::BnSub::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_value", ::android::internal::ToString(in_value)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->Log(in_value); if (ILoggableInterface::BnSub::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.loggable.ILoggableInterface.ISub"; _transaction_log.method_name = "Log"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); ILoggableInterface::BnSub::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_loggable_ILoggableInterface_ISub_clazz = ::ndk::ICInterface::defineClass(ILoggableInterface::ISub::descriptor, _aidl_android_aidl_loggable_ILoggableInterface_ISub_onTransact); ILoggableInterface::BpSub::BpSub(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} ILoggableInterface::BpSub::~BpSub() {} std::function ILoggableInterface::BpSub::logFunc; ::ndk::ScopedAStatus ILoggableInterface::BpSub::Log(int32_t in_value) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; ILoggableInterface::BpSub::TransactionLog _transaction_log; if (ILoggableInterface::BpSub::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_value", ::android::internal::ToString(in_value)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::ISub::Log::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_value); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*Log*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ISub::getDefaultImpl()) { _aidl_status = ISub::getDefaultImpl()->Log(in_value); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (ILoggableInterface::BpSub::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.loggable.ILoggableInterface.ISub"; _transaction_log.method_name = "Log"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); ILoggableInterface::BpSub::logFunc(_transaction_log); } return _aidl_status; } // Source for BnSub ILoggableInterface::BnSub::BnSub() {} ILoggableInterface::BnSub::~BnSub() {} std::function ILoggableInterface::BnSub::logFunc; ::ndk::SpAIBinder ILoggableInterface::BnSub::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_loggable_ILoggableInterface_ISub_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } // Source for ISub const char* ILoggableInterface::ISub::descriptor = "android.aidl.loggable.ILoggableInterface.ISub"; ILoggableInterface::ISub::ISub() {} ILoggableInterface::ISub::~ISub() {} std::shared_ptr ILoggableInterface::ISub::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_loggable_ILoggableInterface_ISub_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t ILoggableInterface::ISub::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t ILoggableInterface::ISub::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = ISub::fromBinder(binder); return STATUS_OK; } bool ILoggableInterface::ISub::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!ISub::default_impl); if (impl) { ISub::default_impl = impl; return true; } return false; } const std::shared_ptr& ILoggableInterface::ISub::getDefaultImpl() { return ISub::default_impl; } std::shared_ptr ILoggableInterface::ISub::default_impl = nullptr; ::ndk::ScopedAStatus ILoggableInterface::ISubDefault::Log(int32_t /*in_value*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::SpAIBinder ILoggableInterface::ISubDefault::asBinder() { return ::ndk::SpAIBinder(); } bool ILoggableInterface::ISubDefault::isRemote() { return false; } } // namespace loggable } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-ndk-source_gen_android_aidl_0100644 0000000 0000000 00000000233 15172120304 033352 xustar000000000 0000000 127 path=tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/ILoggableInterface.cpp.d 28 mtime=1776853188.7070000 tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/ILoggab0100644 0000000 0000000 00000000605 15172120304 033137 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/ILoggableInterface.cpp : \ system/tools/aidl/tests/android/aidl/loggable/ILoggableInterface.aidl \ system/tools/aidl/tests/android/aidl/loggable/Data.aidl \ system/tools/aidl/tests/android/aidl/loggable/Union.aidl \ system/tools/aidl/tests/android/aidl/loggable/Enum.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-ndk-source_gen_android_aidl_0100644 0000000 0000000 00000000214 15172120304 033351 xustar000000000 0000000 112 path=tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/Union.cpp 28 mtime=1776853188.7070000 tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/Union.c0100644 0000000 0000000 00000004651 15172120304 033151 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging/android/aidl/loggable/Union.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Union.aidl */ #include "aidl/android/aidl/loggable/Union.h" #include namespace aidl { namespace android { namespace aidl { namespace loggable { const char* Union::descriptor = "android.aidl.loggable.Union"; binder_status_t Union::readFromParcel(const AParcel* _parcel) { binder_status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_tag)) != STATUS_OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case num: { int32_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case str: { std::string _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } } return STATUS_BAD_VALUE; } binder_status_t Union::writeToParcel(AParcel* _parcel) const { binder_status_t _aidl_ret_status = ::ndk::AParcel_writeData(_parcel, static_cast(getTag())); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; switch (getTag()) { case num: return ::ndk::AParcel_writeData(_parcel, get()); case str: return ::ndk::AParcel_writeData(_parcel, get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace loggable } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-ndk-source_gen_android_aidl_0100644 0000000 0000000 00000000216 15172120304 033353 xustar000000000 0000000 114 path=tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/Union.cpp.d 28 mtime=1776853188.7070000 tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/Union.c0100644 0000000 0000000 00000000266 15172120304 033147 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/android/aidl/loggable/Union.cpp : \ system/tools/aidl/tests/android/aidl/loggable/Union.aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-ndk-source_gen_include_0100644 0000000 0000000 00000000034 15172120304 032363 xustar000000000 0000000 28 mtime=1776853188.7070000 tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/include/0040755 0000000 0000000 00000000000 15172120304 027230 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-ndk-source_gen_include_aidl_0100644 0000000 0000000 00000000034 15172120304 033354 xustar000000000 0000000 28 mtime=1776853188.7070000 tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/include/aidl/0040755 0000000 0000000 00000000000 15172120304 030141 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-ndk-source_gen_include_aidl_0100644 0000000 0000000 00000000034 15172120304 033354 xustar000000000 0000000 28 mtime=1776853188.7070000 tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/0040755 0000000 0000000 00000000000 15172120304 031561 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-ndk-source_gen_include_aidl_0100644 0000000 0000000 00000000034 15172120304 033354 xustar000000000 0000000 28 mtime=1776853188.7070000 tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/0040755 0000000 0000000 00000000000 15172120304 032472 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-ndk-source_gen_include_aidl_0100644 0000000 0000000 00000000220 15172120304 033351 xustar000000000 0000000 116 path=tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/ 28 mtime=1776853188.7070000 tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/log0040755 0000000 0000000 00000000000 15172120304 033174 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-ndk-source_gen_include_aidl_0100644 0000000 0000000 00000000230 15172120304 033352 xustar000000000 0000000 124 path=tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/BnData.h 28 mtime=1776853188.7070000 tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/log0100644 0000000 0000000 00000001252 15172120304 033173 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging/android/aidl/loggable/Data.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Data.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-ndk-source_gen_include_aidl_0100644 0000000 0000000 00000000230 15172120304 033352 xustar000000000 0000000 124 path=tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/BnEnum.h 28 mtime=1776853188.7070000 tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/log0100644 0000000 0000000 00000001242 15172120304 033172 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging/android/aidl/loggable/Enum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Enum.aidl */ #error TODO(b/111362593) enums do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-ndk-source_gen_include_aidl_0100644 0000000 0000000 00000000245 15172120304 033360 xustar000000000 0000000 137 path=tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/BnLoggableInterface.h 28 mtime=1776853188.7070000 tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/log0100644 0000000 0000000 00000006136 15172120304 033201 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging/android/aidl/loggable/ILoggableInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/ILoggableInterface.aidl */ #pragma once #include "aidl/android/aidl/loggable/ILoggableInterface.h" #include #include #ifndef __BIONIC__ #ifndef __assert2 #define __assert2(a,b,c,d) ((void)0) #endif #endif namespace aidl { namespace android { namespace aidl { namespace loggable { class BnLoggableInterface : public ::ndk::BnCInterface { public: BnLoggableInterface(); virtual ~BnLoggableInterface(); struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; protected: ::ndk::SpAIBinder createBinder() override; private: }; class ILoggableInterfaceDelegator : public BnLoggableInterface { public: explicit ILoggableInterfaceDelegator(const std::shared_ptr &impl) : _impl(impl) { } ::ndk::ScopedAStatus LogThis(bool in_boolValue, std::vector* in_boolArray, int8_t in_byteValue, std::vector* in_byteArray, char16_t in_charValue, std::vector* in_charArray, int32_t in_intValue, std::vector* in_intArray, int64_t in_longValue, std::vector* in_longArray, float in_floatValue, std::vector* in_floatArray, double in_doubleValue, std::vector* in_doubleArray, const std::string& in_stringValue, std::vector* in_stringArray, std::vector* in_listValue, const ::aidl::android::aidl::loggable::Data& in_dataValue, const ::ndk::SpAIBinder& in_binderValue, ::ndk::ScopedFileDescriptor* in_pfdValue, std::vector<::ndk::ScopedFileDescriptor>* in_pfdArray, std::vector* _aidl_return) override { return _impl->LogThis(in_boolValue, in_boolArray, in_byteValue, in_byteArray, in_charValue, in_charArray, in_intValue, in_intArray, in_longValue, in_longArray, in_floatValue, in_floatArray, in_doubleValue, in_doubleArray, in_stringValue, in_stringArray, in_listValue, in_dataValue, in_binderValue, in_pfdValue, in_pfdArray, _aidl_return); } protected: private: std::shared_ptr _impl; }; } // namespace loggable } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-ndk-source_gen_include_aidl_0100644 0000000 0000000 00000000231 15172120304 033353 xustar000000000 0000000 125 path=tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/BnUnion.h 28 mtime=1776853188.7080000 tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/log0100644 0000000 0000000 00000001254 15172120304 033175 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging/android/aidl/loggable/Union.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Union.aidl */ #error TODO(b/111362593) defined_types do not have bn classes ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-ndk-source_gen_include_aidl_0100644 0000000 0000000 00000000230 15172120304 033352 xustar000000000 0000000 124 path=tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/BpData.h 28 mtime=1776853188.7080000 tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/log0100644 0000000 0000000 00000001252 15172120304 033173 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging/android/aidl/loggable/Data.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Data.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-ndk-source_gen_include_aidl_0100644 0000000 0000000 00000000230 15172120304 033352 xustar000000000 0000000 124 path=tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/BpEnum.h 28 mtime=1776853188.7080000 tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/log0100644 0000000 0000000 00000001242 15172120304 033172 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging/android/aidl/loggable/Enum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Enum.aidl */ #error TODO(b/111362593) enums do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-ndk-source_gen_include_aidl_0100644 0000000 0000000 00000000245 15172120304 033360 xustar000000000 0000000 137 path=tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/BpLoggableInterface.h 28 mtime=1776853188.7080000 tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/log0100644 0000000 0000000 00000004731 15172120304 033200 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging/android/aidl/loggable/ILoggableInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/ILoggableInterface.aidl */ #pragma once #include "aidl/android/aidl/loggable/ILoggableInterface.h" #include #include #include #include #include namespace aidl { namespace android { namespace aidl { namespace loggable { class BpLoggableInterface : public ::ndk::BpCInterface { public: explicit BpLoggableInterface(const ::ndk::SpAIBinder& binder); virtual ~BpLoggableInterface(); ::ndk::ScopedAStatus LogThis(bool in_boolValue, std::vector* in_boolArray, int8_t in_byteValue, std::vector* in_byteArray, char16_t in_charValue, std::vector* in_charArray, int32_t in_intValue, std::vector* in_intArray, int64_t in_longValue, std::vector* in_longArray, float in_floatValue, std::vector* in_floatArray, double in_doubleValue, std::vector* in_doubleArray, const std::string& in_stringValue, std::vector* in_stringArray, std::vector* in_listValue, const ::aidl::android::aidl::loggable::Data& in_dataValue, const ::ndk::SpAIBinder& in_binderValue, ::ndk::ScopedFileDescriptor* in_pfdValue, std::vector<::ndk::ScopedFileDescriptor>* in_pfdArray, std::vector* _aidl_return) override; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; }; } // namespace loggable } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-ndk-source_gen_include_aidl_0100644 0000000 0000000 00000000231 15172120304 033353 xustar000000000 0000000 125 path=tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/BpUnion.h 28 mtime=1776853188.7080000 tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/log0100644 0000000 0000000 00000001254 15172120304 033175 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging/android/aidl/loggable/Union.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Union.aidl */ #error TODO(b/111362593) defined_types do not have bp classes ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-ndk-source_gen_include_aidl_0100644 0000000 0000000 00000000226 15172120304 033357 xustar000000000 0000000 122 path=tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/Data.h 28 mtime=1776853188.7080000 tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/log0100644 0000000 0000000 00000005413 15172120304 033176 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging/android/aidl/loggable/Data.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Data.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace loggable { class Data { public: typedef std::false_type fixed_size; static const char* descriptor; int32_t num = 0; std::string str; ::aidl::android::aidl::loggable::Union nestedUnion; ::aidl::android::aidl::loggable::Enum nestedEnum = ::aidl::android::aidl::loggable::Enum::FOO; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const Data& _rhs) const { return std::tie(num, str, nestedUnion, nestedEnum) == std::tie(_rhs.num, _rhs.str, _rhs.nestedUnion, _rhs.nestedEnum); } inline bool operator<(const Data& _rhs) const { return std::tie(num, str, nestedUnion, nestedEnum) < std::tie(_rhs.num, _rhs.str, _rhs.nestedUnion, _rhs.nestedEnum); } inline bool operator!=(const Data& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Data& _rhs) const { return _rhs < *this; } inline bool operator>=(const Data& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Data& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "Data{"; _aidl_os << "num: " << ::android::internal::ToString(num); _aidl_os << ", str: " << ::android::internal::ToString(str); _aidl_os << ", nestedUnion: " << ::android::internal::ToString(nestedUnion); _aidl_os << ", nestedEnum: " << ::android::internal::ToString(nestedEnum); _aidl_os << "}"; return _aidl_os.str(); } }; } // namespace loggable } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-ndk-source_gen_include_aidl_0100644 0000000 0000000 00000000226 15172120304 033357 xustar000000000 0000000 122 path=tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/Enum.h 28 mtime=1776853188.7080000 tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/log0100644 0000000 0000000 00000003432 15172120304 033175 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging/android/aidl/loggable/Enum.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Enum.aidl */ #pragma once #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl { namespace android { namespace aidl { namespace loggable { enum class Enum : int8_t { FOO = 42, }; } // namespace loggable } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace loggable { [[nodiscard]] static inline std::string toString(Enum val) { switch(val) { case Enum::FOO: return "FOO"; default: return std::to_string(static_cast(val)); } } } // namespace loggable } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::loggable::Enum::FOO, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-ndk-source_gen_include_aidl_0100644 0000000 0000000 00000000244 15172120304 033357 xustar000000000 0000000 136 path=tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/ILoggableInterface.h 28 mtime=1776853188.7080000 tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/log0100644 0000000 0000000 00000014362 15172120304 033201 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging/android/aidl/loggable/ILoggableInterface.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/ILoggableInterface.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT namespace aidl::android::aidl::loggable { class Data; } // namespace aidl::android::aidl::loggable namespace aidl { namespace android { namespace aidl { namespace loggable { class ILoggableInterfaceDelegator; class ILoggableInterface : public ::ndk::ICInterface { public: typedef ILoggableInterfaceDelegator DefaultDelegator; static const char* descriptor; ILoggableInterface(); virtual ~ILoggableInterface(); class ISubDelegator; class ISub : public ::ndk::ICInterface { public: typedef ISubDelegator DefaultDelegator; static const char* descriptor; ISub(); virtual ~ISub(); static constexpr uint32_t TRANSACTION_Log = FIRST_CALL_TRANSACTION + 0; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus Log(int32_t in_value) = 0; private: static std::shared_ptr default_impl; }; class ISubDefault : public ISub { public: ::ndk::ScopedAStatus Log(int32_t in_value) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; class BpSub : public ::ndk::BpCInterface { public: explicit BpSub(const ::ndk::SpAIBinder& binder); virtual ~BpSub(); ::ndk::ScopedAStatus Log(int32_t in_value) override; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; }; class BnSub : public ::ndk::BnCInterface { public: BnSub(); virtual ~BnSub(); struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; protected: ::ndk::SpAIBinder createBinder() override; private: }; static constexpr uint32_t TRANSACTION_LogThis = FIRST_CALL_TRANSACTION + 0; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus LogThis(bool in_boolValue, std::vector* in_boolArray, int8_t in_byteValue, std::vector* in_byteArray, char16_t in_charValue, std::vector* in_charArray, int32_t in_intValue, std::vector* in_intArray, int64_t in_longValue, std::vector* in_longArray, float in_floatValue, std::vector* in_floatArray, double in_doubleValue, std::vector* in_doubleArray, const std::string& in_stringValue, std::vector* in_stringArray, std::vector* in_listValue, const ::aidl::android::aidl::loggable::Data& in_dataValue, const ::ndk::SpAIBinder& in_binderValue, ::ndk::ScopedFileDescriptor* in_pfdValue, std::vector<::ndk::ScopedFileDescriptor>* in_pfdArray, std::vector* _aidl_return) = 0; private: static std::shared_ptr default_impl; }; class ILoggableInterfaceDefault : public ILoggableInterface { public: ::ndk::ScopedAStatus LogThis(bool in_boolValue, std::vector* in_boolArray, int8_t in_byteValue, std::vector* in_byteArray, char16_t in_charValue, std::vector* in_charArray, int32_t in_intValue, std::vector* in_intArray, int64_t in_longValue, std::vector* in_longArray, float in_floatValue, std::vector* in_floatArray, double in_doubleValue, std::vector* in_doubleArray, const std::string& in_stringValue, std::vector* in_stringArray, std::vector* in_listValue, const ::aidl::android::aidl::loggable::Data& in_dataValue, const ::ndk::SpAIBinder& in_binderValue, ::ndk::ScopedFileDescriptor* in_pfdValue, std::vector<::ndk::ScopedFileDescriptor>* in_pfdArray, std::vector* _aidl_return) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; } // namespace loggable } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-ndk-source_gen_include_aidl_0100644 0000000 0000000 00000000227 15172120304 033360 xustar000000000 0000000 123 path=tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/loggable/Union.h 28 mtime=1776853188.7090000 tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/include/aidl/android/aidl/log0100644 0000000 0000000 00000012126 15172120304 033175 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging/android/aidl/loggable/Union.cpp.d -h out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/aidl_test_loggable_interface-ndk-source/gen/staging -Nsystem/tools/aidl/tests system/tools/aidl/tests/android/aidl/loggable/Union.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace aidl { namespace android { namespace aidl { namespace loggable { class Union { public: typedef std::false_type fixed_size; static const char* descriptor; enum class Tag : int32_t { num = 0, str = 1, }; // Expose tag symbols for legacy code static const inline Tag num = Tag::num; static const inline Tag str = Tag::str; template static constexpr bool _not_self = !std::is_same_v>, Union>; Union() : _value(std::in_place_index(num)>, int32_t(43)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr Union(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit Union(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static Union make(_Tp&&... _args) { return Union(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static Union make(std::initializer_list<_Tp> _il, _Up&&... _args) { return Union(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } binder_status_t readFromParcel(const AParcel* _parcel); binder_status_t writeToParcel(AParcel* _parcel) const; inline bool operator==(const Union& _rhs) const { return _value == _rhs._value; } inline bool operator<(const Union& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const Union& _rhs) const { return !(*this == _rhs); } inline bool operator>(const Union& _rhs) const { return _rhs < *this; } inline bool operator>=(const Union& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const Union& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream os; os << "Union{"; switch (getTag()) { case num: os << "num: " << ::android::internal::ToString(get()); break; case str: os << "str: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant _value; }; } // namespace loggable } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace loggable { [[nodiscard]] static inline std::string toString(Union::Tag val) { switch(val) { case Union::Tag::num: return "num"; case Union::Tag::str: return "str"; default: return std::to_string(static_cast(val)); } } } // namespace loggable } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::loggable::Union::Tag::num, aidl::android::aidl::loggable::Union::Tag::str, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_frozen_aidl_test_loggable_interface-ndk-source_gen_timestamp0100644 0000000 0000000 00000000034 15172120304 032604 xustar000000000 0000000 28 mtime=1776853188.7090000 tests/golden_output/frozen/aidl_test_loggable_interface-ndk-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 027516 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_0100644 0000000 0000000 00000000034 15172120304 021275 xustar000000000 0000000 28 mtime=1776853188.7090000 tests/golden_output/frozen/tests/0040755 0000000 0000000 00000000000 15172120304 016302 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_0100644 0000000 0000000 00000000034 15172120304 025111 xustar000000000 0000000 28 mtime=1776853188.7090000 tests/golden_output/frozen/tests/trunk_stable_test/0040755 0000000 0000000 00000000000 15172120304 022036 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-cpp-so0100644 0000000 0000000 00000000034 15172120304 033165 xustar000000000 0000000 28 mtime=1776853188.7090000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/0040755 0000000 0000000 00000000000 15172120304 031050 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-cpp-so0100644 0000000 0000000 00000000034 15172120304 033165 xustar000000000 0000000 28 mtime=1776853188.7090000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/0040755 0000000 0000000 00000000000 15172120304 031621 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-cpp-so0100644 0000000 0000000 00000000213 15172120304 033164 xustar000000000 0000000 111 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/android/ 28 mtime=1776853188.7090000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/android0040755 0000000 0000000 00000000000 15172120304 033162 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-cpp-so0100644 0000000 0000000 00000000220 15172120304 033162 xustar000000000 0000000 116 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/android/aidl/ 28 mtime=1776853188.7090000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/android0040755 0000000 0000000 00000000000 15172120304 033162 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-cpp-so0100644 0000000 0000000 00000000225 15172120304 033167 xustar000000000 0000000 121 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/android/aidl/test/ 28 mtime=1776853188.7090000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/android0040755 0000000 0000000 00000000000 15172120304 033162 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-cpp-so0100644 0000000 0000000 00000000233 15172120304 033166 xustar000000000 0000000 127 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/android/aidl/test/trunk/ 28 mtime=1776853188.7100000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/android0040755 0000000 0000000 00000000000 15172120304 033162 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-cpp-so0100644 0000000 0000000 00000000257 15172120304 033174 xustar000000000 0000000 147 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/android/aidl/test/trunk/ITrunkStableTest.cpp 28 mtime=1776853188.7100000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/android0100644 0000000 0000000 00000136614 15172120304 033174 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 1 --hash 88311b9118fb6fe9eff4a2ca19121de0587f6d5f -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/staging/android/aidl/test/trunk/ITrunkStableTest.cpp.d -h out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/staging -Nsystem/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1 system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/android/aidl/test/trunk/ITrunkStableTest.aidl */ #include #include namespace android { namespace aidl { namespace test { namespace trunk { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE(TrunkStableTest, "android.aidl.test.trunk.ITrunkStableTest") } // namespace trunk } // namespace test } // namespace aidl } // namespace android #include #include #include #include #include namespace android { namespace aidl { namespace test { namespace trunk { BpTrunkStableTest::BpTrunkStableTest(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } std::function BpTrunkStableTest::logFunc; ::android::binder::Status BpTrunkStableTest::repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::repeatParcelable::cppClient"); BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("input", ::android::internal::ToString(input)); } auto _log_start = std::chrono::steady_clock::now(); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTrunkStableTest::TRANSACTION_repeatParcelable, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) [[unlikely]] { return ITrunkStableTest::getDefaultImpl()->repeatParcelable(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatParcelable"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::android::binder::Status BpTrunkStableTest::repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum input, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::repeatEnum::cppClient"); BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("input", ::android::internal::ToString(input)); } auto _log_start = std::chrono::steady_clock::now(); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeByte(static_cast(input)); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTrunkStableTest::TRANSACTION_repeatEnum, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) [[unlikely]] { return ITrunkStableTest::getDefaultImpl()->repeatEnum(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readByte(reinterpret_cast(_aidl_return)); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatEnum"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::android::binder::Status BpTrunkStableTest::repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& input, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::repeatUnion::cppClient"); BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("input", ::android::internal::ToString(input)); } auto _log_start = std::chrono::steady_clock::now(); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTrunkStableTest::TRANSACTION_repeatUnion, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) [[unlikely]] { return ITrunkStableTest::getDefaultImpl()->repeatUnion(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatUnion"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::android::binder::Status BpTrunkStableTest::callMyCallback(const ::android::sp<::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& cb) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::callMyCallback::cppClient"); BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("cb", ::android::internal::ToString(cb)); } auto _log_start = std::chrono::steady_clock::now(); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinder(cb); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTrunkStableTest::TRANSACTION_callMyCallback, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) [[unlikely]] { return ITrunkStableTest::getDefaultImpl()->callMyCallback(cb); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "callMyCallback"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } int32_t BpTrunkStableTest::getInterfaceVersion() { if (cached_version_ == -1) { ::android::Parcel data; ::android::Parcel reply; data.writeInterfaceToken(getInterfaceDescriptor()); ::android::status_t err = remote()->transact(BnTrunkStableTest::TRANSACTION_getInterfaceVersion, data, &reply); if (err == ::android::OK) { ::android::binder::Status _aidl_status; err = _aidl_status.readFromParcel(reply); if (err == ::android::OK && _aidl_status.isOk()) { cached_version_ = reply.readInt32(); } } } return cached_version_; } std::string BpTrunkStableTest::getInterfaceHash() { std::lock_guard lockGuard(cached_hash_mutex_); if (cached_hash_ == "-1") { ::android::Parcel data; ::android::Parcel reply; data.writeInterfaceToken(getInterfaceDescriptor()); ::android::status_t err = remote()->transact(BnTrunkStableTest::TRANSACTION_getInterfaceHash, data, &reply); if (err == ::android::OK) { ::android::binder::Status _aidl_status; err = _aidl_status.readFromParcel(reply); if (err == ::android::OK && _aidl_status.isOk()) { reply.readUtf8FromUtf16(&cached_hash_); } } } return cached_hash_; } } // namespace trunk } // namespace test } // namespace aidl } // namespace android #include #include #include #include #include namespace android { namespace aidl { namespace test { namespace trunk { BnTrunkStableTest::BnTrunkStableTest() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t BnTrunkStableTest::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnTrunkStableTest::TRANSACTION_repeatParcelable: { ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable in_input; ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::repeatParcelable::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(repeatParcelable(in_input, &_aidl_return)); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatParcelable"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTrunkStableTest::TRANSACTION_repeatEnum: { ::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input; ::android::aidl::test::trunk::ITrunkStableTest::MyEnum _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::repeatEnum::cppServer"); _aidl_ret_status = _aidl_data.readByte(reinterpret_cast(&in_input)); if (((_aidl_ret_status) != (::android::OK))) { break; } BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(repeatEnum(in_input, &_aidl_return)); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatEnum"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeByte(static_cast(_aidl_return)); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTrunkStableTest::TRANSACTION_repeatUnion: { ::android::aidl::test::trunk::ITrunkStableTest::MyUnion in_input; ::android::aidl::test::trunk::ITrunkStableTest::MyUnion _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::repeatUnion::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(repeatUnion(in_input, &_aidl_return)); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatUnion"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTrunkStableTest::TRANSACTION_callMyCallback: { ::android::sp<::android::aidl::test::trunk::ITrunkStableTest::IMyCallback> in_cb; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::callMyCallback::cppServer"); _aidl_ret_status = _aidl_data.readStrongBinder(&in_cb); if (((_aidl_ret_status) != (::android::OK))) { break; } BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_cb", ::android::internal::ToString(in_cb)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(callMyCallback(in_cb)); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "callMyCallback"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; case BnTrunkStableTest::TRANSACTION_getInterfaceVersion: { _aidl_data.checkInterface(this); _aidl_reply->writeNoException(); _aidl_reply->writeInt32(ITrunkStableTest::VERSION); } break; case BnTrunkStableTest::TRANSACTION_getInterfaceHash: { _aidl_data.checkInterface(this); _aidl_reply->writeNoException(); _aidl_reply->writeUtf8AsUtf16(ITrunkStableTest::HASH); } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } int32_t BnTrunkStableTest::getInterfaceVersion() { return ITrunkStableTest::VERSION; } std::string BnTrunkStableTest::getInterfaceHash() { return ITrunkStableTest::HASH; } std::function BnTrunkStableTest::logFunc; } // namespace trunk } // namespace test } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace test { namespace trunk { ::android::status_t ITrunkStableTest::MyParcelable::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&a); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&b); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t ITrunkStableTest::MyParcelable::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeInt32(a); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(b); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace trunk } // namespace test } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace test { namespace trunk { ::android::status_t ITrunkStableTest::MyUnion::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_tag)) != ::android::OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case a: { int32_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case b: { int32_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } } return ::android::BAD_VALUE; } ::android::status_t ITrunkStableTest::MyUnion::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(getTag())); if (_aidl_ret_status != ::android::OK) return _aidl_ret_status; switch (getTag()) { case a: return _aidl_parcel->writeInt32(get()); case b: return _aidl_parcel->writeInt32(get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace trunk } // namespace test } // namespace aidl } // namespace android #include #include namespace android { namespace aidl { namespace test { namespace trunk { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_NESTED_INTERFACE(ITrunkStableTest, MyCallback, "android.aidl.test.trunk.ITrunkStableTest.IMyCallback") } // namespace trunk } // namespace test } // namespace aidl } // namespace android #include #include #include #include #include namespace android { namespace aidl { namespace test { namespace trunk { ITrunkStableTest::BpMyCallback::BpMyCallback(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } std::function ITrunkStableTest::BpMyCallback::logFunc; ::android::binder::Status ITrunkStableTest::BpMyCallback::repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyCallback::repeatParcelable::cppClient"); ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("input", ::android::internal::ToString(input)); } auto _log_start = std::chrono::steady_clock::now(); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(ITrunkStableTest::BnMyCallback::TRANSACTION_repeatParcelable, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) [[unlikely]] { return IMyCallback::getDefaultImpl()->repeatParcelable(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatParcelable"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } ::android::binder::Status ITrunkStableTest::BpMyCallback::repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum input, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyCallback::repeatEnum::cppClient"); ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("input", ::android::internal::ToString(input)); } auto _log_start = std::chrono::steady_clock::now(); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeByte(static_cast(input)); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(ITrunkStableTest::BnMyCallback::TRANSACTION_repeatEnum, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) [[unlikely]] { return IMyCallback::getDefaultImpl()->repeatEnum(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readByte(reinterpret_cast(_aidl_return)); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatEnum"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } ::android::binder::Status ITrunkStableTest::BpMyCallback::repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& input, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyCallback::repeatUnion::cppClient"); ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("input", ::android::internal::ToString(input)); } auto _log_start = std::chrono::steady_clock::now(); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(ITrunkStableTest::BnMyCallback::TRANSACTION_repeatUnion, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) [[unlikely]] { return IMyCallback::getDefaultImpl()->repeatUnion(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatUnion"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } int32_t ITrunkStableTest::BpMyCallback::getInterfaceVersion() { if (cached_version_ == -1) { ::android::Parcel data; ::android::Parcel reply; data.writeInterfaceToken(getInterfaceDescriptor()); ::android::status_t err = remote()->transact(ITrunkStableTest::BnMyCallback::TRANSACTION_getInterfaceVersion, data, &reply); if (err == ::android::OK) { ::android::binder::Status _aidl_status; err = _aidl_status.readFromParcel(reply); if (err == ::android::OK && _aidl_status.isOk()) { cached_version_ = reply.readInt32(); } } } return cached_version_; } std::string ITrunkStableTest::BpMyCallback::getInterfaceHash() { std::lock_guard lockGuard(cached_hash_mutex_); if (cached_hash_ == "-1") { ::android::Parcel data; ::android::Parcel reply; data.writeInterfaceToken(getInterfaceDescriptor()); ::android::status_t err = remote()->transact(ITrunkStableTest::BnMyCallback::TRANSACTION_getInterfaceHash, data, &reply); if (err == ::android::OK) { ::android::binder::Status _aidl_status; err = _aidl_status.readFromParcel(reply); if (err == ::android::OK && _aidl_status.isOk()) { reply.readUtf8FromUtf16(&cached_hash_); } } } return cached_hash_; } } // namespace trunk } // namespace test } // namespace aidl } // namespace android #include #include #include #include #include namespace android { namespace aidl { namespace test { namespace trunk { ITrunkStableTest::BnMyCallback::BnMyCallback() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t ITrunkStableTest::BnMyCallback::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnMyCallback::TRANSACTION_repeatParcelable: { ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable in_input; ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyCallback::repeatParcelable::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(repeatParcelable(in_input, &_aidl_return)); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatParcelable"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnMyCallback::TRANSACTION_repeatEnum: { ::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input; ::android::aidl::test::trunk::ITrunkStableTest::MyEnum _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyCallback::repeatEnum::cppServer"); _aidl_ret_status = _aidl_data.readByte(reinterpret_cast(&in_input)); if (((_aidl_ret_status) != (::android::OK))) { break; } ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(repeatEnum(in_input, &_aidl_return)); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatEnum"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeByte(static_cast(_aidl_return)); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnMyCallback::TRANSACTION_repeatUnion: { ::android::aidl::test::trunk::ITrunkStableTest::MyUnion in_input; ::android::aidl::test::trunk::ITrunkStableTest::MyUnion _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyCallback::repeatUnion::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(repeatUnion(in_input, &_aidl_return)); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatUnion"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnMyCallback::TRANSACTION_getInterfaceVersion: { _aidl_data.checkInterface(this); _aidl_reply->writeNoException(); _aidl_reply->writeInt32(IMyCallback::VERSION); } break; case BnMyCallback::TRANSACTION_getInterfaceHash: { _aidl_data.checkInterface(this); _aidl_reply->writeNoException(); _aidl_reply->writeUtf8AsUtf16(IMyCallback::HASH); } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } int32_t ITrunkStableTest::BnMyCallback::getInterfaceVersion() { return IMyCallback::VERSION; } std::string ITrunkStableTest::BnMyCallback::getInterfaceHash() { return IMyCallback::HASH; } std::function ITrunkStableTest::BnMyCallback::logFunc; } // namespace trunk } // namespace test } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-cpp-so0100644 0000000 0000000 00000000261 15172120304 033167 xustar000000000 0000000 149 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/android/aidl/test/trunk/ITrunkStableTest.cpp.d 28 mtime=1776853188.7150000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/android0100644 0000000 0000000 00000000433 15172120304 033161 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/android/aidl/test/trunk/ITrunkStableTest.cpp : \ system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/android/aidl/test/trunk/ITrunkStableTest.aidl ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-cpp-so0100644 0000000 0000000 00000000213 15172120304 033164 xustar000000000 0000000 111 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include/ 28 mtime=1776853188.7160000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include0040755 0000000 0000000 00000000000 15172120304 033165 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-cpp-so0100644 0000000 0000000 00000000223 15172120304 033165 xustar000000000 0000000 119 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include/android/ 28 mtime=1776853188.7160000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include0040755 0000000 0000000 00000000000 15172120304 033165 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-cpp-so0100644 0000000 0000000 00000000230 15172120304 033163 xustar000000000 0000000 124 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include/android/aidl/ 28 mtime=1776853188.7160000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include0040755 0000000 0000000 00000000000 15172120304 033165 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-cpp-so0100644 0000000 0000000 00000000235 15172120304 033170 xustar000000000 0000000 129 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include/android/aidl/test/ 28 mtime=1776853188.7160000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include0040755 0000000 0000000 00000000000 15172120304 033165 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-cpp-so0100644 0000000 0000000 00000000243 15172120304 033167 xustar000000000 0000000 135 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include/android/aidl/test/trunk/ 28 mtime=1776853188.7160000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include0040755 0000000 0000000 00000000000 15172120304 033165 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-cpp-so0100644 0000000 0000000 00000000266 15172120304 033174 xustar000000000 0000000 154 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include/android/aidl/test/trunk/BnTrunkStableTest.h 28 mtime=1776853188.7160000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include0100644 0000000 0000000 00000011175 15172120304 033171 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 1 --hash 88311b9118fb6fe9eff4a2ca19121de0587f6d5f -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/staging/android/aidl/test/trunk/ITrunkStableTest.cpp.d -h out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/staging -Nsystem/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1 system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/android/aidl/test/trunk/ITrunkStableTest.aidl */ #pragma once #include #include #include #include #include #include #include namespace android { namespace aidl { namespace test { namespace trunk { class BnTrunkStableTest : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_repeatParcelable = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_repeatEnum = ::android::IBinder::FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_repeatUnion = ::android::IBinder::FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_callMyCallback = ::android::IBinder::FIRST_CALL_TRANSACTION + 3; static constexpr uint32_t TRANSACTION_getInterfaceVersion = ::android::IBinder::FIRST_CALL_TRANSACTION + 16777214; static constexpr uint32_t TRANSACTION_getInterfaceHash = ::android::IBinder::FIRST_CALL_TRANSACTION + 16777213; explicit BnTrunkStableTest(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; int32_t getInterfaceVersion(); std::string getInterfaceHash(); struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; }; // class BnTrunkStableTest class ITrunkStableTestDelegator : public BnTrunkStableTest { public: explicit ITrunkStableTestDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override { return _aidl_delegate->repeatParcelable(input, _aidl_return); } ::android::binder::Status repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum input, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override { return _aidl_delegate->repeatEnum(input, _aidl_return); } ::android::binder::Status repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& input, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override { return _aidl_delegate->repeatUnion(input, _aidl_return); } ::android::binder::Status callMyCallback(const ::android::sp<::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& cb) override { ::android::sp<::android::aidl::test::trunk::ITrunkStableTest::IMyCallbackDelegator> _cb; if (cb) { _cb = ::android::sp<::android::aidl::test::trunk::ITrunkStableTest::IMyCallbackDelegator>::cast(delegate(cb)); } return _aidl_delegate->callMyCallback(_cb); } int32_t getInterfaceVersion() override { int32_t _delegator_ver = BnTrunkStableTest::getInterfaceVersion(); int32_t _impl_ver = _aidl_delegate->getInterfaceVersion(); return _delegator_ver < _impl_ver ? _delegator_ver : _impl_ver; } std::string getInterfaceHash() override { return _aidl_delegate->getInterfaceHash(); } private: ::android::sp _aidl_delegate; }; // class ITrunkStableTestDelegator } // namespace trunk } // namespace test } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-cpp-so0100644 0000000 0000000 00000000266 15172120304 033174 xustar000000000 0000000 154 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include/android/aidl/test/trunk/BpTrunkStableTest.h 28 mtime=1776853188.7170000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include0100644 0000000 0000000 00000005512 15172120304 033167 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 1 --hash 88311b9118fb6fe9eff4a2ca19121de0587f6d5f -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/staging/android/aidl/test/trunk/ITrunkStableTest.cpp.d -h out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/staging -Nsystem/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1 system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/android/aidl/test/trunk/ITrunkStableTest.aidl */ #pragma once #include #include #include #include #include #include namespace android { namespace aidl { namespace test { namespace trunk { class BpTrunkStableTest : public ::android::BpInterface { public: explicit BpTrunkStableTest(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpTrunkStableTest() = default; ::android::binder::Status repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override; ::android::binder::Status repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum input, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override; ::android::binder::Status repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& input, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override; ::android::binder::Status callMyCallback(const ::android::sp<::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& cb) override; int32_t getInterfaceVersion() override; std::string getInterfaceHash() override; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; private: int32_t cached_version_ = -1; std::string cached_hash_ = "-1"; std::mutex cached_hash_mutex_; }; // class BpTrunkStableTest } // namespace trunk } // namespace test } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-cpp-so0100644 0000000 0000000 00000000265 15172120304 033173 xustar000000000 0000000 153 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include/android/aidl/test/trunk/ITrunkStableTest.h 28 mtime=1776853188.7170000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include0100644 0000000 0000000 00000042605 15172120304 033173 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 1 --hash 88311b9118fb6fe9eff4a2ca19121de0587f6d5f -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/staging/android/aidl/test/trunk/ITrunkStableTest.cpp.d -h out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/staging -Nsystem/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1 system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/android/aidl/test/trunk/ITrunkStableTest.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace android { namespace aidl { namespace test { namespace trunk { class ITrunkStableTestDelegator; class ITrunkStableTest : public ::android::IInterface { public: typedef ITrunkStableTestDelegator DefaultDelegator; DECLARE_META_INTERFACE(TrunkStableTest) static inline const int32_t VERSION = 1; static inline const std::string HASH = "88311b9118fb6fe9eff4a2ca19121de0587f6d5f"; class MyParcelable : public ::android::Parcelable { public: int32_t a = 0; int32_t b = 0; inline bool operator==(const MyParcelable& _rhs) const { return std::tie(a, b) == std::tie(_rhs.a, _rhs.b); } inline bool operator<(const MyParcelable& _rhs) const { return std::tie(a, b) < std::tie(_rhs.a, _rhs.b); } inline bool operator!=(const MyParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyParcelable& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.test.trunk.ITrunkStableTest.MyParcelable"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "MyParcelable{"; _aidl_os << "a: " << ::android::internal::ToString(a); _aidl_os << ", b: " << ::android::internal::ToString(b); _aidl_os << "}"; return _aidl_os.str(); } }; // class MyParcelable enum class MyEnum : int8_t { ZERO = 0, ONE = 1, TWO = 2, }; class MyUnion : public ::android::Parcelable { public: enum class Tag : int32_t { a = 0, b = 1, }; // Expose tag symbols for legacy code static const inline Tag a = Tag::a; static const inline Tag b = Tag::b; template static constexpr bool _not_self = !std::is_same_v>, MyUnion>; MyUnion() : _value(std::in_place_index(a)>, int32_t(0)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr MyUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit MyUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static MyUnion make(_Tp&&... _args) { return MyUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static MyUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return MyUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } inline bool operator==(const MyUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const MyUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const MyUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyUnion& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.test.trunk.ITrunkStableTest.MyUnion"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream os; os << "MyUnion{"; switch (getTag()) { case a: os << "a: " << ::android::internal::ToString(get()); break; case b: os << "b: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant _value; }; // class MyUnion class IMyCallbackDelegator; class IMyCallback : public ::android::IInterface { public: typedef IMyCallbackDelegator DefaultDelegator; DECLARE_META_INTERFACE(MyCallback) static inline const int32_t VERSION = 1; static inline const std::string HASH = "88311b9118fb6fe9eff4a2ca19121de0587f6d5f"; virtual ::android::binder::Status repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) = 0; virtual ::android::binder::Status repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum input, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) = 0; virtual ::android::binder::Status repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& input, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) = 0; virtual int32_t getInterfaceVersion() = 0; virtual std::string getInterfaceHash() = 0; }; // class IMyCallback class IMyCallbackDefault : public IMyCallback { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& /*input*/, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum /*input*/, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& /*input*/, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } int32_t getInterfaceVersion() override { return 0; } std::string getInterfaceHash() override { return ""; } }; // class IMyCallbackDefault class BpMyCallback : public ::android::BpInterface { public: explicit BpMyCallback(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpMyCallback() = default; ::android::binder::Status repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override; ::android::binder::Status repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum input, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override; ::android::binder::Status repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& input, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override; int32_t getInterfaceVersion() override; std::string getInterfaceHash() override; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; private: int32_t cached_version_ = -1; std::string cached_hash_ = "-1"; std::mutex cached_hash_mutex_; }; // class BpMyCallback class BnMyCallback : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_repeatParcelable = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_repeatEnum = ::android::IBinder::FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_repeatUnion = ::android::IBinder::FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_getInterfaceVersion = ::android::IBinder::FIRST_CALL_TRANSACTION + 16777214; static constexpr uint32_t TRANSACTION_getInterfaceHash = ::android::IBinder::FIRST_CALL_TRANSACTION + 16777213; explicit BnMyCallback(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; int32_t getInterfaceVersion(); std::string getInterfaceHash(); struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; }; // class BnMyCallback class IMyCallbackDelegator : public BnMyCallback { public: explicit IMyCallbackDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override { return _aidl_delegate->repeatParcelable(input, _aidl_return); } ::android::binder::Status repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum input, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override { return _aidl_delegate->repeatEnum(input, _aidl_return); } ::android::binder::Status repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& input, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override { return _aidl_delegate->repeatUnion(input, _aidl_return); } int32_t getInterfaceVersion() override { int32_t _delegator_ver = BnMyCallback::getInterfaceVersion(); int32_t _impl_ver = _aidl_delegate->getInterfaceVersion(); return _delegator_ver < _impl_ver ? _delegator_ver : _impl_ver; } std::string getInterfaceHash() override { return _aidl_delegate->getInterfaceHash(); } private: ::android::sp _aidl_delegate; }; // class IMyCallbackDelegator virtual ::android::binder::Status repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) = 0; virtual ::android::binder::Status repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum input, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) = 0; virtual ::android::binder::Status repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& input, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) = 0; virtual ::android::binder::Status callMyCallback(const ::android::sp<::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& cb) = 0; virtual int32_t getInterfaceVersion() = 0; virtual std::string getInterfaceHash() = 0; }; // class ITrunkStableTest class ITrunkStableTestDefault : public ITrunkStableTest { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& /*input*/, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum /*input*/, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& /*input*/, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status callMyCallback(const ::android::sp<::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& /*cb*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } int32_t getInterfaceVersion() override { return 0; } std::string getInterfaceHash() override { return ""; } }; // class ITrunkStableTestDefault } // namespace trunk } // namespace test } // namespace aidl } // namespace android namespace android { namespace aidl { namespace test { namespace trunk { [[nodiscard]] static inline std::string toString(ITrunkStableTest::MyEnum val) { switch(val) { case ITrunkStableTest::MyEnum::ZERO: return "ZERO"; case ITrunkStableTest::MyEnum::ONE: return "ONE"; case ITrunkStableTest::MyEnum::TWO: return "TWO"; default: return std::to_string(static_cast(val)); } } } // namespace trunk } // namespace test } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::test::trunk::ITrunkStableTest::MyEnum, 3> enum_values<::android::aidl::test::trunk::ITrunkStableTest::MyEnum> = { ::android::aidl::test::trunk::ITrunkStableTest::MyEnum::ZERO, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum::ONE, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum::TWO, }; #pragma clang diagnostic pop } // namespace internal } // namespace android namespace android { namespace aidl { namespace test { namespace trunk { [[nodiscard]] static inline std::string toString(ITrunkStableTest::MyUnion::Tag val) { switch(val) { case ITrunkStableTest::MyUnion::Tag::a: return "a"; case ITrunkStableTest::MyUnion::Tag::b: return "b"; default: return std::to_string(static_cast(val)); } } } // namespace trunk } // namespace test } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::test::trunk::ITrunkStableTest::MyUnion::Tag, 2> enum_values<::android::aidl::test::trunk::ITrunkStableTest::MyUnion::Tag> = { ::android::aidl::test::trunk::ITrunkStableTest::MyUnion::Tag::a, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion::Tag::b, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-cpp-so0100644 0000000 0000000 00000000214 15172120304 033165 xustar000000000 0000000 112 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/timestamp 28 mtime=1776853188.7180000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/timesta0100644 0000000 0000000 00000000000 15172120304 033175 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-java-s0100644 0000000 0000000 00000000034 15172120304 033145 xustar000000000 0000000 28 mtime=1776853188.7180000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/0040755 0000000 0000000 00000000000 15172120304 031207 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-java-s0100644 0000000 0000000 00000000034 15172120304 033145 xustar000000000 0000000 28 mtime=1776853188.7180000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/gen/0040755 0000000 0000000 00000000000 15172120304 031760 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-java-s0100644 0000000 0000000 00000000214 15172120304 033145 xustar000000000 0000000 112 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/gen/android/ 28 mtime=1776853188.7180000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/gen/androi0040755 0000000 0000000 00000000000 15172120304 033155 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-java-s0100644 0000000 0000000 00000000221 15172120304 033143 xustar000000000 0000000 117 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/gen/android/aidl/ 28 mtime=1776853188.7180000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/gen/androi0040755 0000000 0000000 00000000000 15172120304 033155 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-java-s0100644 0000000 0000000 00000000226 15172120304 033150 xustar000000000 0000000 122 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/gen/android/aidl/test/ 28 mtime=1776853188.7180000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/gen/androi0040755 0000000 0000000 00000000000 15172120304 033155 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-java-s0100644 0000000 0000000 00000000234 15172120304 033147 xustar000000000 0000000 128 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/gen/android/aidl/test/trunk/ 28 mtime=1776853188.7180000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/gen/androi0040755 0000000 0000000 00000000000 15172120304 033155 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-java-s0100644 0000000 0000000 00000000261 15172120304 033147 xustar000000000 0000000 149 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/gen/android/aidl/test/trunk/ITrunkStableTest.java 28 mtime=1776853188.7180000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/gen/androi0100644 0000000 0000000 00000074457 15172120304 033175 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java --structured --version 1 --hash 88311b9118fb6fe9eff4a2ca19121de0587f6d5f -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/gen/android/aidl/test/trunk/ITrunkStableTest.java.d -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/gen -Nsystem/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1 system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/android/aidl/test/trunk/ITrunkStableTest.aidl */ package android.aidl.test.trunk; public interface ITrunkStableTest extends android.os.IInterface { /** * The version of this interface that the caller is built against. * This might be different from what {@link #getInterfaceVersion() * getInterfaceVersion} returns as that is the version of the interface * that the remote object is implementing. */ public static final int VERSION = 1; public static final String HASH = "88311b9118fb6fe9eff4a2ca19121de0587f6d5f"; /** Default implementation for ITrunkStableTest. */ public static class Default implements android.aidl.test.trunk.ITrunkStableTest { @Override public android.aidl.test.trunk.ITrunkStableTest.MyParcelable repeatParcelable(android.aidl.test.trunk.ITrunkStableTest.MyParcelable input) throws android.os.RemoteException { return null; } @Override public byte repeatEnum(byte input) throws android.os.RemoteException { return 0; } @Override public android.aidl.test.trunk.ITrunkStableTest.MyUnion repeatUnion(android.aidl.test.trunk.ITrunkStableTest.MyUnion input) throws android.os.RemoteException { return null; } @Override public void callMyCallback(android.aidl.test.trunk.ITrunkStableTest.IMyCallback cb) throws android.os.RemoteException { } @Override public int getInterfaceVersion() { return 0; } @Override public String getInterfaceHash() { return ""; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.test.trunk.ITrunkStableTest { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.test.trunk.ITrunkStableTest interface, * generating a proxy if needed. */ public static android.aidl.test.trunk.ITrunkStableTest asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.test.trunk.ITrunkStableTest))) { return ((android.aidl.test.trunk.ITrunkStableTest)iin); } return new android.aidl.test.trunk.ITrunkStableTest.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_repeatParcelable: { return "repeatParcelable"; } case TRANSACTION_repeatEnum: { return "repeatEnum"; } case TRANSACTION_repeatUnion: { return "repeatUnion"; } case TRANSACTION_callMyCallback: { return "callMyCallback"; } case TRANSACTION_getInterfaceVersion: { return "getInterfaceVersion"; } case TRANSACTION_getInterfaceHash: { return "getInterfaceHash"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } else if (code == TRANSACTION_getInterfaceVersion) { reply.writeNoException(); reply.writeInt(getInterfaceVersion()); return true; } else if (code == TRANSACTION_getInterfaceHash) { reply.writeNoException(); reply.writeString(getInterfaceHash()); return true; } switch (code) { case TRANSACTION_repeatParcelable: { android.aidl.test.trunk.ITrunkStableTest.MyParcelable _arg0; _arg0 = data.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyParcelable.CREATOR); data.enforceNoDataAvail(); android.aidl.test.trunk.ITrunkStableTest.MyParcelable _result = this.repeatParcelable(_arg0); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_repeatEnum: { byte _arg0; _arg0 = data.readByte(); data.enforceNoDataAvail(); byte _result = this.repeatEnum(_arg0); reply.writeNoException(); reply.writeByte(_result); break; } case TRANSACTION_repeatUnion: { android.aidl.test.trunk.ITrunkStableTest.MyUnion _arg0; _arg0 = data.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyUnion.CREATOR); data.enforceNoDataAvail(); android.aidl.test.trunk.ITrunkStableTest.MyUnion _result = this.repeatUnion(_arg0); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_callMyCallback: { android.aidl.test.trunk.ITrunkStableTest.IMyCallback _arg0; _arg0 = android.aidl.test.trunk.ITrunkStableTest.IMyCallback.Stub.asInterface(data.readStrongBinder()); data.enforceNoDataAvail(); this.callMyCallback(_arg0); reply.writeNoException(); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.test.trunk.ITrunkStableTest { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } private int mCachedVersion = -1; private String mCachedHash = "-1"; @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public android.aidl.test.trunk.ITrunkStableTest.MyParcelable repeatParcelable(android.aidl.test.trunk.ITrunkStableTest.MyParcelable input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.test.trunk.ITrunkStableTest.MyParcelable _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_repeatParcelable, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method repeatParcelable is unimplemented."); } _reply.readException(); _result = _reply.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyParcelable.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public byte repeatEnum(byte input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); byte _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeByte(input); boolean _status = mRemote.transact(Stub.TRANSACTION_repeatEnum, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method repeatEnum is unimplemented."); } _reply.readException(); _result = _reply.readByte(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.test.trunk.ITrunkStableTest.MyUnion repeatUnion(android.aidl.test.trunk.ITrunkStableTest.MyUnion input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.test.trunk.ITrunkStableTest.MyUnion _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_repeatUnion, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method repeatUnion is unimplemented."); } _reply.readException(); _result = _reply.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyUnion.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public void callMyCallback(android.aidl.test.trunk.ITrunkStableTest.IMyCallback cb) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeStrongInterface(cb); boolean _status = mRemote.transact(Stub.TRANSACTION_callMyCallback, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method callMyCallback is unimplemented."); } _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } @Override public int getInterfaceVersion() throws android.os.RemoteException { if (mCachedVersion == -1) { android.os.Parcel data = android.os.Parcel.obtain(asBinder()); android.os.Parcel reply = android.os.Parcel.obtain(); try { data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getInterfaceVersion, data, reply, 0); reply.readException(); mCachedVersion = reply.readInt(); } finally { reply.recycle(); data.recycle(); } } return mCachedVersion; } @Override public synchronized String getInterfaceHash() throws android.os.RemoteException { if ("-1".equals(mCachedHash)) { android.os.Parcel data = android.os.Parcel.obtain(asBinder()); android.os.Parcel reply = android.os.Parcel.obtain(); try { data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getInterfaceHash, data, reply, 0); reply.readException(); mCachedHash = reply.readString(); } finally { reply.recycle(); data.recycle(); } } return mCachedHash; } } static final int TRANSACTION_repeatParcelable = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); static final int TRANSACTION_repeatEnum = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1); static final int TRANSACTION_repeatUnion = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2); static final int TRANSACTION_callMyCallback = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3); static final int TRANSACTION_getInterfaceVersion = (android.os.IBinder.FIRST_CALL_TRANSACTION + 16777214); static final int TRANSACTION_getInterfaceHash = (android.os.IBinder.FIRST_CALL_TRANSACTION + 16777213); /** @hide */ public int getMaxTransactionId() { return 16777214; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android$aidl$test$trunk$ITrunkStableTest".replace('$', '.'); public android.aidl.test.trunk.ITrunkStableTest.MyParcelable repeatParcelable(android.aidl.test.trunk.ITrunkStableTest.MyParcelable input) throws android.os.RemoteException; public byte repeatEnum(byte input) throws android.os.RemoteException; public android.aidl.test.trunk.ITrunkStableTest.MyUnion repeatUnion(android.aidl.test.trunk.ITrunkStableTest.MyUnion input) throws android.os.RemoteException; public void callMyCallback(android.aidl.test.trunk.ITrunkStableTest.IMyCallback cb) throws android.os.RemoteException; public int getInterfaceVersion() throws android.os.RemoteException; public String getInterfaceHash() throws android.os.RemoteException; public static class MyParcelable implements android.os.Parcelable { public int a = 0; public int b = 0; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public MyParcelable createFromParcel(android.os.Parcel _aidl_source) { MyParcelable _aidl_out = new MyParcelable(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public MyParcelable[] newArray(int _aidl_size) { return new MyParcelable[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(a); _aidl_parcel.writeInt(b); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; a = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; b = _aidl_parcel.readInt(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } } public static @interface MyEnum { public static final byte ZERO = 0; public static final byte ONE = 1; public static final byte TWO = 2; } public static final class MyUnion implements android.os.Parcelable { // tags for union fields public final static int a = 0; // int a; public final static int b = 1; // int b; private int _tag; private Object _value; public MyUnion() { int _value = 0; this._tag = a; this._value = _value; } private MyUnion(android.os.Parcel _aidl_parcel) { readFromParcel(_aidl_parcel); } private MyUnion(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public int getTag() { return _tag; } // int a; public static MyUnion a(int _value) { return new MyUnion(a, _value); } public int getA() { _assertTag(a); return (int) _value; } public void setA(int _value) { _set(a, _value); } // int b; public static MyUnion b(int _value) { return new MyUnion(b, _value); } public int getB() { _assertTag(b); return (int) _value; } public void setB(int _value) { _set(b, _value); } public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public MyUnion createFromParcel(android.os.Parcel _aidl_source) { return new MyUnion(_aidl_source); } @Override public MyUnion[] newArray(int _aidl_size) { return new MyUnion[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { _aidl_parcel.writeInt(_tag); switch (_tag) { case a: _aidl_parcel.writeInt(getA()); break; case b: _aidl_parcel.writeInt(getB()); break; } } public void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_tag; _aidl_tag = _aidl_parcel.readInt(); switch (_aidl_tag) { case a: { int _aidl_value; _aidl_value = _aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } case b: { int _aidl_value; _aidl_value = _aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } } throw new IllegalArgumentException("union: unknown tag: " + _aidl_tag); } @Override public int describeContents() { int _mask = 0; switch (getTag()) { } return _mask; } private void _assertTag(int tag) { if (getTag() != tag) { throw new IllegalStateException("bad access: " + _tagString(tag) + ", " + _tagString(getTag()) + " is available."); } } private String _tagString(int _tag) { switch (_tag) { case a: return "a"; case b: return "b"; } throw new IllegalStateException("unknown field: " + _tag); } private void _set(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public static @interface Tag { public static final int a = 0; public static final int b = 1; } } public interface IMyCallback extends android.os.IInterface { /** * The version of this interface that the caller is built against. * This might be different from what {@link #getInterfaceVersion() * getInterfaceVersion} returns as that is the version of the interface * that the remote object is implementing. */ public static final int VERSION = 1; public static final String HASH = "88311b9118fb6fe9eff4a2ca19121de0587f6d5f"; /** Default implementation for IMyCallback. */ public static class Default implements android.aidl.test.trunk.ITrunkStableTest.IMyCallback { @Override public android.aidl.test.trunk.ITrunkStableTest.MyParcelable repeatParcelable(android.aidl.test.trunk.ITrunkStableTest.MyParcelable input) throws android.os.RemoteException { return null; } @Override public byte repeatEnum(byte input) throws android.os.RemoteException { return 0; } @Override public android.aidl.test.trunk.ITrunkStableTest.MyUnion repeatUnion(android.aidl.test.trunk.ITrunkStableTest.MyUnion input) throws android.os.RemoteException { return null; } @Override public int getInterfaceVersion() { return 0; } @Override public String getInterfaceHash() { return ""; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.test.trunk.ITrunkStableTest.IMyCallback { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.test.trunk.ITrunkStableTest.IMyCallback interface, * generating a proxy if needed. */ public static android.aidl.test.trunk.ITrunkStableTest.IMyCallback asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.test.trunk.ITrunkStableTest.IMyCallback))) { return ((android.aidl.test.trunk.ITrunkStableTest.IMyCallback)iin); } return new android.aidl.test.trunk.ITrunkStableTest.IMyCallback.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_repeatParcelable: { return "repeatParcelable"; } case TRANSACTION_repeatEnum: { return "repeatEnum"; } case TRANSACTION_repeatUnion: { return "repeatUnion"; } case TRANSACTION_getInterfaceVersion: { return "getInterfaceVersion"; } case TRANSACTION_getInterfaceHash: { return "getInterfaceHash"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } else if (code == TRANSACTION_getInterfaceVersion) { reply.writeNoException(); reply.writeInt(getInterfaceVersion()); return true; } else if (code == TRANSACTION_getInterfaceHash) { reply.writeNoException(); reply.writeString(getInterfaceHash()); return true; } switch (code) { case TRANSACTION_repeatParcelable: { android.aidl.test.trunk.ITrunkStableTest.MyParcelable _arg0; _arg0 = data.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyParcelable.CREATOR); data.enforceNoDataAvail(); android.aidl.test.trunk.ITrunkStableTest.MyParcelable _result = this.repeatParcelable(_arg0); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_repeatEnum: { byte _arg0; _arg0 = data.readByte(); data.enforceNoDataAvail(); byte _result = this.repeatEnum(_arg0); reply.writeNoException(); reply.writeByte(_result); break; } case TRANSACTION_repeatUnion: { android.aidl.test.trunk.ITrunkStableTest.MyUnion _arg0; _arg0 = data.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyUnion.CREATOR); data.enforceNoDataAvail(); android.aidl.test.trunk.ITrunkStableTest.MyUnion _result = this.repeatUnion(_arg0); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.test.trunk.ITrunkStableTest.IMyCallback { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } private int mCachedVersion = -1; private String mCachedHash = "-1"; @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public android.aidl.test.trunk.ITrunkStableTest.MyParcelable repeatParcelable(android.aidl.test.trunk.ITrunkStableTest.MyParcelable input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.test.trunk.ITrunkStableTest.MyParcelable _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_repeatParcelable, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method repeatParcelable is unimplemented."); } _reply.readException(); _result = _reply.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyParcelable.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public byte repeatEnum(byte input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); byte _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeByte(input); boolean _status = mRemote.transact(Stub.TRANSACTION_repeatEnum, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method repeatEnum is unimplemented."); } _reply.readException(); _result = _reply.readByte(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.test.trunk.ITrunkStableTest.MyUnion repeatUnion(android.aidl.test.trunk.ITrunkStableTest.MyUnion input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.test.trunk.ITrunkStableTest.MyUnion _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_repeatUnion, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method repeatUnion is unimplemented."); } _reply.readException(); _result = _reply.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyUnion.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int getInterfaceVersion() throws android.os.RemoteException { if (mCachedVersion == -1) { android.os.Parcel data = android.os.Parcel.obtain(asBinder()); android.os.Parcel reply = android.os.Parcel.obtain(); try { data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getInterfaceVersion, data, reply, 0); reply.readException(); mCachedVersion = reply.readInt(); } finally { reply.recycle(); data.recycle(); } } return mCachedVersion; } @Override public synchronized String getInterfaceHash() throws android.os.RemoteException { if ("-1".equals(mCachedHash)) { android.os.Parcel data = android.os.Parcel.obtain(asBinder()); android.os.Parcel reply = android.os.Parcel.obtain(); try { data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getInterfaceHash, data, reply, 0); reply.readException(); mCachedHash = reply.readString(); } finally { reply.recycle(); data.recycle(); } } return mCachedHash; } } static final int TRANSACTION_repeatParcelable = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); static final int TRANSACTION_repeatEnum = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1); static final int TRANSACTION_repeatUnion = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2); static final int TRANSACTION_getInterfaceVersion = (android.os.IBinder.FIRST_CALL_TRANSACTION + 16777214); static final int TRANSACTION_getInterfaceHash = (android.os.IBinder.FIRST_CALL_TRANSACTION + 16777213); /** @hide */ public int getMaxTransactionId() { return 16777214; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android$aidl$test$trunk$ITrunkStableTest$IMyCallback".replace('$', '.'); public android.aidl.test.trunk.ITrunkStableTest.MyParcelable repeatParcelable(android.aidl.test.trunk.ITrunkStableTest.MyParcelable input) throws android.os.RemoteException; public byte repeatEnum(byte input) throws android.os.RemoteException; public android.aidl.test.trunk.ITrunkStableTest.MyUnion repeatUnion(android.aidl.test.trunk.ITrunkStableTest.MyUnion input) throws android.os.RemoteException; public int getInterfaceVersion() throws android.os.RemoteException; public String getInterfaceHash() throws android.os.RemoteException; } } ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-java-s0100644 0000000 0000000 00000000263 15172120304 033151 xustar000000000 0000000 151 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/gen/android/aidl/test/trunk/ITrunkStableTest.java.d 28 mtime=1776853188.7190000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/gen/androi0100644 0000000 0000000 00000000435 15172120304 033156 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/gen/android/aidl/test/trunk/ITrunkStableTest.java : \ system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/android/aidl/test/trunk/ITrunkStableTest.aidl ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-java-s0100644 0000000 0000000 00000000215 15172120304 033146 xustar000000000 0000000 113 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/gen/timestamp 28 mtime=1776853188.7190000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/gen/timest0100644 0000000 0000000 00000000000 15172120304 033173 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-so0100644 0000000 0000000 00000000034 15172120304 033157 xustar000000000 0000000 28 mtime=1776853188.7190000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/0040755 0000000 0000000 00000000000 15172120304 031042 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-so0100644 0000000 0000000 00000000034 15172120304 033157 xustar000000000 0000000 28 mtime=1776853188.7190000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/0040755 0000000 0000000 00000000000 15172120304 031613 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-so0100644 0000000 0000000 00000000213 15172120304 033156 xustar000000000 0000000 111 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/android/ 28 mtime=1776853188.7200000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/android0040755 0000000 0000000 00000000000 15172120304 033154 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-so0100644 0000000 0000000 00000000220 15172120304 033154 xustar000000000 0000000 116 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/android/aidl/ 28 mtime=1776853188.7200000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/android0040755 0000000 0000000 00000000000 15172120304 033154 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-so0100644 0000000 0000000 00000000225 15172120304 033161 xustar000000000 0000000 121 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/android/aidl/test/ 28 mtime=1776853188.7200000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/android0040755 0000000 0000000 00000000000 15172120304 033154 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-so0100644 0000000 0000000 00000000233 15172120304 033160 xustar000000000 0000000 127 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/android/aidl/test/trunk/ 28 mtime=1776853188.7200000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/android0040755 0000000 0000000 00000000000 15172120304 033154 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-so0100644 0000000 0000000 00000000257 15172120304 033166 xustar000000000 0000000 147 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/android/aidl/test/trunk/ITrunkStableTest.cpp 28 mtime=1776853188.7200000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/android0100644 0000000 0000000 00000213127 15172120304 033161 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 1 --hash 88311b9118fb6fe9eff4a2ca19121de0587f6d5f -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/staging/android/aidl/test/trunk/ITrunkStableTest.cpp.d -h out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/staging -Nsystem/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1 system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/android/aidl/test/trunk/ITrunkStableTest.aidl */ #include "aidl/android/aidl/test/trunk/ITrunkStableTest.h" #include #include #include #include namespace { struct ScopedTrace { inline explicit ScopedTrace(const char* name) { ATrace_beginSection(name); } inline ~ScopedTrace() { ATrace_endSection(); } }; } // namespace namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { static binder_status_t _aidl_android_aidl_test_trunk_ITrunkStableTest_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*repeatParcelable*/): { ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable in_input; ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::repeatParcelable::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->repeatParcelable(in_input, &_aidl_return); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatParcelable"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 1 /*repeatEnum*/): { ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input; ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::repeatEnum::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->repeatEnum(in_input, &_aidl_return); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatEnum"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 2 /*repeatUnion*/): { ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion in_input; ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::repeatUnion::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->repeatUnion(in_input, &_aidl_return); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatUnion"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 3 /*callMyCallback*/): { std::shared_ptr<::aidl::android::aidl::test::trunk::ITrunkStableTest::IMyCallback> in_cb; ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::callMyCallback::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_cb); if (_aidl_ret_status != STATUS_OK) break; BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_cb", ::android::internal::ToString(in_cb)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->callMyCallback(in_cb); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "callMyCallback"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } case (FIRST_CALL_TRANSACTION + 16777214 /*getInterfaceVersion*/): { int32_t _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::getInterfaceVersion::server"); BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->getInterfaceVersion(&_aidl_return); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "getInterfaceVersion"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 16777213 /*getInterfaceHash*/): { std::string _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::getInterfaceHash::server"); BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->getInterfaceHash(&_aidl_return); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "getInterfaceHash"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_test_trunk_ITrunkStableTest_clazz = ::ndk::ICInterface::defineClass(ITrunkStableTest::descriptor, _aidl_android_aidl_test_trunk_ITrunkStableTest_onTransact); BpTrunkStableTest::BpTrunkStableTest(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} BpTrunkStableTest::~BpTrunkStableTest() {} std::function BpTrunkStableTest::logFunc; ::ndk::ScopedAStatus BpTrunkStableTest::repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::repeatParcelable::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*repeatParcelable*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) { _aidl_status = ITrunkStableTest::getDefaultImpl()->repeatParcelable(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatParcelable"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus BpTrunkStableTest::repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::repeatEnum::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 1 /*repeatEnum*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) { _aidl_status = ITrunkStableTest::getDefaultImpl()->repeatEnum(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatEnum"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus BpTrunkStableTest::repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::repeatUnion::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 2 /*repeatUnion*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) { _aidl_status = ITrunkStableTest::getDefaultImpl()->repeatUnion(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatUnion"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus BpTrunkStableTest::callMyCallback(const std::shared_ptr<::aidl::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& in_cb) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_cb", ::android::internal::ToString(in_cb)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::callMyCallback::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_cb); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 3 /*callMyCallback*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) { _aidl_status = ITrunkStableTest::getDefaultImpl()->callMyCallback(in_cb); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "callMyCallback"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus BpTrunkStableTest::getInterfaceVersion(int32_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; if (_aidl_cached_version != -1) { *_aidl_return = _aidl_cached_version; _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); return _aidl_status; } ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::getInterfaceVersion::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 16777214 /*getInterfaceVersion*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) { _aidl_status = ITrunkStableTest::getDefaultImpl()->getInterfaceVersion(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_cached_version = *_aidl_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "getInterfaceVersion"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus BpTrunkStableTest::getInterfaceHash(std::string* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; const std::lock_guard lock(_aidl_cached_hash_mutex); if (_aidl_cached_hash != "-1") { *_aidl_return = _aidl_cached_hash; _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); return _aidl_status; } ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::getInterfaceHash::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 16777213 /*getInterfaceHash*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) { _aidl_status = ITrunkStableTest::getDefaultImpl()->getInterfaceHash(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_cached_hash = *_aidl_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "getInterfaceHash"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } // Source for BnTrunkStableTest BnTrunkStableTest::BnTrunkStableTest() {} BnTrunkStableTest::~BnTrunkStableTest() {} std::function BnTrunkStableTest::logFunc; ::ndk::SpAIBinder BnTrunkStableTest::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_test_trunk_ITrunkStableTest_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } ::ndk::ScopedAStatus BnTrunkStableTest::getInterfaceVersion(int32_t* _aidl_return) { *_aidl_return = ITrunkStableTest::version; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::ScopedAStatus BnTrunkStableTest::getInterfaceHash(std::string* _aidl_return) { *_aidl_return = ITrunkStableTest::hash; return ::ndk::ScopedAStatus(AStatus_newOk()); } // Source for ITrunkStableTest const char* ITrunkStableTest::descriptor = "android.aidl.test.trunk.ITrunkStableTest"; ITrunkStableTest::ITrunkStableTest() {} ITrunkStableTest::~ITrunkStableTest() {} std::shared_ptr ITrunkStableTest::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_test_trunk_ITrunkStableTest_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t ITrunkStableTest::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t ITrunkStableTest::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = ITrunkStableTest::fromBinder(binder); return STATUS_OK; } bool ITrunkStableTest::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!ITrunkStableTest::default_impl); if (impl) { ITrunkStableTest::default_impl = impl; return true; } return false; } const std::shared_ptr& ITrunkStableTest::getDefaultImpl() { return ITrunkStableTest::default_impl; } std::shared_ptr ITrunkStableTest::default_impl = nullptr; ::ndk::ScopedAStatus ITrunkStableTestDefault::repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& /*in_input*/, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTestDefault::repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum /*in_input*/, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTestDefault::repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& /*in_input*/, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTestDefault::callMyCallback(const std::shared_ptr<::aidl::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& /*in_cb*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTestDefault::getInterfaceVersion(int32_t* _aidl_return) { *_aidl_return = 0; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::ScopedAStatus ITrunkStableTestDefault::getInterfaceHash(std::string* _aidl_return) { *_aidl_return = ""; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::SpAIBinder ITrunkStableTestDefault::asBinder() { return ::ndk::SpAIBinder(); } bool ITrunkStableTestDefault::isRemote() { return false; } } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { const char* ITrunkStableTest::MyParcelable::descriptor = "android.aidl.test.trunk.ITrunkStableTest.MyParcelable"; binder_status_t ITrunkStableTest::MyParcelable::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &a); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &b); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t ITrunkStableTest::MyParcelable::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, a); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, b); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { const char* ITrunkStableTest::MyUnion::descriptor = "android.aidl.test.trunk.ITrunkStableTest.MyUnion"; binder_status_t ITrunkStableTest::MyUnion::readFromParcel(const AParcel* _parcel) { binder_status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_tag)) != STATUS_OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case a: { int32_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case b: { int32_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } } return STATUS_BAD_VALUE; } binder_status_t ITrunkStableTest::MyUnion::writeToParcel(AParcel* _parcel) const { binder_status_t _aidl_ret_status = ::ndk::AParcel_writeData(_parcel, static_cast(getTag())); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; switch (getTag()) { case a: return ::ndk::AParcel_writeData(_parcel, get()); case b: return ::ndk::AParcel_writeData(_parcel, get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { static binder_status_t _aidl_android_aidl_test_trunk_ITrunkStableTest_IMyCallback_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*repeatParcelable*/): { ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable in_input; ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::repeatParcelable::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->repeatParcelable(in_input, &_aidl_return); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatParcelable"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 1 /*repeatEnum*/): { ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input; ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::repeatEnum::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->repeatEnum(in_input, &_aidl_return); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatEnum"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 2 /*repeatUnion*/): { ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion in_input; ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::repeatUnion::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->repeatUnion(in_input, &_aidl_return); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatUnion"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 16777214 /*getInterfaceVersion*/): { int32_t _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::getInterfaceVersion::server"); ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->getInterfaceVersion(&_aidl_return); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "getInterfaceVersion"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 16777213 /*getInterfaceHash*/): { std::string _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::getInterfaceHash::server"); ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->getInterfaceHash(&_aidl_return); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "getInterfaceHash"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_test_trunk_ITrunkStableTest_IMyCallback_clazz = ::ndk::ICInterface::defineClass(ITrunkStableTest::IMyCallback::descriptor, _aidl_android_aidl_test_trunk_ITrunkStableTest_IMyCallback_onTransact); ITrunkStableTest::BpMyCallback::BpMyCallback(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} ITrunkStableTest::BpMyCallback::~BpMyCallback() {} std::function ITrunkStableTest::BpMyCallback::logFunc; ::ndk::ScopedAStatus ITrunkStableTest::BpMyCallback::repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::repeatParcelable::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*repeatParcelable*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) { _aidl_status = IMyCallback::getDefaultImpl()->repeatParcelable(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatParcelable"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTest::BpMyCallback::repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::repeatEnum::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 1 /*repeatEnum*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) { _aidl_status = IMyCallback::getDefaultImpl()->repeatEnum(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatEnum"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTest::BpMyCallback::repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::repeatUnion::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 2 /*repeatUnion*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) { _aidl_status = IMyCallback::getDefaultImpl()->repeatUnion(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatUnion"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTest::BpMyCallback::getInterfaceVersion(int32_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; if (_aidl_cached_version != -1) { *_aidl_return = _aidl_cached_version; _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); return _aidl_status; } ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::getInterfaceVersion::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 16777214 /*getInterfaceVersion*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) { _aidl_status = IMyCallback::getDefaultImpl()->getInterfaceVersion(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_cached_version = *_aidl_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "getInterfaceVersion"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTest::BpMyCallback::getInterfaceHash(std::string* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; const std::lock_guard lock(_aidl_cached_hash_mutex); if (_aidl_cached_hash != "-1") { *_aidl_return = _aidl_cached_hash; _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); return _aidl_status; } ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::getInterfaceHash::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 16777213 /*getInterfaceHash*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) { _aidl_status = IMyCallback::getDefaultImpl()->getInterfaceHash(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_cached_hash = *_aidl_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "getInterfaceHash"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } // Source for BnMyCallback ITrunkStableTest::BnMyCallback::BnMyCallback() {} ITrunkStableTest::BnMyCallback::~BnMyCallback() {} std::function ITrunkStableTest::BnMyCallback::logFunc; ::ndk::SpAIBinder ITrunkStableTest::BnMyCallback::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_test_trunk_ITrunkStableTest_IMyCallback_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } ::ndk::ScopedAStatus ITrunkStableTest::BnMyCallback::getInterfaceVersion(int32_t* _aidl_return) { *_aidl_return = IMyCallback::version; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::ScopedAStatus ITrunkStableTest::BnMyCallback::getInterfaceHash(std::string* _aidl_return) { *_aidl_return = IMyCallback::hash; return ::ndk::ScopedAStatus(AStatus_newOk()); } // Source for IMyCallback const char* ITrunkStableTest::IMyCallback::descriptor = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; ITrunkStableTest::IMyCallback::IMyCallback() {} ITrunkStableTest::IMyCallback::~IMyCallback() {} std::shared_ptr ITrunkStableTest::IMyCallback::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_test_trunk_ITrunkStableTest_IMyCallback_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t ITrunkStableTest::IMyCallback::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t ITrunkStableTest::IMyCallback::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = IMyCallback::fromBinder(binder); return STATUS_OK; } bool ITrunkStableTest::IMyCallback::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!IMyCallback::default_impl); if (impl) { IMyCallback::default_impl = impl; return true; } return false; } const std::shared_ptr& ITrunkStableTest::IMyCallback::getDefaultImpl() { return IMyCallback::default_impl; } std::shared_ptr ITrunkStableTest::IMyCallback::default_impl = nullptr; ::ndk::ScopedAStatus ITrunkStableTest::IMyCallbackDefault::repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& /*in_input*/, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTest::IMyCallbackDefault::repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum /*in_input*/, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTest::IMyCallbackDefault::repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& /*in_input*/, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTest::IMyCallbackDefault::getInterfaceVersion(int32_t* _aidl_return) { *_aidl_return = 0; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::ScopedAStatus ITrunkStableTest::IMyCallbackDefault::getInterfaceHash(std::string* _aidl_return) { *_aidl_return = ""; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::SpAIBinder ITrunkStableTest::IMyCallbackDefault::asBinder() { return ::ndk::SpAIBinder(); } bool ITrunkStableTest::IMyCallbackDefault::isRemote() { return false; } } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-so0100644 0000000 0000000 00000000261 15172120304 033161 xustar000000000 0000000 149 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/android/aidl/test/trunk/ITrunkStableTest.cpp.d 28 mtime=1776853188.7220000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/android0100644 0000000 0000000 00000000433 15172120304 033153 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/android/aidl/test/trunk/ITrunkStableTest.cpp : \ system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/android/aidl/test/trunk/ITrunkStableTest.aidl ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-so0100644 0000000 0000000 00000000213 15172120304 033156 xustar000000000 0000000 111 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include/ 28 mtime=1776853188.7220000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include0040755 0000000 0000000 00000000000 15172120304 033157 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-so0100644 0000000 0000000 00000000220 15172120304 033154 xustar000000000 0000000 116 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include/aidl/ 28 mtime=1776853188.7220000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include0040755 0000000 0000000 00000000000 15172120304 033157 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-so0100644 0000000 0000000 00000000230 15172120304 033155 xustar000000000 0000000 124 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include/aidl/android/ 28 mtime=1776853188.7220000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include0040755 0000000 0000000 00000000000 15172120304 033157 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-so0100644 0000000 0000000 00000000235 15172120304 033162 xustar000000000 0000000 129 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include/aidl/android/aidl/ 28 mtime=1776853188.7220000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include0040755 0000000 0000000 00000000000 15172120304 033157 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-so0100644 0000000 0000000 00000000242 15172120304 033160 xustar000000000 0000000 134 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include/aidl/android/aidl/test/ 28 mtime=1776853188.7220000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include0040755 0000000 0000000 00000000000 15172120304 033157 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-so0100644 0000000 0000000 00000000250 15172120304 033157 xustar000000000 0000000 140 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include/aidl/android/aidl/test/trunk/ 28 mtime=1776853188.7220000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include0040755 0000000 0000000 00000000000 15172120304 033157 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-so0100644 0000000 0000000 00000000273 15172120304 033164 xustar000000000 0000000 159 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include/aidl/android/aidl/test/trunk/BnTrunkStableTest.h 28 mtime=1776853188.7220000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include0100644 0000000 0000000 00000007256 15172120304 033170 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 1 --hash 88311b9118fb6fe9eff4a2ca19121de0587f6d5f -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/staging/android/aidl/test/trunk/ITrunkStableTest.cpp.d -h out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/staging -Nsystem/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1 system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/android/aidl/test/trunk/ITrunkStableTest.aidl */ #pragma once #include "aidl/android/aidl/test/trunk/ITrunkStableTest.h" #include #include #ifndef __BIONIC__ #ifndef __assert2 #define __assert2(a,b,c,d) ((void)0) #endif #endif namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { class BnTrunkStableTest : public ::ndk::BnCInterface { public: BnTrunkStableTest(); virtual ~BnTrunkStableTest(); ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) final; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) final; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; protected: ::ndk::SpAIBinder createBinder() override; private: }; class ITrunkStableTestDelegator : public BnTrunkStableTest { public: explicit ITrunkStableTestDelegator(const std::shared_ptr &impl) : _impl(impl) { int32_t _impl_ver = 0; if (!impl->getInterfaceVersion(&_impl_ver).isOk()) {; __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Delegator failed to get version of the implementation."); } if (_impl_ver != ITrunkStableTest::version) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Mismatched versions of delegator and implementation is not allowed."); } } ::ndk::ScopedAStatus repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override { return _impl->repeatParcelable(in_input, _aidl_return); } ::ndk::ScopedAStatus repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override { return _impl->repeatEnum(in_input, _aidl_return); } ::ndk::ScopedAStatus repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override { return _impl->repeatUnion(in_input, _aidl_return); } ::ndk::ScopedAStatus callMyCallback(const std::shared_ptr<::aidl::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& in_cb) override { return _impl->callMyCallback(in_cb); } protected: private: std::shared_ptr _impl; }; } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-so0100644 0000000 0000000 00000000273 15172120304 033164 xustar000000000 0000000 159 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include/aidl/android/aidl/test/trunk/BpTrunkStableTest.h 28 mtime=1776853188.7220000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include0100644 0000000 0000000 00000005621 15172120304 033162 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 1 --hash 88311b9118fb6fe9eff4a2ca19121de0587f6d5f -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/staging/android/aidl/test/trunk/ITrunkStableTest.cpp.d -h out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/staging -Nsystem/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1 system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/android/aidl/test/trunk/ITrunkStableTest.aidl */ #pragma once #include "aidl/android/aidl/test/trunk/ITrunkStableTest.h" #include #include #include #include #include namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { class BpTrunkStableTest : public ::ndk::BpCInterface { public: explicit BpTrunkStableTest(const ::ndk::SpAIBinder& binder); virtual ~BpTrunkStableTest(); ::ndk::ScopedAStatus repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override; ::ndk::ScopedAStatus repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override; ::ndk::ScopedAStatus repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override; ::ndk::ScopedAStatus callMyCallback(const std::shared_ptr<::aidl::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& in_cb) override; ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) override; int32_t _aidl_cached_version = -1; std::string _aidl_cached_hash = "-1"; std::mutex _aidl_cached_hash_mutex; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; }; } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-so0100644 0000000 0000000 00000000272 15172120304 033163 xustar000000000 0000000 158 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include/aidl/android/aidl/test/trunk/ITrunkStableTest.h 28 mtime=1776853188.7230000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include0100644 0000000 0000000 00000041116 15172120304 033161 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 1 --hash 88311b9118fb6fe9eff4a2ca19121de0587f6d5f -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/staging/android/aidl/test/trunk/ITrunkStableTest.cpp.d -h out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/staging -Nsystem/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1 system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/android/aidl/test/trunk/ITrunkStableTest.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { class ITrunkStableTestDelegator; class ITrunkStableTest : public ::ndk::ICInterface { public: typedef ITrunkStableTestDelegator DefaultDelegator; static const char* descriptor; ITrunkStableTest(); virtual ~ITrunkStableTest(); class MyParcelable { public: typedef std::false_type fixed_size; static const char* descriptor; int32_t a = 0; int32_t b = 0; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const MyParcelable& _rhs) const { return std::tie(a, b) == std::tie(_rhs.a, _rhs.b); } inline bool operator<(const MyParcelable& _rhs) const { return std::tie(a, b) < std::tie(_rhs.a, _rhs.b); } inline bool operator!=(const MyParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyParcelable& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "MyParcelable{"; _aidl_os << "a: " << ::android::internal::ToString(a); _aidl_os << ", b: " << ::android::internal::ToString(b); _aidl_os << "}"; return _aidl_os.str(); } }; enum class MyEnum : int8_t { ZERO = 0, ONE = 1, TWO = 2, }; class MyUnion { public: typedef std::false_type fixed_size; static const char* descriptor; enum class Tag : int32_t { a = 0, b = 1, }; // Expose tag symbols for legacy code static const inline Tag a = Tag::a; static const inline Tag b = Tag::b; template static constexpr bool _not_self = !std::is_same_v>, MyUnion>; MyUnion() : _value(std::in_place_index(a)>, int32_t(0)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr MyUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit MyUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static MyUnion make(_Tp&&... _args) { return MyUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static MyUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return MyUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } binder_status_t readFromParcel(const AParcel* _parcel); binder_status_t writeToParcel(AParcel* _parcel) const; inline bool operator==(const MyUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const MyUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const MyUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyUnion& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream os; os << "MyUnion{"; switch (getTag()) { case a: os << "a: " << ::android::internal::ToString(get()); break; case b: os << "b: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant _value; }; class IMyCallbackDelegator; class IMyCallback : public ::ndk::ICInterface { public: typedef IMyCallbackDelegator DefaultDelegator; static const char* descriptor; IMyCallback(); virtual ~IMyCallback(); static inline const int32_t version = 1; static inline const std::string hash = "88311b9118fb6fe9eff4a2ca19121de0587f6d5f"; static constexpr uint32_t TRANSACTION_repeatParcelable = FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_repeatEnum = FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_repeatUnion = FIRST_CALL_TRANSACTION + 2; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) = 0; virtual ::ndk::ScopedAStatus repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) = 0; virtual ::ndk::ScopedAStatus repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) = 0; virtual ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) = 0; private: static std::shared_ptr default_impl; }; class IMyCallbackDefault : public IMyCallback { public: ::ndk::ScopedAStatus repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override; ::ndk::ScopedAStatus repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override; ::ndk::ScopedAStatus repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; class BpMyCallback : public ::ndk::BpCInterface { public: explicit BpMyCallback(const ::ndk::SpAIBinder& binder); virtual ~BpMyCallback(); ::ndk::ScopedAStatus repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override; ::ndk::ScopedAStatus repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override; ::ndk::ScopedAStatus repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) override; int32_t _aidl_cached_version = -1; std::string _aidl_cached_hash = "-1"; std::mutex _aidl_cached_hash_mutex; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; }; class BnMyCallback : public ::ndk::BnCInterface { public: BnMyCallback(); virtual ~BnMyCallback(); ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) final; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) final; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; protected: ::ndk::SpAIBinder createBinder() override; private: }; static inline const int32_t version = 1; static inline const std::string hash = "88311b9118fb6fe9eff4a2ca19121de0587f6d5f"; static constexpr uint32_t TRANSACTION_repeatParcelable = FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_repeatEnum = FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_repeatUnion = FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_callMyCallback = FIRST_CALL_TRANSACTION + 3; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) = 0; virtual ::ndk::ScopedAStatus repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) = 0; virtual ::ndk::ScopedAStatus repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) = 0; virtual ::ndk::ScopedAStatus callMyCallback(const std::shared_ptr<::aidl::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& in_cb) = 0; virtual ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) = 0; private: static std::shared_ptr default_impl; }; class ITrunkStableTestDefault : public ITrunkStableTest { public: ::ndk::ScopedAStatus repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override; ::ndk::ScopedAStatus repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override; ::ndk::ScopedAStatus repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override; ::ndk::ScopedAStatus callMyCallback(const std::shared_ptr<::aidl::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& in_cb) override; ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { [[nodiscard]] static inline std::string toString(ITrunkStableTest::MyEnum val) { switch(val) { case ITrunkStableTest::MyEnum::ZERO: return "ZERO"; case ITrunkStableTest::MyEnum::ONE: return "ONE"; case ITrunkStableTest::MyEnum::TWO: return "TWO"; default: return std::to_string(static_cast(val)); } } } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum::ZERO, aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum::ONE, aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum::TWO, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { [[nodiscard]] static inline std::string toString(ITrunkStableTest::MyUnion::Tag val) { switch(val) { case ITrunkStableTest::MyUnion::Tag::a: return "a"; case ITrunkStableTest::MyUnion::Tag::b: return "b"; default: return std::to_string(static_cast(val)); } } } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion::Tag::a, aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion::Tag::b, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-so0100644 0000000 0000000 00000000214 15172120304 033157 xustar000000000 0000000 112 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/timestamp 28 mtime=1776853188.7230000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/timesta0100644 0000000 0000000 00000000000 15172120304 033167 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-rust-s0100644 0000000 0000000 00000000034 15172120304 033221 xustar000000000 0000000 28 mtime=1776853188.7240000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/0040755 0000000 0000000 00000000000 15172120304 031263 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-rust-s0100644 0000000 0000000 00000000034 15172120304 033221 xustar000000000 0000000 28 mtime=1776853188.7240000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/gen/0040755 0000000 0000000 00000000000 15172120304 032034 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-rust-s0100644 0000000 0000000 00000000214 15172120304 033221 xustar000000000 0000000 112 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/gen/android/ 28 mtime=1776853188.7240000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/gen/androi0040755 0000000 0000000 00000000000 15172120304 033231 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-rust-s0100644 0000000 0000000 00000000221 15172120304 033217 xustar000000000 0000000 117 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/gen/android/aidl/ 28 mtime=1776853188.7240000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/gen/androi0040755 0000000 0000000 00000000000 15172120304 033231 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-rust-s0100644 0000000 0000000 00000000226 15172120304 033224 xustar000000000 0000000 122 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/gen/android/aidl/test/ 28 mtime=1776853188.7240000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/gen/androi0040755 0000000 0000000 00000000000 15172120304 033231 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-rust-s0100644 0000000 0000000 00000000234 15172120304 033223 xustar000000000 0000000 128 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/gen/android/aidl/test/trunk/ 28 mtime=1776853188.7240000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/gen/androi0040755 0000000 0000000 00000000000 15172120304 033231 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-rust-s0100644 0000000 0000000 00000000257 15172120304 033230 xustar000000000 0000000 147 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/gen/android/aidl/test/trunk/ITrunkStableTest.rs 28 mtime=1776853188.7250000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/gen/androi0100644 0000000 0000000 00000150751 15172120304 033241 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust --structured --version 1 --hash 88311b9118fb6fe9eff4a2ca19121de0587f6d5f --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/gen/android/aidl/test/trunk/ITrunkStableTest.rs.d -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/gen -Nsystem/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1 system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/android/aidl/test/trunk/ITrunkStableTest.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { ITrunkStableTest["android.aidl.test.trunk.ITrunkStableTest"] { native: BnTrunkStableTest(on_transact), proxy: BpTrunkStableTest { cached_version: std::sync::atomic::AtomicI32 = std::sync::atomic::AtomicI32::new(-1), cached_hash: std::sync::Mutex> = std::sync::Mutex::new(None) }, async: ITrunkStableTestAsync, } } pub trait ITrunkStableTest: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.test.trunk.ITrunkStableTest" } fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result; fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result; fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result; fn r#callMyCallback(&self, _arg_cb: &binder::Strong) -> binder::Result<()>; fn r#getInterfaceVersion(&self) -> binder::Result { Ok(VERSION) } fn r#getInterfaceHash(&self) -> binder::Result { Ok(HASH.into()) } fn getDefaultImpl() -> ITrunkStableTestDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: ITrunkStableTestDefaultRef) -> ITrunkStableTestDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait ITrunkStableTestAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.test.trunk.ITrunkStableTest" } fn r#repeatParcelable<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::BoxFuture<'a, binder::Result>; fn r#repeatEnum<'a>(&'a self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::BoxFuture<'a, binder::Result>; fn r#repeatUnion<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::BoxFuture<'a, binder::Result>; fn r#callMyCallback<'a>(&'a self, _arg_cb: &'a binder::Strong) -> binder::BoxFuture<'a, binder::Result<()>>; fn r#getInterfaceVersion<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { Box::pin(async move { Ok(VERSION) }) } fn r#getInterfaceHash<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { Box::pin(async move { Ok(HASH.into()) }) } } #[::async_trait::async_trait] pub trait ITrunkStableTestAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.test.trunk.ITrunkStableTest" } async fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result; async fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result; async fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result; async fn r#callMyCallback(&self, _arg_cb: &binder::Strong) -> binder::Result<()>; } impl BnTrunkStableTest { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: ITrunkStableTestAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl ITrunkStableTest for Wrapper where T: ITrunkStableTestAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { self._rt.block_on(self._inner.r#repeatParcelable(_arg_input)) } fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { self._rt.block_on(self._inner.r#repeatEnum(_arg_input)) } fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { self._rt.block_on(self._inner.r#repeatUnion(_arg_input)) } fn r#callMyCallback(&self, _arg_cb: &binder::Strong) -> binder::Result<()> { self._rt.block_on(self._inner.r#callMyCallback(_arg_cb)) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait ITrunkStableTestDefault: Send + Sync { fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#callMyCallback(&self, _arg_cb: &binder::Strong) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#repeatParcelable: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; pub const r#repeatEnum: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 1; pub const r#repeatUnion: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 2; pub const r#callMyCallback: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 3; pub const r#getInterfaceVersion: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 16777214; pub const r#getInterfaceHash: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 16777213; } pub type ITrunkStableTestDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); pub const VERSION: i32 = 1; pub const HASH: &str = "88311b9118fb6fe9eff4a2ca19121de0587f6d5f"; impl BpTrunkStableTest { fn build_parcel_repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#repeatParcelable(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(&_arg_input)?; Ok(aidl_data) } fn read_response_repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#repeatEnum(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#repeatUnion(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_callMyCallback(&self, _arg_cb: &binder::Strong) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_cb)?; Ok(aidl_data) } fn read_response_callMyCallback(&self, _arg_cb: &binder::Strong, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#callMyCallback(_arg_cb); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } Ok(()) } fn build_parcel_getInterfaceVersion(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_getInterfaceVersion(&self, _aidl_reply: std::result::Result) -> binder::Result { let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: i32 = _aidl_reply.read()?; self.cached_version.store(_aidl_return, std::sync::atomic::Ordering::Relaxed); Ok(_aidl_return) } fn build_parcel_getInterfaceHash(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_getInterfaceHash(&self, _aidl_reply: std::result::Result) -> binder::Result { let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: String = _aidl_reply.read()?; *self.cached_hash.lock().unwrap() = Some(_aidl_return.clone()); Ok(_aidl_return) } } impl ITrunkStableTest for BpTrunkStableTest { fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { let _aidl_data = self.build_parcel_repeatParcelable(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#repeatParcelable, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_repeatParcelable(_arg_input, _aidl_reply) } fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { let _aidl_data = self.build_parcel_repeatEnum(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#repeatEnum, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_repeatEnum(_arg_input, _aidl_reply) } fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { let _aidl_data = self.build_parcel_repeatUnion(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#repeatUnion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_repeatUnion(_arg_input, _aidl_reply) } fn r#callMyCallback(&self, _arg_cb: &binder::Strong) -> binder::Result<()> { let _aidl_data = self.build_parcel_callMyCallback(_arg_cb)?; let _aidl_reply = self.binder.submit_transact(transactions::r#callMyCallback, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_callMyCallback(_arg_cb, _aidl_reply) } fn r#getInterfaceVersion(&self) -> binder::Result { let _aidl_version = self.cached_version.load(std::sync::atomic::Ordering::Relaxed); if _aidl_version != -1 { return Ok(_aidl_version); } let _aidl_data = self.build_parcel_getInterfaceVersion()?; let _aidl_reply = self.binder.submit_transact(transactions::r#getInterfaceVersion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_getInterfaceVersion(_aidl_reply) } fn r#getInterfaceHash(&self) -> binder::Result { { let _aidl_hash_lock = self.cached_hash.lock().unwrap(); if let Some(ref _aidl_hash) = *_aidl_hash_lock { return Ok(_aidl_hash.clone()); } } let _aidl_data = self.build_parcel_getInterfaceHash()?; let _aidl_reply = self.binder.submit_transact(transactions::r#getInterfaceHash, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_getInterfaceHash(_aidl_reply) } } impl ITrunkStableTestAsync

for BpTrunkStableTest { fn r#repeatParcelable<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_repeatParcelable(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#repeatParcelable, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_repeatParcelable(_arg_input, _aidl_reply) } ) } fn r#repeatEnum<'a>(&'a self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_repeatEnum(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#repeatEnum, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_repeatEnum(_arg_input, _aidl_reply) } ) } fn r#repeatUnion<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_repeatUnion(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#repeatUnion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_repeatUnion(_arg_input, _aidl_reply) } ) } fn r#callMyCallback<'a>(&'a self, _arg_cb: &'a binder::Strong) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_callMyCallback(_arg_cb) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#callMyCallback, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_callMyCallback(_arg_cb, _aidl_reply) } ) } fn r#getInterfaceVersion<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { let _aidl_version = self.cached_version.load(std::sync::atomic::Ordering::Relaxed); if _aidl_version != -1 { return Box::pin(std::future::ready(Ok(_aidl_version))); } let _aidl_data = match self.build_parcel_getInterfaceVersion() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#getInterfaceVersion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_getInterfaceVersion(_aidl_reply) } ) } fn r#getInterfaceHash<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { { let _aidl_hash_lock = self.cached_hash.lock().unwrap(); if let Some(ref _aidl_hash) = *_aidl_hash_lock { return Box::pin(std::future::ready(Ok(_aidl_hash.clone()))); } } let _aidl_data = match self.build_parcel_getInterfaceHash() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#getInterfaceHash, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_getInterfaceHash(_aidl_reply) } ) } } impl ITrunkStableTest for binder::binder_impl::Binder { fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { self.0.r#repeatParcelable(_arg_input) } fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { self.0.r#repeatEnum(_arg_input) } fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { self.0.r#repeatUnion(_arg_input) } fn r#callMyCallback(&self, _arg_cb: &binder::Strong) -> binder::Result<()> { self.0.r#callMyCallback(_arg_cb) } fn r#getInterfaceVersion(&self) -> binder::Result { self.0.r#getInterfaceVersion() } fn r#getInterfaceHash(&self) -> binder::Result { self.0.r#getInterfaceHash() } } fn on_transact(_aidl_service: &dyn ITrunkStableTest, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#repeatParcelable => { let _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable = _aidl_data.read()?; let _aidl_return = _aidl_service.r#repeatParcelable(&_arg_input); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#repeatEnum => { let _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum = _aidl_data.read()?; let _aidl_return = _aidl_service.r#repeatEnum(_arg_input); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#repeatUnion => { let _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion = _aidl_data.read()?; let _aidl_return = _aidl_service.r#repeatUnion(&_arg_input); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#callMyCallback => { let _arg_cb: binder::Strong = _aidl_data.read()?; let _aidl_return = _aidl_service.r#callMyCallback(&_arg_cb); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#getInterfaceVersion => { let _aidl_return = _aidl_service.r#getInterfaceVersion(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#getInterfaceHash => { let _aidl_return = _aidl_service.r#getInterfaceHash(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } pub mod r#MyParcelable { #[derive(Debug)] pub struct r#MyParcelable { pub r#a: i32, pub r#b: i32, } impl Default for r#MyParcelable { fn default() -> Self { Self { r#a: 0, r#b: 0, } } } impl binder::Parcelable for r#MyParcelable { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#a)?; subparcel.write(&self.r#b)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#a = subparcel.read()?; } if subparcel.has_more_data() { self.r#b = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#MyParcelable); binder::impl_deserialize_for_parcelable!(r#MyParcelable); impl binder::binder_impl::ParcelableMetadata for r#MyParcelable { fn get_descriptor() -> &'static str { "android.aidl.test.trunk.ITrunkStableTest.MyParcelable" } } } pub mod r#MyEnum { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#MyEnum : [i8; 3] { r#ZERO = 0, r#ONE = 1, r#TWO = 2, } } } pub mod r#MyUnion { #[derive(Debug)] pub enum r#MyUnion { A(i32), B(i32), } impl Default for r#MyUnion { fn default() -> Self { Self::A(0) } } impl binder::Parcelable for r#MyUnion { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { match self { Self::A(v) => { parcel.write(&0i32)?; parcel.write(v) } Self::B(v) => { parcel.write(&1i32)?; parcel.write(v) } } } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { let tag: i32 = parcel.read()?; match tag { 0 => { let value: i32 = parcel.read()?; *self = Self::A(value); Ok(()) } 1 => { let value: i32 = parcel.read()?; *self = Self::B(value); Ok(()) } _ => { Err(binder::StatusCode::BAD_VALUE) } } } } binder::impl_serialize_for_parcelable!(r#MyUnion); binder::impl_deserialize_for_parcelable!(r#MyUnion); impl binder::binder_impl::ParcelableMetadata for r#MyUnion { fn get_descriptor() -> &'static str { "android.aidl.test.trunk.ITrunkStableTest.MyUnion" } } pub mod r#Tag { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#Tag : [i32; 2] { r#a = 0, r#b = 1, } } } } pub mod r#IMyCallback { #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { IMyCallback["android.aidl.test.trunk.ITrunkStableTest.IMyCallback"] { native: BnMyCallback(on_transact), proxy: BpMyCallback { cached_version: std::sync::atomic::AtomicI32 = std::sync::atomic::AtomicI32::new(-1), cached_hash: std::sync::Mutex> = std::sync::Mutex::new(None) }, async: IMyCallbackAsync, } } pub trait IMyCallback: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.test.trunk.ITrunkStableTest.IMyCallback" } fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result; fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result; fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result; fn r#getInterfaceVersion(&self) -> binder::Result { Ok(VERSION) } fn r#getInterfaceHash(&self) -> binder::Result { Ok(HASH.into()) } fn getDefaultImpl() -> IMyCallbackDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: IMyCallbackDefaultRef) -> IMyCallbackDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait IMyCallbackAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.test.trunk.ITrunkStableTest.IMyCallback" } fn r#repeatParcelable<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::BoxFuture<'a, binder::Result>; fn r#repeatEnum<'a>(&'a self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::BoxFuture<'a, binder::Result>; fn r#repeatUnion<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::BoxFuture<'a, binder::Result>; fn r#getInterfaceVersion<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { Box::pin(async move { Ok(VERSION) }) } fn r#getInterfaceHash<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { Box::pin(async move { Ok(HASH.into()) }) } } #[::async_trait::async_trait] pub trait IMyCallbackAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.test.trunk.ITrunkStableTest.IMyCallback" } async fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result; async fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result; async fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result; } impl BnMyCallback { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: IMyCallbackAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl IMyCallback for Wrapper where T: IMyCallbackAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { self._rt.block_on(self._inner.r#repeatParcelable(_arg_input)) } fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { self._rt.block_on(self._inner.r#repeatEnum(_arg_input)) } fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { self._rt.block_on(self._inner.r#repeatUnion(_arg_input)) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait IMyCallbackDefault: Send + Sync { fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#repeatParcelable: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; pub const r#repeatEnum: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 1; pub const r#repeatUnion: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 2; pub const r#getInterfaceVersion: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 16777214; pub const r#getInterfaceHash: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 16777213; } pub type IMyCallbackDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); pub const VERSION: i32 = 1; pub const HASH: &str = "88311b9118fb6fe9eff4a2ca19121de0587f6d5f"; impl BpMyCallback { fn build_parcel_repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#repeatParcelable(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(&_arg_input)?; Ok(aidl_data) } fn read_response_repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#repeatEnum(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#repeatUnion(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_getInterfaceVersion(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_getInterfaceVersion(&self, _aidl_reply: std::result::Result) -> binder::Result { let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: i32 = _aidl_reply.read()?; self.cached_version.store(_aidl_return, std::sync::atomic::Ordering::Relaxed); Ok(_aidl_return) } fn build_parcel_getInterfaceHash(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_getInterfaceHash(&self, _aidl_reply: std::result::Result) -> binder::Result { let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: String = _aidl_reply.read()?; *self.cached_hash.lock().unwrap() = Some(_aidl_return.clone()); Ok(_aidl_return) } } impl IMyCallback for BpMyCallback { fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { let _aidl_data = self.build_parcel_repeatParcelable(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#repeatParcelable, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_repeatParcelable(_arg_input, _aidl_reply) } fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { let _aidl_data = self.build_parcel_repeatEnum(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#repeatEnum, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_repeatEnum(_arg_input, _aidl_reply) } fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { let _aidl_data = self.build_parcel_repeatUnion(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#repeatUnion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_repeatUnion(_arg_input, _aidl_reply) } fn r#getInterfaceVersion(&self) -> binder::Result { let _aidl_version = self.cached_version.load(std::sync::atomic::Ordering::Relaxed); if _aidl_version != -1 { return Ok(_aidl_version); } let _aidl_data = self.build_parcel_getInterfaceVersion()?; let _aidl_reply = self.binder.submit_transact(transactions::r#getInterfaceVersion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_getInterfaceVersion(_aidl_reply) } fn r#getInterfaceHash(&self) -> binder::Result { { let _aidl_hash_lock = self.cached_hash.lock().unwrap(); if let Some(ref _aidl_hash) = *_aidl_hash_lock { return Ok(_aidl_hash.clone()); } } let _aidl_data = self.build_parcel_getInterfaceHash()?; let _aidl_reply = self.binder.submit_transact(transactions::r#getInterfaceHash, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_getInterfaceHash(_aidl_reply) } } impl IMyCallbackAsync

for BpMyCallback { fn r#repeatParcelable<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_repeatParcelable(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#repeatParcelable, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_repeatParcelable(_arg_input, _aidl_reply) } ) } fn r#repeatEnum<'a>(&'a self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_repeatEnum(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#repeatEnum, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_repeatEnum(_arg_input, _aidl_reply) } ) } fn r#repeatUnion<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_repeatUnion(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#repeatUnion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_repeatUnion(_arg_input, _aidl_reply) } ) } fn r#getInterfaceVersion<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { let _aidl_version = self.cached_version.load(std::sync::atomic::Ordering::Relaxed); if _aidl_version != -1 { return Box::pin(std::future::ready(Ok(_aidl_version))); } let _aidl_data = match self.build_parcel_getInterfaceVersion() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#getInterfaceVersion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_getInterfaceVersion(_aidl_reply) } ) } fn r#getInterfaceHash<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { { let _aidl_hash_lock = self.cached_hash.lock().unwrap(); if let Some(ref _aidl_hash) = *_aidl_hash_lock { return Box::pin(std::future::ready(Ok(_aidl_hash.clone()))); } } let _aidl_data = match self.build_parcel_getInterfaceHash() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#getInterfaceHash, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_getInterfaceHash(_aidl_reply) } ) } } impl IMyCallback for binder::binder_impl::Binder { fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { self.0.r#repeatParcelable(_arg_input) } fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { self.0.r#repeatEnum(_arg_input) } fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { self.0.r#repeatUnion(_arg_input) } fn r#getInterfaceVersion(&self) -> binder::Result { self.0.r#getInterfaceVersion() } fn r#getInterfaceHash(&self) -> binder::Result { self.0.r#getInterfaceHash() } } fn on_transact(_aidl_service: &dyn IMyCallback, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#repeatParcelable => { let _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable = _aidl_data.read()?; let _aidl_return = _aidl_service.r#repeatParcelable(&_arg_input); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#repeatEnum => { let _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum = _aidl_data.read()?; let _aidl_return = _aidl_service.r#repeatEnum(_arg_input); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#repeatUnion => { let _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion = _aidl_data.read()?; let _aidl_return = _aidl_service.r#repeatUnion(&_arg_input); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#getInterfaceVersion => { let _aidl_return = _aidl_service.r#getInterfaceVersion(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#getInterfaceHash => { let _aidl_return = _aidl_service.r#getInterfaceHash(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } } pub(crate) mod mangled { pub use super::r#ITrunkStableTest as _7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest; pub use super::r#MyParcelable::r#MyParcelable as _7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable; pub use super::r#MyEnum::r#MyEnum as _7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum; pub use super::r#MyUnion::r#MyUnion as _7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion; pub use super::r#MyUnion::r#Tag::r#Tag as _7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion_3_Tag; pub use super::r#IMyCallback::r#IMyCallback as _7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_11_IMyCallback; } ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-rust-s0100644 0000000 0000000 00000000261 15172120304 033223 xustar000000000 0000000 149 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/gen/android/aidl/test/trunk/ITrunkStableTest.rs.d 28 mtime=1776853188.7260000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/gen/androi0100644 0000000 0000000 00000000433 15172120304 033230 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/gen/android/aidl/test/trunk/ITrunkStableTest.rs : \ system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/android/aidl/test/trunk/ITrunkStableTest.aidl ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V1-rust-s0100644 0000000 0000000 00000000215 15172120304 033222 xustar000000000 0000000 113 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/gen/timestamp 28 mtime=1776853188.7260000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/gen/timest0100644 0000000 0000000 00000000000 15172120304 033247 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-cpp-so0100644 0000000 0000000 00000000034 15172120304 033166 xustar000000000 0000000 28 mtime=1776853188.7260000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/0040755 0000000 0000000 00000000000 15172120304 031051 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-cpp-so0100644 0000000 0000000 00000000034 15172120304 033166 xustar000000000 0000000 28 mtime=1776853188.7260000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/0040755 0000000 0000000 00000000000 15172120304 031622 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-cpp-so0100644 0000000 0000000 00000000213 15172120304 033165 xustar000000000 0000000 111 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/android/ 28 mtime=1776853188.7260000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/android0040755 0000000 0000000 00000000000 15172120304 033163 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-cpp-so0100644 0000000 0000000 00000000220 15172120304 033163 xustar000000000 0000000 116 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/android/aidl/ 28 mtime=1776853188.7260000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/android0040755 0000000 0000000 00000000000 15172120304 033163 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-cpp-so0100644 0000000 0000000 00000000225 15172120304 033170 xustar000000000 0000000 121 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/android/aidl/test/ 28 mtime=1776853188.7260000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/android0040755 0000000 0000000 00000000000 15172120304 033163 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-cpp-so0100644 0000000 0000000 00000000233 15172120304 033167 xustar000000000 0000000 127 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/android/aidl/test/trunk/ 28 mtime=1776853188.7260000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/android0040755 0000000 0000000 00000000000 15172120304 033163 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-cpp-so0100644 0000000 0000000 00000000257 15172120304 033175 xustar000000000 0000000 147 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/android/aidl/test/trunk/ITrunkStableTest.cpp 28 mtime=1776853188.7270000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/android0100644 0000000 0000000 00000172766 15172120304 033205 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror --structured --version 2 --hash notfrozen -t --min_sdk_version current --previous_api_dir=system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1 --previous_hash 88311b9118fb6fe9eff4a2ca19121de0587f6d5f --log --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/staging/android/aidl/test/trunk/ITrunkStableTest.cpp.d -h out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/staging -Nsystem/tools/aidl/tests/trunk_stable_test system/tools/aidl/tests/trunk_stable_test/android/aidl/test/trunk/ITrunkStableTest.aidl */ #include #include namespace android { namespace aidl { namespace test { namespace trunk { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE(TrunkStableTest, "android.aidl.test.trunk.ITrunkStableTest") } // namespace trunk } // namespace test } // namespace aidl } // namespace android #include #include #include #include #include namespace android { namespace aidl { namespace test { namespace trunk { BpTrunkStableTest::BpTrunkStableTest(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } std::function BpTrunkStableTest::logFunc; ::android::binder::Status BpTrunkStableTest::repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::repeatParcelable::cppClient"); BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("input", ::android::internal::ToString(input)); } auto _log_start = std::chrono::steady_clock::now(); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTrunkStableTest::TRANSACTION_repeatParcelable, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) [[unlikely]] { return ITrunkStableTest::getDefaultImpl()->repeatParcelable(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatParcelable"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::android::binder::Status BpTrunkStableTest::repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum input, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::repeatEnum::cppClient"); BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("input", ::android::internal::ToString(input)); } auto _log_start = std::chrono::steady_clock::now(); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeByte(static_cast(input)); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTrunkStableTest::TRANSACTION_repeatEnum, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) [[unlikely]] { return ITrunkStableTest::getDefaultImpl()->repeatEnum(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readByte(reinterpret_cast(_aidl_return)); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatEnum"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::android::binder::Status BpTrunkStableTest::repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& input, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::repeatUnion::cppClient"); BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("input", ::android::internal::ToString(input)); } auto _log_start = std::chrono::steady_clock::now(); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTrunkStableTest::TRANSACTION_repeatUnion, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) [[unlikely]] { return ITrunkStableTest::getDefaultImpl()->repeatUnion(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatUnion"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::android::binder::Status BpTrunkStableTest::callMyCallback(const ::android::sp<::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& cb) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::callMyCallback::cppClient"); BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("cb", ::android::internal::ToString(cb)); } auto _log_start = std::chrono::steady_clock::now(); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinder(cb); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTrunkStableTest::TRANSACTION_callMyCallback, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) [[unlikely]] { return ITrunkStableTest::getDefaultImpl()->callMyCallback(cb); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "callMyCallback"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::android::binder::Status BpTrunkStableTest::repeatOtherParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::repeatOtherParcelable::cppClient"); BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("input", ::android::internal::ToString(input)); } auto _log_start = std::chrono::steady_clock::now(); if (true) { _aidl_ret_status = ::android::UNKNOWN_TRANSACTION; } else { _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTrunkStableTest::TRANSACTION_repeatOtherParcelable, _aidl_data, &_aidl_reply, 0); } if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) [[unlikely]] { return ITrunkStableTest::getDefaultImpl()->repeatOtherParcelable(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatOtherParcelable"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } int32_t BpTrunkStableTest::getInterfaceVersion() { if (cached_version_ == -1) { ::android::Parcel data; ::android::Parcel reply; data.writeInterfaceToken(getInterfaceDescriptor()); ::android::status_t err = remote()->transact(BnTrunkStableTest::TRANSACTION_getInterfaceVersion, data, &reply); if (err == ::android::OK) { ::android::binder::Status _aidl_status; err = _aidl_status.readFromParcel(reply); if (err == ::android::OK && _aidl_status.isOk()) { cached_version_ = reply.readInt32(); } } } return cached_version_; } std::string BpTrunkStableTest::getInterfaceHash() { std::lock_guard lockGuard(cached_hash_mutex_); if (cached_hash_ == "-1") { ::android::Parcel data; ::android::Parcel reply; data.writeInterfaceToken(getInterfaceDescriptor()); ::android::status_t err = remote()->transact(BnTrunkStableTest::TRANSACTION_getInterfaceHash, data, &reply); if (err == ::android::OK) { ::android::binder::Status _aidl_status; err = _aidl_status.readFromParcel(reply); if (err == ::android::OK && _aidl_status.isOk()) { reply.readUtf8FromUtf16(&cached_hash_); } } } return cached_hash_; } } // namespace trunk } // namespace test } // namespace aidl } // namespace android #include #include #include #include #include namespace android { namespace aidl { namespace test { namespace trunk { BnTrunkStableTest::BnTrunkStableTest() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t BnTrunkStableTest::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnTrunkStableTest::TRANSACTION_repeatParcelable: { ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable in_input; ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::repeatParcelable::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(repeatParcelable(in_input, &_aidl_return)); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatParcelable"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTrunkStableTest::TRANSACTION_repeatEnum: { ::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input; ::android::aidl::test::trunk::ITrunkStableTest::MyEnum _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::repeatEnum::cppServer"); _aidl_ret_status = _aidl_data.readByte(reinterpret_cast(&in_input)); if (((_aidl_ret_status) != (::android::OK))) { break; } BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(repeatEnum(in_input, &_aidl_return)); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatEnum"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeByte(static_cast(_aidl_return)); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTrunkStableTest::TRANSACTION_repeatUnion: { ::android::aidl::test::trunk::ITrunkStableTest::MyUnion in_input; ::android::aidl::test::trunk::ITrunkStableTest::MyUnion _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::repeatUnion::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(repeatUnion(in_input, &_aidl_return)); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatUnion"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTrunkStableTest::TRANSACTION_callMyCallback: { ::android::sp<::android::aidl::test::trunk::ITrunkStableTest::IMyCallback> in_cb; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::callMyCallback::cppServer"); _aidl_ret_status = _aidl_data.readStrongBinder(&in_cb); if (((_aidl_ret_status) != (::android::OK))) { break; } BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_cb", ::android::internal::ToString(in_cb)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(callMyCallback(in_cb)); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "callMyCallback"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; case BnTrunkStableTest::TRANSACTION_repeatOtherParcelable: { if (true) { _aidl_ret_status = ::android::UNKNOWN_TRANSACTION; break; } ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable in_input; ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::repeatOtherParcelable::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(repeatOtherParcelable(in_input, &_aidl_return)); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatOtherParcelable"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTrunkStableTest::TRANSACTION_getInterfaceVersion: { _aidl_data.checkInterface(this); _aidl_reply->writeNoException(); _aidl_reply->writeInt32(ITrunkStableTest::VERSION); } break; case BnTrunkStableTest::TRANSACTION_getInterfaceHash: { _aidl_data.checkInterface(this); _aidl_reply->writeNoException(); _aidl_reply->writeUtf8AsUtf16(ITrunkStableTest::HASH); } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } int32_t BnTrunkStableTest::getInterfaceVersion() { return ITrunkStableTest::VERSION; } std::string BnTrunkStableTest::getInterfaceHash() { return ITrunkStableTest::HASH; } std::function BnTrunkStableTest::logFunc; } // namespace trunk } // namespace test } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace test { namespace trunk { ::android::status_t ITrunkStableTest::MyParcelable::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&a); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&b); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } if (false) { _aidl_ret_status = _aidl_parcel->readInt32(&c); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t ITrunkStableTest::MyParcelable::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeInt32(a); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(b); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (false) { _aidl_ret_status = _aidl_parcel->writeInt32(c); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace trunk } // namespace test } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace test { namespace trunk { ::android::status_t ITrunkStableTest::MyUnion::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_tag)) != ::android::OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case a: { int32_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case b: { int32_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case c: { if (true) return ::android::BAD_VALUE; int32_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } } return ::android::BAD_VALUE; } ::android::status_t ITrunkStableTest::MyUnion::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(getTag())); if (_aidl_ret_status != ::android::OK) return _aidl_ret_status; switch (getTag()) { case a: return _aidl_parcel->writeInt32(get()); case b: return _aidl_parcel->writeInt32(get()); case c: return true ? ::android::BAD_VALUE : _aidl_parcel->writeInt32(get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace trunk } // namespace test } // namespace aidl } // namespace android #include #include namespace android { namespace aidl { namespace test { namespace trunk { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_NESTED_INTERFACE(ITrunkStableTest, MyCallback, "android.aidl.test.trunk.ITrunkStableTest.IMyCallback") } // namespace trunk } // namespace test } // namespace aidl } // namespace android #include #include #include #include #include namespace android { namespace aidl { namespace test { namespace trunk { ITrunkStableTest::BpMyCallback::BpMyCallback(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } std::function ITrunkStableTest::BpMyCallback::logFunc; ::android::binder::Status ITrunkStableTest::BpMyCallback::repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyCallback::repeatParcelable::cppClient"); ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("input", ::android::internal::ToString(input)); } auto _log_start = std::chrono::steady_clock::now(); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(ITrunkStableTest::BnMyCallback::TRANSACTION_repeatParcelable, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) [[unlikely]] { return IMyCallback::getDefaultImpl()->repeatParcelable(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatParcelable"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } ::android::binder::Status ITrunkStableTest::BpMyCallback::repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum input, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyCallback::repeatEnum::cppClient"); ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("input", ::android::internal::ToString(input)); } auto _log_start = std::chrono::steady_clock::now(); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeByte(static_cast(input)); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(ITrunkStableTest::BnMyCallback::TRANSACTION_repeatEnum, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) [[unlikely]] { return IMyCallback::getDefaultImpl()->repeatEnum(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readByte(reinterpret_cast(_aidl_return)); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatEnum"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } ::android::binder::Status ITrunkStableTest::BpMyCallback::repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& input, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyCallback::repeatUnion::cppClient"); ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("input", ::android::internal::ToString(input)); } auto _log_start = std::chrono::steady_clock::now(); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(ITrunkStableTest::BnMyCallback::TRANSACTION_repeatUnion, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) [[unlikely]] { return IMyCallback::getDefaultImpl()->repeatUnion(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatUnion"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } ::android::binder::Status ITrunkStableTest::BpMyCallback::repeatOtherParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyCallback::repeatOtherParcelable::cppClient"); ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("input", ::android::internal::ToString(input)); } auto _log_start = std::chrono::steady_clock::now(); if (true) { _aidl_ret_status = ::android::UNKNOWN_TRANSACTION; } else { _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(ITrunkStableTest::BnMyCallback::TRANSACTION_repeatOtherParcelable, _aidl_data, &_aidl_reply, 0); } if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) [[unlikely]] { return IMyCallback::getDefaultImpl()->repeatOtherParcelable(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatOtherParcelable"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } int32_t ITrunkStableTest::BpMyCallback::getInterfaceVersion() { if (cached_version_ == -1) { ::android::Parcel data; ::android::Parcel reply; data.writeInterfaceToken(getInterfaceDescriptor()); ::android::status_t err = remote()->transact(ITrunkStableTest::BnMyCallback::TRANSACTION_getInterfaceVersion, data, &reply); if (err == ::android::OK) { ::android::binder::Status _aidl_status; err = _aidl_status.readFromParcel(reply); if (err == ::android::OK && _aidl_status.isOk()) { cached_version_ = reply.readInt32(); } } } return cached_version_; } std::string ITrunkStableTest::BpMyCallback::getInterfaceHash() { std::lock_guard lockGuard(cached_hash_mutex_); if (cached_hash_ == "-1") { ::android::Parcel data; ::android::Parcel reply; data.writeInterfaceToken(getInterfaceDescriptor()); ::android::status_t err = remote()->transact(ITrunkStableTest::BnMyCallback::TRANSACTION_getInterfaceHash, data, &reply); if (err == ::android::OK) { ::android::binder::Status _aidl_status; err = _aidl_status.readFromParcel(reply); if (err == ::android::OK && _aidl_status.isOk()) { reply.readUtf8FromUtf16(&cached_hash_); } } } return cached_hash_; } } // namespace trunk } // namespace test } // namespace aidl } // namespace android #include #include #include #include #include namespace android { namespace aidl { namespace test { namespace trunk { ITrunkStableTest::BnMyCallback::BnMyCallback() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t ITrunkStableTest::BnMyCallback::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnMyCallback::TRANSACTION_repeatParcelable: { ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable in_input; ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyCallback::repeatParcelable::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(repeatParcelable(in_input, &_aidl_return)); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatParcelable"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnMyCallback::TRANSACTION_repeatEnum: { ::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input; ::android::aidl::test::trunk::ITrunkStableTest::MyEnum _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyCallback::repeatEnum::cppServer"); _aidl_ret_status = _aidl_data.readByte(reinterpret_cast(&in_input)); if (((_aidl_ret_status) != (::android::OK))) { break; } ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(repeatEnum(in_input, &_aidl_return)); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatEnum"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeByte(static_cast(_aidl_return)); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnMyCallback::TRANSACTION_repeatUnion: { ::android::aidl::test::trunk::ITrunkStableTest::MyUnion in_input; ::android::aidl::test::trunk::ITrunkStableTest::MyUnion _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyCallback::repeatUnion::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(repeatUnion(in_input, &_aidl_return)); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatUnion"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnMyCallback::TRANSACTION_repeatOtherParcelable: { if (true) { _aidl_ret_status = ::android::UNKNOWN_TRANSACTION; break; } ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable in_input; ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyCallback::repeatOtherParcelable::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(repeatOtherParcelable(in_input, &_aidl_return)); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatOtherParcelable"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnMyCallback::TRANSACTION_getInterfaceVersion: { _aidl_data.checkInterface(this); _aidl_reply->writeNoException(); _aidl_reply->writeInt32(IMyCallback::VERSION); } break; case BnMyCallback::TRANSACTION_getInterfaceHash: { _aidl_data.checkInterface(this); _aidl_reply->writeNoException(); _aidl_reply->writeUtf8AsUtf16(IMyCallback::HASH); } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } int32_t ITrunkStableTest::BnMyCallback::getInterfaceVersion() { return IMyCallback::VERSION; } std::string ITrunkStableTest::BnMyCallback::getInterfaceHash() { return IMyCallback::HASH; } std::function ITrunkStableTest::BnMyCallback::logFunc; } // namespace trunk } // namespace test } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace test { namespace trunk { ::android::status_t ITrunkStableTest::MyOtherParcelable::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&a); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&b); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t ITrunkStableTest::MyOtherParcelable::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeInt32(a); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(b); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace trunk } // namespace test } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-cpp-so0100644 0000000 0000000 00000000261 15172120304 033170 xustar000000000 0000000 149 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/android/aidl/test/trunk/ITrunkStableTest.cpp.d 28 mtime=1776853188.7280000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/android0100644 0000000 0000000 00000000370 15172120304 033162 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/android/aidl/test/trunk/ITrunkStableTest.cpp : \ system/tools/aidl/tests/trunk_stable_test/android/aidl/test/trunk/ITrunkStableTest.aidl ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-cpp-so0100644 0000000 0000000 00000000213 15172120304 033165 xustar000000000 0000000 111 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include/ 28 mtime=1776853188.7280000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include0040755 0000000 0000000 00000000000 15172120304 033166 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-cpp-so0100644 0000000 0000000 00000000223 15172120304 033166 xustar000000000 0000000 119 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include/android/ 28 mtime=1776853188.7280000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include0040755 0000000 0000000 00000000000 15172120304 033166 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-cpp-so0100644 0000000 0000000 00000000230 15172120304 033164 xustar000000000 0000000 124 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include/android/aidl/ 28 mtime=1776853188.7280000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include0040755 0000000 0000000 00000000000 15172120304 033166 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-cpp-so0100644 0000000 0000000 00000000235 15172120304 033171 xustar000000000 0000000 129 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include/android/aidl/test/ 28 mtime=1776853188.7280000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include0040755 0000000 0000000 00000000000 15172120304 033166 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-cpp-so0100644 0000000 0000000 00000000243 15172120304 033170 xustar000000000 0000000 135 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include/android/aidl/test/trunk/ 28 mtime=1776853188.7280000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include0040755 0000000 0000000 00000000000 15172120304 033166 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-cpp-so0100644 0000000 0000000 00000000266 15172120304 033175 xustar000000000 0000000 154 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include/android/aidl/test/trunk/BnTrunkStableTest.h 28 mtime=1776853188.7280000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include0100644 0000000 0000000 00000012202 15172120304 033162 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror --structured --version 2 --hash notfrozen -t --min_sdk_version current --previous_api_dir=system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1 --previous_hash 88311b9118fb6fe9eff4a2ca19121de0587f6d5f --log --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/staging/android/aidl/test/trunk/ITrunkStableTest.cpp.d -h out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/staging -Nsystem/tools/aidl/tests/trunk_stable_test system/tools/aidl/tests/trunk_stable_test/android/aidl/test/trunk/ITrunkStableTest.aidl */ #pragma once #include #include #include #include #include #include #include namespace android { namespace aidl { namespace test { namespace trunk { class BnTrunkStableTest : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_repeatParcelable = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_repeatEnum = ::android::IBinder::FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_repeatUnion = ::android::IBinder::FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_callMyCallback = ::android::IBinder::FIRST_CALL_TRANSACTION + 3; static constexpr uint32_t TRANSACTION_repeatOtherParcelable = ::android::IBinder::FIRST_CALL_TRANSACTION + 4; static constexpr uint32_t TRANSACTION_getInterfaceVersion = ::android::IBinder::FIRST_CALL_TRANSACTION + 16777214; static constexpr uint32_t TRANSACTION_getInterfaceHash = ::android::IBinder::FIRST_CALL_TRANSACTION + 16777213; explicit BnTrunkStableTest(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; int32_t getInterfaceVersion(); std::string getInterfaceHash(); struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; }; // class BnTrunkStableTest class ITrunkStableTestDelegator : public BnTrunkStableTest { public: explicit ITrunkStableTestDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override { return _aidl_delegate->repeatParcelable(input, _aidl_return); } ::android::binder::Status repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum input, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override { return _aidl_delegate->repeatEnum(input, _aidl_return); } ::android::binder::Status repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& input, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override { return _aidl_delegate->repeatUnion(input, _aidl_return); } ::android::binder::Status callMyCallback(const ::android::sp<::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& cb) override { ::android::sp<::android::aidl::test::trunk::ITrunkStableTest::IMyCallbackDelegator> _cb; if (cb) { _cb = ::android::sp<::android::aidl::test::trunk::ITrunkStableTest::IMyCallbackDelegator>::cast(delegate(cb)); } return _aidl_delegate->callMyCallback(_cb); } ::android::binder::Status repeatOtherParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) override { return _aidl_delegate->repeatOtherParcelable(input, _aidl_return); } int32_t getInterfaceVersion() override { int32_t _delegator_ver = BnTrunkStableTest::getInterfaceVersion(); int32_t _impl_ver = _aidl_delegate->getInterfaceVersion(); return _delegator_ver < _impl_ver ? _delegator_ver : _impl_ver; } std::string getInterfaceHash() override { return _aidl_delegate->getInterfaceHash(); } private: ::android::sp _aidl_delegate; }; // class ITrunkStableTestDelegator } // namespace trunk } // namespace test } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-cpp-so0100644 0000000 0000000 00000000266 15172120304 033175 xustar000000000 0000000 154 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include/android/aidl/test/trunk/BpTrunkStableTest.h 28 mtime=1776853188.7290000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include0100644 0000000 0000000 00000006223 15172120304 033170 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror --structured --version 2 --hash notfrozen -t --min_sdk_version current --previous_api_dir=system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1 --previous_hash 88311b9118fb6fe9eff4a2ca19121de0587f6d5f --log --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/staging/android/aidl/test/trunk/ITrunkStableTest.cpp.d -h out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/staging -Nsystem/tools/aidl/tests/trunk_stable_test system/tools/aidl/tests/trunk_stable_test/android/aidl/test/trunk/ITrunkStableTest.aidl */ #pragma once #include #include #include #include #include #include namespace android { namespace aidl { namespace test { namespace trunk { class BpTrunkStableTest : public ::android::BpInterface { public: explicit BpTrunkStableTest(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpTrunkStableTest() = default; ::android::binder::Status repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override; ::android::binder::Status repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum input, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override; ::android::binder::Status repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& input, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override; ::android::binder::Status callMyCallback(const ::android::sp<::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& cb) override; ::android::binder::Status repeatOtherParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) override; int32_t getInterfaceVersion() override; std::string getInterfaceHash() override; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; private: int32_t cached_version_ = -1; std::string cached_hash_ = "-1"; std::mutex cached_hash_mutex_; }; // class BpTrunkStableTest } // namespace trunk } // namespace test } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-cpp-so0100644 0000000 0000000 00000000265 15172120304 033174 xustar000000000 0000000 153 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include/android/aidl/test/trunk/ITrunkStableTest.h 28 mtime=1776853188.7300000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include0100644 0000000 0000000 00000052277 15172120304 033202 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror --structured --version 2 --hash notfrozen -t --min_sdk_version current --previous_api_dir=system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1 --previous_hash 88311b9118fb6fe9eff4a2ca19121de0587f6d5f --log --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/staging/android/aidl/test/trunk/ITrunkStableTest.cpp.d -h out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/staging -Nsystem/tools/aidl/tests/trunk_stable_test system/tools/aidl/tests/trunk_stable_test/android/aidl/test/trunk/ITrunkStableTest.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace android { namespace aidl { namespace test { namespace trunk { class ITrunkStableTestDelegator; class ITrunkStableTest : public ::android::IInterface { public: typedef ITrunkStableTestDelegator DefaultDelegator; DECLARE_META_INTERFACE(TrunkStableTest) static inline const int32_t VERSION = true ? 1 : 2; static inline const std::string HASH = true ? "88311b9118fb6fe9eff4a2ca19121de0587f6d5f" : "notfrozen"; class MyParcelable : public ::android::Parcelable { public: int32_t a = 0; int32_t b = 0; int32_t c = 0; inline bool operator==(const MyParcelable& _rhs) const { return std::tie(a, b, c) == std::tie(_rhs.a, _rhs.b, _rhs.c); } inline bool operator<(const MyParcelable& _rhs) const { return std::tie(a, b, c) < std::tie(_rhs.a, _rhs.b, _rhs.c); } inline bool operator!=(const MyParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyParcelable& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.test.trunk.ITrunkStableTest.MyParcelable"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "MyParcelable{"; _aidl_os << "a: " << ::android::internal::ToString(a); _aidl_os << ", b: " << ::android::internal::ToString(b); _aidl_os << ", c: " << ::android::internal::ToString(c); _aidl_os << "}"; return _aidl_os.str(); } }; // class MyParcelable enum class MyEnum : int8_t { ZERO = 0, ONE = 1, TWO = 2, THREE = 3, }; class MyUnion : public ::android::Parcelable { public: enum class Tag : int32_t { a = 0, b = 1, c = 2, }; // Expose tag symbols for legacy code static const inline Tag a = Tag::a; static const inline Tag b = Tag::b; static const inline Tag c = Tag::c; template static constexpr bool _not_self = !std::is_same_v>, MyUnion>; MyUnion() : _value(std::in_place_index(a)>, int32_t(0)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr MyUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit MyUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static MyUnion make(_Tp&&... _args) { return MyUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static MyUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return MyUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } inline bool operator==(const MyUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const MyUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const MyUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyUnion& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.test.trunk.ITrunkStableTest.MyUnion"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream os; os << "MyUnion{"; switch (getTag()) { case a: os << "a: " << ::android::internal::ToString(get()); break; case b: os << "b: " << ::android::internal::ToString(get()); break; case c: os << "c: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant _value; }; // class MyUnion class MyOtherParcelable : public ::android::Parcelable { public: int32_t a = 0; int32_t b = 0; inline bool operator==(const MyOtherParcelable& _rhs) const { return std::tie(a, b) == std::tie(_rhs.a, _rhs.b); } inline bool operator<(const MyOtherParcelable& _rhs) const { return std::tie(a, b) < std::tie(_rhs.a, _rhs.b); } inline bool operator!=(const MyOtherParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyOtherParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyOtherParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyOtherParcelable& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "MyOtherParcelable{"; _aidl_os << "a: " << ::android::internal::ToString(a); _aidl_os << ", b: " << ::android::internal::ToString(b); _aidl_os << "}"; return _aidl_os.str(); } }; // class MyOtherParcelable class IMyCallbackDelegator; class IMyCallback : public ::android::IInterface { public: typedef IMyCallbackDelegator DefaultDelegator; DECLARE_META_INTERFACE(MyCallback) static inline const int32_t VERSION = true ? 1 : 2; static inline const std::string HASH = true ? "88311b9118fb6fe9eff4a2ca19121de0587f6d5f" : "notfrozen"; virtual ::android::binder::Status repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) = 0; virtual ::android::binder::Status repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum input, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) = 0; virtual ::android::binder::Status repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& input, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) = 0; virtual ::android::binder::Status repeatOtherParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) = 0; virtual int32_t getInterfaceVersion() = 0; virtual std::string getInterfaceHash() = 0; }; // class IMyCallback class IMyCallbackDefault : public IMyCallback { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& /*input*/, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum /*input*/, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& /*input*/, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status repeatOtherParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& /*input*/, ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } int32_t getInterfaceVersion() override { return 0; } std::string getInterfaceHash() override { return ""; } }; // class IMyCallbackDefault class BpMyCallback : public ::android::BpInterface { public: explicit BpMyCallback(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpMyCallback() = default; ::android::binder::Status repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override; ::android::binder::Status repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum input, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override; ::android::binder::Status repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& input, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override; ::android::binder::Status repeatOtherParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) override; int32_t getInterfaceVersion() override; std::string getInterfaceHash() override; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; private: int32_t cached_version_ = -1; std::string cached_hash_ = "-1"; std::mutex cached_hash_mutex_; }; // class BpMyCallback class BnMyCallback : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_repeatParcelable = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_repeatEnum = ::android::IBinder::FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_repeatUnion = ::android::IBinder::FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_repeatOtherParcelable = ::android::IBinder::FIRST_CALL_TRANSACTION + 3; static constexpr uint32_t TRANSACTION_getInterfaceVersion = ::android::IBinder::FIRST_CALL_TRANSACTION + 16777214; static constexpr uint32_t TRANSACTION_getInterfaceHash = ::android::IBinder::FIRST_CALL_TRANSACTION + 16777213; explicit BnMyCallback(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; int32_t getInterfaceVersion(); std::string getInterfaceHash(); struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; }; // class BnMyCallback class IMyCallbackDelegator : public BnMyCallback { public: explicit IMyCallbackDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override { return _aidl_delegate->repeatParcelable(input, _aidl_return); } ::android::binder::Status repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum input, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override { return _aidl_delegate->repeatEnum(input, _aidl_return); } ::android::binder::Status repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& input, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override { return _aidl_delegate->repeatUnion(input, _aidl_return); } ::android::binder::Status repeatOtherParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) override { return _aidl_delegate->repeatOtherParcelable(input, _aidl_return); } int32_t getInterfaceVersion() override { int32_t _delegator_ver = BnMyCallback::getInterfaceVersion(); int32_t _impl_ver = _aidl_delegate->getInterfaceVersion(); return _delegator_ver < _impl_ver ? _delegator_ver : _impl_ver; } std::string getInterfaceHash() override { return _aidl_delegate->getInterfaceHash(); } private: ::android::sp _aidl_delegate; }; // class IMyCallbackDelegator virtual ::android::binder::Status repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) = 0; virtual ::android::binder::Status repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum input, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) = 0; virtual ::android::binder::Status repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& input, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) = 0; virtual ::android::binder::Status callMyCallback(const ::android::sp<::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& cb) = 0; virtual ::android::binder::Status repeatOtherParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) = 0; virtual int32_t getInterfaceVersion() = 0; virtual std::string getInterfaceHash() = 0; }; // class ITrunkStableTest class ITrunkStableTestDefault : public ITrunkStableTest { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& /*input*/, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum /*input*/, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& /*input*/, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status callMyCallback(const ::android::sp<::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& /*cb*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status repeatOtherParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& /*input*/, ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } int32_t getInterfaceVersion() override { return 0; } std::string getInterfaceHash() override { return ""; } }; // class ITrunkStableTestDefault } // namespace trunk } // namespace test } // namespace aidl } // namespace android namespace android { namespace aidl { namespace test { namespace trunk { [[nodiscard]] static inline std::string toString(ITrunkStableTest::MyEnum val) { switch(val) { case ITrunkStableTest::MyEnum::ZERO: return "ZERO"; case ITrunkStableTest::MyEnum::ONE: return "ONE"; case ITrunkStableTest::MyEnum::TWO: return "TWO"; case ITrunkStableTest::MyEnum::THREE: return "THREE"; default: return std::to_string(static_cast(val)); } } } // namespace trunk } // namespace test } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::test::trunk::ITrunkStableTest::MyEnum, 4> enum_values<::android::aidl::test::trunk::ITrunkStableTest::MyEnum> = { ::android::aidl::test::trunk::ITrunkStableTest::MyEnum::ZERO, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum::ONE, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum::TWO, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum::THREE, }; #pragma clang diagnostic pop } // namespace internal } // namespace android namespace android { namespace aidl { namespace test { namespace trunk { [[nodiscard]] static inline std::string toString(ITrunkStableTest::MyUnion::Tag val) { switch(val) { case ITrunkStableTest::MyUnion::Tag::a: return "a"; case ITrunkStableTest::MyUnion::Tag::b: return "b"; case ITrunkStableTest::MyUnion::Tag::c: return "c"; default: return std::to_string(static_cast(val)); } } } // namespace trunk } // namespace test } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::test::trunk::ITrunkStableTest::MyUnion::Tag, 3> enum_values<::android::aidl::test::trunk::ITrunkStableTest::MyUnion::Tag> = { ::android::aidl::test::trunk::ITrunkStableTest::MyUnion::Tag::a, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion::Tag::b, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion::Tag::c, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-cpp-so0100644 0000000 0000000 00000000214 15172120304 033166 xustar000000000 0000000 112 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/timestamp 28 mtime=1776853188.7300000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/timesta0100644 0000000 0000000 00000000000 15172120304 033176 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-java-s0100644 0000000 0000000 00000000034 15172120304 033146 xustar000000000 0000000 28 mtime=1776853188.7300000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/0040755 0000000 0000000 00000000000 15172120304 031210 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-java-s0100644 0000000 0000000 00000000034 15172120304 033146 xustar000000000 0000000 28 mtime=1776853188.7300000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/gen/0040755 0000000 0000000 00000000000 15172120304 031761 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-java-s0100644 0000000 0000000 00000000214 15172120304 033146 xustar000000000 0000000 112 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/gen/android/ 28 mtime=1776853188.7300000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/gen/androi0040755 0000000 0000000 00000000000 15172120304 033156 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-java-s0100644 0000000 0000000 00000000221 15172120304 033144 xustar000000000 0000000 117 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/gen/android/aidl/ 28 mtime=1776853188.7300000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/gen/androi0040755 0000000 0000000 00000000000 15172120304 033156 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-java-s0100644 0000000 0000000 00000000226 15172120304 033151 xustar000000000 0000000 122 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/gen/android/aidl/test/ 28 mtime=1776853188.7300000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/gen/androi0040755 0000000 0000000 00000000000 15172120304 033156 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-java-s0100644 0000000 0000000 00000000234 15172120304 033150 xustar000000000 0000000 128 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/gen/android/aidl/test/trunk/ 28 mtime=1776853188.7300000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/gen/androi0040755 0000000 0000000 00000000000 15172120304 033156 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-java-s0100644 0000000 0000000 00000000261 15172120304 033150 xustar000000000 0000000 149 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/gen/android/aidl/test/trunk/ITrunkStableTest.java 28 mtime=1776853188.7310000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/gen/androi0100644 0000000 0000000 00000115011 15172120304 033154 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror --structured --version 2 --hash notfrozen -t --min_sdk_version platform_apis --previous_api_dir=system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1 --previous_hash 88311b9118fb6fe9eff4a2ca19121de0587f6d5f --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/gen/android/aidl/test/trunk/ITrunkStableTest.java.d -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/gen -Nsystem/tools/aidl/tests/trunk_stable_test system/tools/aidl/tests/trunk_stable_test/android/aidl/test/trunk/ITrunkStableTest.aidl */ package android.aidl.test.trunk; public interface ITrunkStableTest extends android.os.IInterface { /** * The version of this interface that the caller is built against. * This might be different from what {@link #getInterfaceVersion() * getInterfaceVersion} returns as that is the version of the interface * that the remote object is implementing. */ public static final int VERSION = true ? 1 : 2; public static final String HASH = "88311b9118fb6fe9eff4a2ca19121de0587f6d5f"; /** Default implementation for ITrunkStableTest. */ public static class Default implements android.aidl.test.trunk.ITrunkStableTest { @Override public android.aidl.test.trunk.ITrunkStableTest.MyParcelable repeatParcelable(android.aidl.test.trunk.ITrunkStableTest.MyParcelable input) throws android.os.RemoteException { return null; } @Override public byte repeatEnum(byte input) throws android.os.RemoteException { return 0; } @Override public android.aidl.test.trunk.ITrunkStableTest.MyUnion repeatUnion(android.aidl.test.trunk.ITrunkStableTest.MyUnion input) throws android.os.RemoteException { return null; } @Override public void callMyCallback(android.aidl.test.trunk.ITrunkStableTest.IMyCallback cb) throws android.os.RemoteException { } @Override public android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable repeatOtherParcelable(android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable input) throws android.os.RemoteException { return null; } @Override public int getInterfaceVersion() { return 0; } @Override public String getInterfaceHash() { return ""; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.test.trunk.ITrunkStableTest { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.test.trunk.ITrunkStableTest interface, * generating a proxy if needed. */ public static android.aidl.test.trunk.ITrunkStableTest asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.test.trunk.ITrunkStableTest))) { return ((android.aidl.test.trunk.ITrunkStableTest)iin); } return new android.aidl.test.trunk.ITrunkStableTest.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_repeatParcelable: { return "repeatParcelable"; } case TRANSACTION_repeatEnum: { return "repeatEnum"; } case TRANSACTION_repeatUnion: { return "repeatUnion"; } case TRANSACTION_callMyCallback: { return "callMyCallback"; } case TRANSACTION_repeatOtherParcelable: { return "repeatOtherParcelable"; } case TRANSACTION_getInterfaceVersion: { return "getInterfaceVersion"; } case TRANSACTION_getInterfaceHash: { return "getInterfaceHash"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } else if (code == TRANSACTION_getInterfaceVersion) { reply.writeNoException(); reply.writeInt(getInterfaceVersion()); return true; } else if (code == TRANSACTION_getInterfaceHash) { reply.writeNoException(); reply.writeString(getInterfaceHash()); return true; } switch (code) { case TRANSACTION_repeatParcelable: { android.aidl.test.trunk.ITrunkStableTest.MyParcelable _arg0; _arg0 = data.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyParcelable.CREATOR); data.enforceNoDataAvail(); android.aidl.test.trunk.ITrunkStableTest.MyParcelable _result = this.repeatParcelable(_arg0); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_repeatEnum: { byte _arg0; _arg0 = data.readByte(); data.enforceNoDataAvail(); byte _result = this.repeatEnum(_arg0); reply.writeNoException(); reply.writeByte(_result); break; } case TRANSACTION_repeatUnion: { android.aidl.test.trunk.ITrunkStableTest.MyUnion _arg0; _arg0 = data.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyUnion.CREATOR); data.enforceNoDataAvail(); android.aidl.test.trunk.ITrunkStableTest.MyUnion _result = this.repeatUnion(_arg0); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_callMyCallback: { android.aidl.test.trunk.ITrunkStableTest.IMyCallback _arg0; _arg0 = android.aidl.test.trunk.ITrunkStableTest.IMyCallback.Stub.asInterface(data.readStrongBinder()); data.enforceNoDataAvail(); this.callMyCallback(_arg0); reply.writeNoException(); break; } case TRANSACTION_repeatOtherParcelable: { if (true) { throw new android.os.RemoteException("Method repeatOtherParcelable is unimplemented."); } android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable _arg0; _arg0 = data.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable.CREATOR); data.enforceNoDataAvail(); android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable _result = this.repeatOtherParcelable(_arg0); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.test.trunk.ITrunkStableTest { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } private int mCachedVersion = -1; private String mCachedHash = "-1"; @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public android.aidl.test.trunk.ITrunkStableTest.MyParcelable repeatParcelable(android.aidl.test.trunk.ITrunkStableTest.MyParcelable input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.test.trunk.ITrunkStableTest.MyParcelable _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_repeatParcelable, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method repeatParcelable is unimplemented."); } _reply.readException(); _result = _reply.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyParcelable.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public byte repeatEnum(byte input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); byte _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeByte(input); boolean _status = mRemote.transact(Stub.TRANSACTION_repeatEnum, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method repeatEnum is unimplemented."); } _reply.readException(); _result = _reply.readByte(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.test.trunk.ITrunkStableTest.MyUnion repeatUnion(android.aidl.test.trunk.ITrunkStableTest.MyUnion input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.test.trunk.ITrunkStableTest.MyUnion _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_repeatUnion, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method repeatUnion is unimplemented."); } _reply.readException(); _result = _reply.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyUnion.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public void callMyCallback(android.aidl.test.trunk.ITrunkStableTest.IMyCallback cb) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeStrongInterface(cb); boolean _status = mRemote.transact(Stub.TRANSACTION_callMyCallback, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method callMyCallback is unimplemented."); } _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } @Override public android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable repeatOtherParcelable(android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable input) throws android.os.RemoteException { if (true) { throw new android.os.RemoteException("Method repeatOtherParcelable is unimplemented."); } android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_repeatOtherParcelable, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method repeatOtherParcelable is unimplemented."); } _reply.readException(); _result = _reply.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int getInterfaceVersion() throws android.os.RemoteException { if (mCachedVersion == -1) { android.os.Parcel data = android.os.Parcel.obtain(asBinder()); android.os.Parcel reply = android.os.Parcel.obtain(); try { data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getInterfaceVersion, data, reply, 0); reply.readException(); mCachedVersion = reply.readInt(); } finally { reply.recycle(); data.recycle(); } } return mCachedVersion; } @Override public synchronized String getInterfaceHash() throws android.os.RemoteException { if ("-1".equals(mCachedHash)) { android.os.Parcel data = android.os.Parcel.obtain(asBinder()); android.os.Parcel reply = android.os.Parcel.obtain(); try { data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getInterfaceHash, data, reply, 0); reply.readException(); mCachedHash = reply.readString(); } finally { reply.recycle(); data.recycle(); } } return mCachedHash; } } static final int TRANSACTION_repeatParcelable = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); static final int TRANSACTION_repeatEnum = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1); static final int TRANSACTION_repeatUnion = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2); static final int TRANSACTION_callMyCallback = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3); static final int TRANSACTION_repeatOtherParcelable = (android.os.IBinder.FIRST_CALL_TRANSACTION + 4); static final int TRANSACTION_getInterfaceVersion = (android.os.IBinder.FIRST_CALL_TRANSACTION + 16777214); static final int TRANSACTION_getInterfaceHash = (android.os.IBinder.FIRST_CALL_TRANSACTION + 16777213); /** @hide */ public int getMaxTransactionId() { return 16777214; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android$aidl$test$trunk$ITrunkStableTest".replace('$', '.'); public android.aidl.test.trunk.ITrunkStableTest.MyParcelable repeatParcelable(android.aidl.test.trunk.ITrunkStableTest.MyParcelable input) throws android.os.RemoteException; public byte repeatEnum(byte input) throws android.os.RemoteException; public android.aidl.test.trunk.ITrunkStableTest.MyUnion repeatUnion(android.aidl.test.trunk.ITrunkStableTest.MyUnion input) throws android.os.RemoteException; public void callMyCallback(android.aidl.test.trunk.ITrunkStableTest.IMyCallback cb) throws android.os.RemoteException; public android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable repeatOtherParcelable(android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable input) throws android.os.RemoteException; public int getInterfaceVersion() throws android.os.RemoteException; public String getInterfaceHash() throws android.os.RemoteException; public static class MyParcelable implements android.os.Parcelable { public int a = 0; public int b = 0; // New in V2 public int c = 0; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public MyParcelable createFromParcel(android.os.Parcel _aidl_source) { MyParcelable _aidl_out = new MyParcelable(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public MyParcelable[] newArray(int _aidl_size) { return new MyParcelable[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(a); _aidl_parcel.writeInt(b); if (false) {; _aidl_parcel.writeInt(c); }; int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; a = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; b = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; if (false) {; c = _aidl_parcel.readInt(); }; } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } } public static @interface MyEnum { public static final byte ZERO = 0; public static final byte ONE = 1; public static final byte TWO = 2; // New in V2 public static final byte THREE = 3; } public static final class MyUnion implements android.os.Parcelable { // tags for union fields public final static int a = 0; // int a; public final static int b = 1; // int b; public final static int c = 2; // int c; private int _tag; private Object _value; public MyUnion() { int _value = 0; this._tag = a; this._value = _value; } private MyUnion(android.os.Parcel _aidl_parcel) { readFromParcel(_aidl_parcel); } private MyUnion(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public int getTag() { return _tag; } // int a; public static MyUnion a(int _value) { return new MyUnion(a, _value); } public int getA() { _assertTag(a); return (int) _value; } public void setA(int _value) { _set(a, _value); } // int b; public static MyUnion b(int _value) { return new MyUnion(b, _value); } public int getB() { _assertTag(b); return (int) _value; } public void setB(int _value) { _set(b, _value); } // int c; // New in V3 public static MyUnion c(int _value) { return new MyUnion(c, _value); } public int getC() { _assertTag(c); return (int) _value; } public void setC(int _value) { _set(c, _value); } public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public MyUnion createFromParcel(android.os.Parcel _aidl_source) { return new MyUnion(_aidl_source); } @Override public MyUnion[] newArray(int _aidl_size) { return new MyUnion[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { _aidl_parcel.writeInt(_tag); switch (_tag) { case a: _aidl_parcel.writeInt(getA()); break; case b: _aidl_parcel.writeInt(getB()); break; case c: if (true) throw new IllegalArgumentException("union: unknown tag: " + _tag); _aidl_parcel.writeInt(getC()); break; } } public void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_tag; _aidl_tag = _aidl_parcel.readInt(); switch (_aidl_tag) { case a: { int _aidl_value; _aidl_value = _aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } case b: { int _aidl_value; _aidl_value = _aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } case c: { if (true) throw new IllegalArgumentException("union: unknown tag: " + _tag); int _aidl_value; _aidl_value = _aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } } throw new IllegalArgumentException("union: unknown tag: " + _aidl_tag); } @Override public int describeContents() { int _mask = 0; switch (getTag()) { } return _mask; } private void _assertTag(int tag) { if (getTag() != tag) { throw new IllegalStateException("bad access: " + _tagString(tag) + ", " + _tagString(getTag()) + " is available."); } } private String _tagString(int _tag) { switch (_tag) { case a: return "a"; case b: return "b"; case c: return "c"; } throw new IllegalStateException("unknown field: " + _tag); } private void _set(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public static @interface Tag { public static final int a = 0; public static final int b = 1; // New in V3 public static final int c = 2; } } public interface IMyCallback extends android.os.IInterface { /** * The version of this interface that the caller is built against. * This might be different from what {@link #getInterfaceVersion() * getInterfaceVersion} returns as that is the version of the interface * that the remote object is implementing. */ public static final int VERSION = true ? 1 : 2; public static final String HASH = "88311b9118fb6fe9eff4a2ca19121de0587f6d5f"; /** Default implementation for IMyCallback. */ public static class Default implements android.aidl.test.trunk.ITrunkStableTest.IMyCallback { @Override public android.aidl.test.trunk.ITrunkStableTest.MyParcelable repeatParcelable(android.aidl.test.trunk.ITrunkStableTest.MyParcelable input) throws android.os.RemoteException { return null; } @Override public byte repeatEnum(byte input) throws android.os.RemoteException { return 0; } @Override public android.aidl.test.trunk.ITrunkStableTest.MyUnion repeatUnion(android.aidl.test.trunk.ITrunkStableTest.MyUnion input) throws android.os.RemoteException { return null; } @Override public android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable repeatOtherParcelable(android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable input) throws android.os.RemoteException { return null; } @Override public int getInterfaceVersion() { return 0; } @Override public String getInterfaceHash() { return ""; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.test.trunk.ITrunkStableTest.IMyCallback { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.test.trunk.ITrunkStableTest.IMyCallback interface, * generating a proxy if needed. */ public static android.aidl.test.trunk.ITrunkStableTest.IMyCallback asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.test.trunk.ITrunkStableTest.IMyCallback))) { return ((android.aidl.test.trunk.ITrunkStableTest.IMyCallback)iin); } return new android.aidl.test.trunk.ITrunkStableTest.IMyCallback.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_repeatParcelable: { return "repeatParcelable"; } case TRANSACTION_repeatEnum: { return "repeatEnum"; } case TRANSACTION_repeatUnion: { return "repeatUnion"; } case TRANSACTION_repeatOtherParcelable: { return "repeatOtherParcelable"; } case TRANSACTION_getInterfaceVersion: { return "getInterfaceVersion"; } case TRANSACTION_getInterfaceHash: { return "getInterfaceHash"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } else if (code == TRANSACTION_getInterfaceVersion) { reply.writeNoException(); reply.writeInt(getInterfaceVersion()); return true; } else if (code == TRANSACTION_getInterfaceHash) { reply.writeNoException(); reply.writeString(getInterfaceHash()); return true; } switch (code) { case TRANSACTION_repeatParcelable: { android.aidl.test.trunk.ITrunkStableTest.MyParcelable _arg0; _arg0 = data.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyParcelable.CREATOR); data.enforceNoDataAvail(); android.aidl.test.trunk.ITrunkStableTest.MyParcelable _result = this.repeatParcelable(_arg0); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_repeatEnum: { byte _arg0; _arg0 = data.readByte(); data.enforceNoDataAvail(); byte _result = this.repeatEnum(_arg0); reply.writeNoException(); reply.writeByte(_result); break; } case TRANSACTION_repeatUnion: { android.aidl.test.trunk.ITrunkStableTest.MyUnion _arg0; _arg0 = data.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyUnion.CREATOR); data.enforceNoDataAvail(); android.aidl.test.trunk.ITrunkStableTest.MyUnion _result = this.repeatUnion(_arg0); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_repeatOtherParcelable: { if (true) { throw new android.os.RemoteException("Method repeatOtherParcelable is unimplemented."); } android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable _arg0; _arg0 = data.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable.CREATOR); data.enforceNoDataAvail(); android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable _result = this.repeatOtherParcelable(_arg0); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.test.trunk.ITrunkStableTest.IMyCallback { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } private int mCachedVersion = -1; private String mCachedHash = "-1"; @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public android.aidl.test.trunk.ITrunkStableTest.MyParcelable repeatParcelable(android.aidl.test.trunk.ITrunkStableTest.MyParcelable input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.test.trunk.ITrunkStableTest.MyParcelable _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_repeatParcelable, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method repeatParcelable is unimplemented."); } _reply.readException(); _result = _reply.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyParcelable.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public byte repeatEnum(byte input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); byte _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeByte(input); boolean _status = mRemote.transact(Stub.TRANSACTION_repeatEnum, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method repeatEnum is unimplemented."); } _reply.readException(); _result = _reply.readByte(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.test.trunk.ITrunkStableTest.MyUnion repeatUnion(android.aidl.test.trunk.ITrunkStableTest.MyUnion input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.test.trunk.ITrunkStableTest.MyUnion _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_repeatUnion, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method repeatUnion is unimplemented."); } _reply.readException(); _result = _reply.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyUnion.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable repeatOtherParcelable(android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable input) throws android.os.RemoteException { if (true) { throw new android.os.RemoteException("Method repeatOtherParcelable is unimplemented."); } android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_repeatOtherParcelable, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method repeatOtherParcelable is unimplemented."); } _reply.readException(); _result = _reply.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int getInterfaceVersion() throws android.os.RemoteException { if (mCachedVersion == -1) { android.os.Parcel data = android.os.Parcel.obtain(asBinder()); android.os.Parcel reply = android.os.Parcel.obtain(); try { data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getInterfaceVersion, data, reply, 0); reply.readException(); mCachedVersion = reply.readInt(); } finally { reply.recycle(); data.recycle(); } } return mCachedVersion; } @Override public synchronized String getInterfaceHash() throws android.os.RemoteException { if ("-1".equals(mCachedHash)) { android.os.Parcel data = android.os.Parcel.obtain(asBinder()); android.os.Parcel reply = android.os.Parcel.obtain(); try { data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getInterfaceHash, data, reply, 0); reply.readException(); mCachedHash = reply.readString(); } finally { reply.recycle(); data.recycle(); } } return mCachedHash; } } static final int TRANSACTION_repeatParcelable = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); static final int TRANSACTION_repeatEnum = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1); static final int TRANSACTION_repeatUnion = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2); static final int TRANSACTION_repeatOtherParcelable = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3); static final int TRANSACTION_getInterfaceVersion = (android.os.IBinder.FIRST_CALL_TRANSACTION + 16777214); static final int TRANSACTION_getInterfaceHash = (android.os.IBinder.FIRST_CALL_TRANSACTION + 16777213); /** @hide */ public int getMaxTransactionId() { return 16777214; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android$aidl$test$trunk$ITrunkStableTest$IMyCallback".replace('$', '.'); public android.aidl.test.trunk.ITrunkStableTest.MyParcelable repeatParcelable(android.aidl.test.trunk.ITrunkStableTest.MyParcelable input) throws android.os.RemoteException; public byte repeatEnum(byte input) throws android.os.RemoteException; public android.aidl.test.trunk.ITrunkStableTest.MyUnion repeatUnion(android.aidl.test.trunk.ITrunkStableTest.MyUnion input) throws android.os.RemoteException; public android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable repeatOtherParcelable(android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable input) throws android.os.RemoteException; public int getInterfaceVersion() throws android.os.RemoteException; public String getInterfaceHash() throws android.os.RemoteException; } // New in V2 public static class MyOtherParcelable implements android.os.Parcelable { public int a = 0; public int b = 0; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public MyOtherParcelable createFromParcel(android.os.Parcel _aidl_source) { MyOtherParcelable _aidl_out = new MyOtherParcelable(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public MyOtherParcelable[] newArray(int _aidl_size) { return new MyOtherParcelable[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(a); _aidl_parcel.writeInt(b); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; a = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; b = _aidl_parcel.readInt(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } } } ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-java-s0100644 0000000 0000000 00000000263 15172120304 033152 xustar000000000 0000000 151 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/gen/android/aidl/test/trunk/ITrunkStableTest.java.d 28 mtime=1776853188.7320000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/gen/androi0100644 0000000 0000000 00000000372 15172120304 033157 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/gen/android/aidl/test/trunk/ITrunkStableTest.java : \ system/tools/aidl/tests/trunk_stable_test/android/aidl/test/trunk/ITrunkStableTest.aidl ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-java-s0100644 0000000 0000000 00000000215 15172120304 033147 xustar000000000 0000000 113 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/gen/timestamp 28 mtime=1776853188.7320000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/gen/timest0100644 0000000 0000000 00000000000 15172120304 033174 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-so0100644 0000000 0000000 00000000034 15172120304 033160 xustar000000000 0000000 28 mtime=1776853188.7320000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/0040755 0000000 0000000 00000000000 15172120304 031043 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-so0100644 0000000 0000000 00000000034 15172120304 033160 xustar000000000 0000000 28 mtime=1776853188.7320000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/0040755 0000000 0000000 00000000000 15172120304 031614 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-so0100644 0000000 0000000 00000000213 15172120304 033157 xustar000000000 0000000 111 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/android/ 28 mtime=1776853188.7320000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/android0040755 0000000 0000000 00000000000 15172120304 033155 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-so0100644 0000000 0000000 00000000220 15172120304 033155 xustar000000000 0000000 116 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/android/aidl/ 28 mtime=1776853188.7320000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/android0040755 0000000 0000000 00000000000 15172120304 033155 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-so0100644 0000000 0000000 00000000225 15172120304 033162 xustar000000000 0000000 121 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/android/aidl/test/ 28 mtime=1776853188.7320000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/android0040755 0000000 0000000 00000000000 15172120304 033155 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-so0100644 0000000 0000000 00000000233 15172120304 033161 xustar000000000 0000000 127 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/android/aidl/test/trunk/ 28 mtime=1776853188.7320000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/android0040755 0000000 0000000 00000000000 15172120304 033155 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-so0100644 0000000 0000000 00000000257 15172120304 033167 xustar000000000 0000000 147 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/android/aidl/test/trunk/ITrunkStableTest.cpp 28 mtime=1776853188.7330000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/android0100644 0000000 0000000 00000250376 15172120304 033171 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --structured --version 2 --hash notfrozen -t --min_sdk_version current --previous_api_dir=system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1 --previous_hash 88311b9118fb6fe9eff4a2ca19121de0587f6d5f --log --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/staging/android/aidl/test/trunk/ITrunkStableTest.cpp.d -h out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/staging -Nsystem/tools/aidl/tests/trunk_stable_test system/tools/aidl/tests/trunk_stable_test/android/aidl/test/trunk/ITrunkStableTest.aidl */ #include "aidl/android/aidl/test/trunk/ITrunkStableTest.h" #include #include #include #include namespace { struct ScopedTrace { inline explicit ScopedTrace(const char* name) { ATrace_beginSection(name); } inline ~ScopedTrace() { ATrace_endSection(); } }; } // namespace namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { static binder_status_t _aidl_android_aidl_test_trunk_ITrunkStableTest_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*repeatParcelable*/): { ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable in_input; ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::repeatParcelable::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->repeatParcelable(in_input, &_aidl_return); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatParcelable"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 1 /*repeatEnum*/): { ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input; ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::repeatEnum::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->repeatEnum(in_input, &_aidl_return); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatEnum"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 2 /*repeatUnion*/): { ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion in_input; ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::repeatUnion::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->repeatUnion(in_input, &_aidl_return); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatUnion"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 3 /*callMyCallback*/): { std::shared_ptr<::aidl::android::aidl::test::trunk::ITrunkStableTest::IMyCallback> in_cb; ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::callMyCallback::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_cb); if (_aidl_ret_status != STATUS_OK) break; BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_cb", ::android::internal::ToString(in_cb)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->callMyCallback(in_cb); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "callMyCallback"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } case (FIRST_CALL_TRANSACTION + 4 /*repeatOtherParcelable*/): { if (true) break; ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable in_input; ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::repeatOtherParcelable::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->repeatOtherParcelable(in_input, &_aidl_return); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatOtherParcelable"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 16777214 /*getInterfaceVersion*/): { int32_t _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::getInterfaceVersion::server"); BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->getInterfaceVersion(&_aidl_return); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "getInterfaceVersion"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 16777213 /*getInterfaceHash*/): { std::string _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::getInterfaceHash::server"); BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->getInterfaceHash(&_aidl_return); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "getInterfaceHash"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_test_trunk_ITrunkStableTest_clazz = ::ndk::ICInterface::defineClass(ITrunkStableTest::descriptor, _aidl_android_aidl_test_trunk_ITrunkStableTest_onTransact); BpTrunkStableTest::BpTrunkStableTest(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} BpTrunkStableTest::~BpTrunkStableTest() {} std::function BpTrunkStableTest::logFunc; ::ndk::ScopedAStatus BpTrunkStableTest::repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::repeatParcelable::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*repeatParcelable*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) { _aidl_status = ITrunkStableTest::getDefaultImpl()->repeatParcelable(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatParcelable"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus BpTrunkStableTest::repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::repeatEnum::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 1 /*repeatEnum*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) { _aidl_status = ITrunkStableTest::getDefaultImpl()->repeatEnum(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatEnum"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus BpTrunkStableTest::repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::repeatUnion::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 2 /*repeatUnion*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) { _aidl_status = ITrunkStableTest::getDefaultImpl()->repeatUnion(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatUnion"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus BpTrunkStableTest::callMyCallback(const std::shared_ptr<::aidl::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& in_cb) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_cb", ::android::internal::ToString(in_cb)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::callMyCallback::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_cb); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 3 /*callMyCallback*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) { _aidl_status = ITrunkStableTest::getDefaultImpl()->callMyCallback(in_cb); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "callMyCallback"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus BpTrunkStableTest::repeatOtherParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::repeatOtherParcelable::client"); if (true) { _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; goto _aidl_error; } _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 4 /*repeatOtherParcelable*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) { _aidl_status = ITrunkStableTest::getDefaultImpl()->repeatOtherParcelable(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatOtherParcelable"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus BpTrunkStableTest::getInterfaceVersion(int32_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; if (_aidl_cached_version != -1) { *_aidl_return = _aidl_cached_version; _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); return _aidl_status; } ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::getInterfaceVersion::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 16777214 /*getInterfaceVersion*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) { _aidl_status = ITrunkStableTest::getDefaultImpl()->getInterfaceVersion(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_cached_version = *_aidl_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "getInterfaceVersion"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus BpTrunkStableTest::getInterfaceHash(std::string* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; const std::lock_guard lock(_aidl_cached_hash_mutex); if (_aidl_cached_hash != "-1") { *_aidl_return = _aidl_cached_hash; _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); return _aidl_status; } ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::getInterfaceHash::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 16777213 /*getInterfaceHash*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) { _aidl_status = ITrunkStableTest::getDefaultImpl()->getInterfaceHash(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_cached_hash = *_aidl_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "getInterfaceHash"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } // Source for BnTrunkStableTest BnTrunkStableTest::BnTrunkStableTest() {} BnTrunkStableTest::~BnTrunkStableTest() {} std::function BnTrunkStableTest::logFunc; ::ndk::SpAIBinder BnTrunkStableTest::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_test_trunk_ITrunkStableTest_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } ::ndk::ScopedAStatus BnTrunkStableTest::getInterfaceVersion(int32_t* _aidl_return) { *_aidl_return = ITrunkStableTest::version; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::ScopedAStatus BnTrunkStableTest::getInterfaceHash(std::string* _aidl_return) { *_aidl_return = ITrunkStableTest::hash; return ::ndk::ScopedAStatus(AStatus_newOk()); } // Source for ITrunkStableTest const char* ITrunkStableTest::descriptor = "android.aidl.test.trunk.ITrunkStableTest"; ITrunkStableTest::ITrunkStableTest() {} ITrunkStableTest::~ITrunkStableTest() {} std::shared_ptr ITrunkStableTest::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_test_trunk_ITrunkStableTest_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t ITrunkStableTest::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t ITrunkStableTest::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = ITrunkStableTest::fromBinder(binder); return STATUS_OK; } bool ITrunkStableTest::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!ITrunkStableTest::default_impl); if (impl) { ITrunkStableTest::default_impl = impl; return true; } return false; } const std::shared_ptr& ITrunkStableTest::getDefaultImpl() { return ITrunkStableTest::default_impl; } std::shared_ptr ITrunkStableTest::default_impl = nullptr; ::ndk::ScopedAStatus ITrunkStableTestDefault::repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& /*in_input*/, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTestDefault::repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum /*in_input*/, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTestDefault::repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& /*in_input*/, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTestDefault::callMyCallback(const std::shared_ptr<::aidl::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& /*in_cb*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTestDefault::repeatOtherParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& /*in_input*/, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTestDefault::getInterfaceVersion(int32_t* _aidl_return) { *_aidl_return = 0; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::ScopedAStatus ITrunkStableTestDefault::getInterfaceHash(std::string* _aidl_return) { *_aidl_return = ""; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::SpAIBinder ITrunkStableTestDefault::asBinder() { return ::ndk::SpAIBinder(); } bool ITrunkStableTestDefault::isRemote() { return false; } } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { const char* ITrunkStableTest::MyParcelable::descriptor = "android.aidl.test.trunk.ITrunkStableTest.MyParcelable"; binder_status_t ITrunkStableTest::MyParcelable::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &a); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &b); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (false) { if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &c); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; } AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t ITrunkStableTest::MyParcelable::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, a); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, b); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (false) { _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, c); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; } size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { const char* ITrunkStableTest::MyUnion::descriptor = "android.aidl.test.trunk.ITrunkStableTest.MyUnion"; binder_status_t ITrunkStableTest::MyUnion::readFromParcel(const AParcel* _parcel) { binder_status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_tag)) != STATUS_OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case a: { int32_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case b: { int32_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case c: { if (true) return STATUS_BAD_VALUE; int32_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } } return STATUS_BAD_VALUE; } binder_status_t ITrunkStableTest::MyUnion::writeToParcel(AParcel* _parcel) const { binder_status_t _aidl_ret_status = ::ndk::AParcel_writeData(_parcel, static_cast(getTag())); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; switch (getTag()) { case a: return ::ndk::AParcel_writeData(_parcel, get()); case b: return ::ndk::AParcel_writeData(_parcel, get()); case c: return true ? STATUS_BAD_VALUE : ::ndk::AParcel_writeData(_parcel, get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { static binder_status_t _aidl_android_aidl_test_trunk_ITrunkStableTest_IMyCallback_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*repeatParcelable*/): { ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable in_input; ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::repeatParcelable::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->repeatParcelable(in_input, &_aidl_return); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatParcelable"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 1 /*repeatEnum*/): { ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input; ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::repeatEnum::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->repeatEnum(in_input, &_aidl_return); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatEnum"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 2 /*repeatUnion*/): { ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion in_input; ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::repeatUnion::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->repeatUnion(in_input, &_aidl_return); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatUnion"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 3 /*repeatOtherParcelable*/): { if (true) break; ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable in_input; ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::repeatOtherParcelable::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->repeatOtherParcelable(in_input, &_aidl_return); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatOtherParcelable"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 16777214 /*getInterfaceVersion*/): { int32_t _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::getInterfaceVersion::server"); ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->getInterfaceVersion(&_aidl_return); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "getInterfaceVersion"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 16777213 /*getInterfaceHash*/): { std::string _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::getInterfaceHash::server"); ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->getInterfaceHash(&_aidl_return); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "getInterfaceHash"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_test_trunk_ITrunkStableTest_IMyCallback_clazz = ::ndk::ICInterface::defineClass(ITrunkStableTest::IMyCallback::descriptor, _aidl_android_aidl_test_trunk_ITrunkStableTest_IMyCallback_onTransact); ITrunkStableTest::BpMyCallback::BpMyCallback(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} ITrunkStableTest::BpMyCallback::~BpMyCallback() {} std::function ITrunkStableTest::BpMyCallback::logFunc; ::ndk::ScopedAStatus ITrunkStableTest::BpMyCallback::repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::repeatParcelable::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*repeatParcelable*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) { _aidl_status = IMyCallback::getDefaultImpl()->repeatParcelable(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatParcelable"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTest::BpMyCallback::repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::repeatEnum::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 1 /*repeatEnum*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) { _aidl_status = IMyCallback::getDefaultImpl()->repeatEnum(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatEnum"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTest::BpMyCallback::repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::repeatUnion::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 2 /*repeatUnion*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) { _aidl_status = IMyCallback::getDefaultImpl()->repeatUnion(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatUnion"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTest::BpMyCallback::repeatOtherParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::repeatOtherParcelable::client"); if (true) { _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; goto _aidl_error; } _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 3 /*repeatOtherParcelable*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) { _aidl_status = IMyCallback::getDefaultImpl()->repeatOtherParcelable(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatOtherParcelable"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTest::BpMyCallback::getInterfaceVersion(int32_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; if (_aidl_cached_version != -1) { *_aidl_return = _aidl_cached_version; _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); return _aidl_status; } ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::getInterfaceVersion::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 16777214 /*getInterfaceVersion*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) { _aidl_status = IMyCallback::getDefaultImpl()->getInterfaceVersion(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_cached_version = *_aidl_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "getInterfaceVersion"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTest::BpMyCallback::getInterfaceHash(std::string* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; const std::lock_guard lock(_aidl_cached_hash_mutex); if (_aidl_cached_hash != "-1") { *_aidl_return = _aidl_cached_hash; _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); return _aidl_status; } ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::getInterfaceHash::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 16777213 /*getInterfaceHash*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) { _aidl_status = IMyCallback::getDefaultImpl()->getInterfaceHash(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_cached_hash = *_aidl_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "getInterfaceHash"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } // Source for BnMyCallback ITrunkStableTest::BnMyCallback::BnMyCallback() {} ITrunkStableTest::BnMyCallback::~BnMyCallback() {} std::function ITrunkStableTest::BnMyCallback::logFunc; ::ndk::SpAIBinder ITrunkStableTest::BnMyCallback::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_test_trunk_ITrunkStableTest_IMyCallback_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } ::ndk::ScopedAStatus ITrunkStableTest::BnMyCallback::getInterfaceVersion(int32_t* _aidl_return) { *_aidl_return = IMyCallback::version; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::ScopedAStatus ITrunkStableTest::BnMyCallback::getInterfaceHash(std::string* _aidl_return) { *_aidl_return = IMyCallback::hash; return ::ndk::ScopedAStatus(AStatus_newOk()); } // Source for IMyCallback const char* ITrunkStableTest::IMyCallback::descriptor = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; ITrunkStableTest::IMyCallback::IMyCallback() {} ITrunkStableTest::IMyCallback::~IMyCallback() {} std::shared_ptr ITrunkStableTest::IMyCallback::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_test_trunk_ITrunkStableTest_IMyCallback_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t ITrunkStableTest::IMyCallback::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t ITrunkStableTest::IMyCallback::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = IMyCallback::fromBinder(binder); return STATUS_OK; } bool ITrunkStableTest::IMyCallback::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!IMyCallback::default_impl); if (impl) { IMyCallback::default_impl = impl; return true; } return false; } const std::shared_ptr& ITrunkStableTest::IMyCallback::getDefaultImpl() { return IMyCallback::default_impl; } std::shared_ptr ITrunkStableTest::IMyCallback::default_impl = nullptr; ::ndk::ScopedAStatus ITrunkStableTest::IMyCallbackDefault::repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& /*in_input*/, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTest::IMyCallbackDefault::repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum /*in_input*/, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTest::IMyCallbackDefault::repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& /*in_input*/, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTest::IMyCallbackDefault::repeatOtherParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& /*in_input*/, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTest::IMyCallbackDefault::getInterfaceVersion(int32_t* _aidl_return) { *_aidl_return = 0; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::ScopedAStatus ITrunkStableTest::IMyCallbackDefault::getInterfaceHash(std::string* _aidl_return) { *_aidl_return = ""; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::SpAIBinder ITrunkStableTest::IMyCallbackDefault::asBinder() { return ::ndk::SpAIBinder(); } bool ITrunkStableTest::IMyCallbackDefault::isRemote() { return false; } } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { const char* ITrunkStableTest::MyOtherParcelable::descriptor = "android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable"; binder_status_t ITrunkStableTest::MyOtherParcelable::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &a); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &b); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t ITrunkStableTest::MyOtherParcelable::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, a); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, b); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-so0100644 0000000 0000000 00000000261 15172120304 033162 xustar000000000 0000000 149 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/android/aidl/test/trunk/ITrunkStableTest.cpp.d 28 mtime=1776853188.7350000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/android0100644 0000000 0000000 00000000370 15172120304 033154 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/android/aidl/test/trunk/ITrunkStableTest.cpp : \ system/tools/aidl/tests/trunk_stable_test/android/aidl/test/trunk/ITrunkStableTest.aidl ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-so0100644 0000000 0000000 00000000213 15172120304 033157 xustar000000000 0000000 111 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include/ 28 mtime=1776853188.7350000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include0040755 0000000 0000000 00000000000 15172120304 033160 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-so0100644 0000000 0000000 00000000220 15172120304 033155 xustar000000000 0000000 116 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include/aidl/ 28 mtime=1776853188.7350000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include0040755 0000000 0000000 00000000000 15172120304 033160 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-so0100644 0000000 0000000 00000000230 15172120304 033156 xustar000000000 0000000 124 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include/aidl/android/ 28 mtime=1776853188.7350000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include0040755 0000000 0000000 00000000000 15172120304 033160 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-so0100644 0000000 0000000 00000000235 15172120304 033163 xustar000000000 0000000 129 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include/aidl/android/aidl/ 28 mtime=1776853188.7350000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include0040755 0000000 0000000 00000000000 15172120304 033160 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-so0100644 0000000 0000000 00000000242 15172120304 033161 xustar000000000 0000000 134 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include/aidl/android/aidl/test/ 28 mtime=1776853188.7350000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include0040755 0000000 0000000 00000000000 15172120304 033160 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-so0100644 0000000 0000000 00000000250 15172120304 033160 xustar000000000 0000000 140 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include/aidl/android/aidl/test/trunk/ 28 mtime=1776853188.7360000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include0040755 0000000 0000000 00000000000 15172120304 033160 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-so0100644 0000000 0000000 00000000273 15172120304 033165 xustar000000000 0000000 159 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include/aidl/android/aidl/test/trunk/BnTrunkStableTest.h 28 mtime=1776853188.7360000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include0100644 0000000 0000000 00000010107 15172120304 033156 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --structured --version 2 --hash notfrozen -t --min_sdk_version current --previous_api_dir=system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1 --previous_hash 88311b9118fb6fe9eff4a2ca19121de0587f6d5f --log --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/staging/android/aidl/test/trunk/ITrunkStableTest.cpp.d -h out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/staging -Nsystem/tools/aidl/tests/trunk_stable_test system/tools/aidl/tests/trunk_stable_test/android/aidl/test/trunk/ITrunkStableTest.aidl */ #pragma once #include "aidl/android/aidl/test/trunk/ITrunkStableTest.h" #include #include #ifndef __BIONIC__ #ifndef __assert2 #define __assert2(a,b,c,d) ((void)0) #endif #endif namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { class BnTrunkStableTest : public ::ndk::BnCInterface { public: BnTrunkStableTest(); virtual ~BnTrunkStableTest(); ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) final; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) final; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; protected: ::ndk::SpAIBinder createBinder() override; private: }; class ITrunkStableTestDelegator : public BnTrunkStableTest { public: explicit ITrunkStableTestDelegator(const std::shared_ptr &impl) : _impl(impl) { int32_t _impl_ver = 0; if (!impl->getInterfaceVersion(&_impl_ver).isOk()) {; __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Delegator failed to get version of the implementation."); } if (_impl_ver != ITrunkStableTest::version) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Mismatched versions of delegator and implementation is not allowed."); } } ::ndk::ScopedAStatus repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override { return _impl->repeatParcelable(in_input, _aidl_return); } ::ndk::ScopedAStatus repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override { return _impl->repeatEnum(in_input, _aidl_return); } ::ndk::ScopedAStatus repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override { return _impl->repeatUnion(in_input, _aidl_return); } ::ndk::ScopedAStatus callMyCallback(const std::shared_ptr<::aidl::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& in_cb) override { return _impl->callMyCallback(in_cb); } ::ndk::ScopedAStatus repeatOtherParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) override { return _impl->repeatOtherParcelable(in_input, _aidl_return); } protected: private: std::shared_ptr _impl; }; } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-so0100644 0000000 0000000 00000000273 15172120304 033165 xustar000000000 0000000 159 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include/aidl/android/aidl/test/trunk/BpTrunkStableTest.h 28 mtime=1776853188.7370000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include0100644 0000000 0000000 00000006344 15172120304 033166 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --structured --version 2 --hash notfrozen -t --min_sdk_version current --previous_api_dir=system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1 --previous_hash 88311b9118fb6fe9eff4a2ca19121de0587f6d5f --log --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/staging/android/aidl/test/trunk/ITrunkStableTest.cpp.d -h out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/staging -Nsystem/tools/aidl/tests/trunk_stable_test system/tools/aidl/tests/trunk_stable_test/android/aidl/test/trunk/ITrunkStableTest.aidl */ #pragma once #include "aidl/android/aidl/test/trunk/ITrunkStableTest.h" #include #include #include #include #include namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { class BpTrunkStableTest : public ::ndk::BpCInterface { public: explicit BpTrunkStableTest(const ::ndk::SpAIBinder& binder); virtual ~BpTrunkStableTest(); ::ndk::ScopedAStatus repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override; ::ndk::ScopedAStatus repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override; ::ndk::ScopedAStatus repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override; ::ndk::ScopedAStatus callMyCallback(const std::shared_ptr<::aidl::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& in_cb) override; ::ndk::ScopedAStatus repeatOtherParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) override; int32_t _aidl_cached_version = -1; std::string _aidl_cached_hash = "-1"; std::mutex _aidl_cached_hash_mutex; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; }; } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-so0100644 0000000 0000000 00000000272 15172120304 033164 xustar000000000 0000000 158 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include/aidl/android/aidl/test/trunk/ITrunkStableTest.h 28 mtime=1776853188.7370000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include0100644 0000000 0000000 00000047565 15172120304 033200 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --structured --version 2 --hash notfrozen -t --min_sdk_version current --previous_api_dir=system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1 --previous_hash 88311b9118fb6fe9eff4a2ca19121de0587f6d5f --log --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/staging/android/aidl/test/trunk/ITrunkStableTest.cpp.d -h out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/staging -Nsystem/tools/aidl/tests/trunk_stable_test system/tools/aidl/tests/trunk_stable_test/android/aidl/test/trunk/ITrunkStableTest.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { class ITrunkStableTestDelegator; class ITrunkStableTest : public ::ndk::ICInterface { public: typedef ITrunkStableTestDelegator DefaultDelegator; static const char* descriptor; ITrunkStableTest(); virtual ~ITrunkStableTest(); class MyParcelable { public: typedef std::false_type fixed_size; static const char* descriptor; int32_t a = 0; int32_t b = 0; int32_t c = 0; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const MyParcelable& _rhs) const { return std::tie(a, b, c) == std::tie(_rhs.a, _rhs.b, _rhs.c); } inline bool operator<(const MyParcelable& _rhs) const { return std::tie(a, b, c) < std::tie(_rhs.a, _rhs.b, _rhs.c); } inline bool operator!=(const MyParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyParcelable& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "MyParcelable{"; _aidl_os << "a: " << ::android::internal::ToString(a); _aidl_os << ", b: " << ::android::internal::ToString(b); _aidl_os << ", c: " << ::android::internal::ToString(c); _aidl_os << "}"; return _aidl_os.str(); } }; enum class MyEnum : int8_t { ZERO = 0, ONE = 1, TWO = 2, THREE = 3, }; class MyUnion { public: typedef std::false_type fixed_size; static const char* descriptor; enum class Tag : int32_t { a = 0, b = 1, c = 2, }; // Expose tag symbols for legacy code static const inline Tag a = Tag::a; static const inline Tag b = Tag::b; static const inline Tag c = Tag::c; template static constexpr bool _not_self = !std::is_same_v>, MyUnion>; MyUnion() : _value(std::in_place_index(a)>, int32_t(0)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr MyUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit MyUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static MyUnion make(_Tp&&... _args) { return MyUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static MyUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return MyUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } binder_status_t readFromParcel(const AParcel* _parcel); binder_status_t writeToParcel(AParcel* _parcel) const; inline bool operator==(const MyUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const MyUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const MyUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyUnion& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream os; os << "MyUnion{"; switch (getTag()) { case a: os << "a: " << ::android::internal::ToString(get()); break; case b: os << "b: " << ::android::internal::ToString(get()); break; case c: os << "c: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant _value; }; class MyOtherParcelable { public: typedef std::false_type fixed_size; static const char* descriptor; int32_t a = 0; int32_t b = 0; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const MyOtherParcelable& _rhs) const { return std::tie(a, b) == std::tie(_rhs.a, _rhs.b); } inline bool operator<(const MyOtherParcelable& _rhs) const { return std::tie(a, b) < std::tie(_rhs.a, _rhs.b); } inline bool operator!=(const MyOtherParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyOtherParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyOtherParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyOtherParcelable& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "MyOtherParcelable{"; _aidl_os << "a: " << ::android::internal::ToString(a); _aidl_os << ", b: " << ::android::internal::ToString(b); _aidl_os << "}"; return _aidl_os.str(); } }; class IMyCallbackDelegator; class IMyCallback : public ::ndk::ICInterface { public: typedef IMyCallbackDelegator DefaultDelegator; static const char* descriptor; IMyCallback(); virtual ~IMyCallback(); static inline const int32_t version = true ? 1 : 2; static inline const std::string hash = true ? "88311b9118fb6fe9eff4a2ca19121de0587f6d5f" : "notfrozen"; static constexpr uint32_t TRANSACTION_repeatParcelable = FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_repeatEnum = FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_repeatUnion = FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_repeatOtherParcelable = FIRST_CALL_TRANSACTION + 3; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) = 0; virtual ::ndk::ScopedAStatus repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) = 0; virtual ::ndk::ScopedAStatus repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) = 0; virtual ::ndk::ScopedAStatus repeatOtherParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) = 0; virtual ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) = 0; private: static std::shared_ptr default_impl; }; class IMyCallbackDefault : public IMyCallback { public: ::ndk::ScopedAStatus repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override; ::ndk::ScopedAStatus repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override; ::ndk::ScopedAStatus repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override; ::ndk::ScopedAStatus repeatOtherParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; class BpMyCallback : public ::ndk::BpCInterface { public: explicit BpMyCallback(const ::ndk::SpAIBinder& binder); virtual ~BpMyCallback(); ::ndk::ScopedAStatus repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override; ::ndk::ScopedAStatus repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override; ::ndk::ScopedAStatus repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override; ::ndk::ScopedAStatus repeatOtherParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) override; int32_t _aidl_cached_version = -1; std::string _aidl_cached_hash = "-1"; std::mutex _aidl_cached_hash_mutex; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; }; class BnMyCallback : public ::ndk::BnCInterface { public: BnMyCallback(); virtual ~BnMyCallback(); ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) final; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) final; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; protected: ::ndk::SpAIBinder createBinder() override; private: }; static inline const int32_t version = true ? 1 : 2; static inline const std::string hash = true ? "88311b9118fb6fe9eff4a2ca19121de0587f6d5f" : "notfrozen"; static constexpr uint32_t TRANSACTION_repeatParcelable = FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_repeatEnum = FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_repeatUnion = FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_callMyCallback = FIRST_CALL_TRANSACTION + 3; static constexpr uint32_t TRANSACTION_repeatOtherParcelable = FIRST_CALL_TRANSACTION + 4; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) = 0; virtual ::ndk::ScopedAStatus repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) = 0; virtual ::ndk::ScopedAStatus repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) = 0; virtual ::ndk::ScopedAStatus callMyCallback(const std::shared_ptr<::aidl::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& in_cb) = 0; virtual ::ndk::ScopedAStatus repeatOtherParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) = 0; virtual ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) = 0; private: static std::shared_ptr default_impl; }; class ITrunkStableTestDefault : public ITrunkStableTest { public: ::ndk::ScopedAStatus repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override; ::ndk::ScopedAStatus repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override; ::ndk::ScopedAStatus repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override; ::ndk::ScopedAStatus callMyCallback(const std::shared_ptr<::aidl::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& in_cb) override; ::ndk::ScopedAStatus repeatOtherParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { [[nodiscard]] static inline std::string toString(ITrunkStableTest::MyEnum val) { switch(val) { case ITrunkStableTest::MyEnum::ZERO: return "ZERO"; case ITrunkStableTest::MyEnum::ONE: return "ONE"; case ITrunkStableTest::MyEnum::TWO: return "TWO"; case ITrunkStableTest::MyEnum::THREE: return "THREE"; default: return std::to_string(static_cast(val)); } } } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum::ZERO, aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum::ONE, aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum::TWO, aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum::THREE, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { [[nodiscard]] static inline std::string toString(ITrunkStableTest::MyUnion::Tag val) { switch(val) { case ITrunkStableTest::MyUnion::Tag::a: return "a"; case ITrunkStableTest::MyUnion::Tag::b: return "b"; case ITrunkStableTest::MyUnion::Tag::c: return "c"; default: return std::to_string(static_cast(val)); } } } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion::Tag::a, aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion::Tag::b, aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion::Tag::c, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-so0100644 0000000 0000000 00000000214 15172120304 033160 xustar000000000 0000000 112 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/timestamp 28 mtime=1776853188.7380000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/timesta0100644 0000000 0000000 00000000000 15172120304 033170 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-rust-s0100644 0000000 0000000 00000000034 15172120304 033222 xustar000000000 0000000 28 mtime=1776853188.7380000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/0040755 0000000 0000000 00000000000 15172120304 031264 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-rust-s0100644 0000000 0000000 00000000034 15172120304 033222 xustar000000000 0000000 28 mtime=1776853188.7380000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/gen/0040755 0000000 0000000 00000000000 15172120304 032035 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-rust-s0100644 0000000 0000000 00000000214 15172120304 033222 xustar000000000 0000000 112 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/gen/android/ 28 mtime=1776853188.7380000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/gen/androi0040755 0000000 0000000 00000000000 15172120304 033232 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-rust-s0100644 0000000 0000000 00000000221 15172120304 033220 xustar000000000 0000000 117 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/gen/android/aidl/ 28 mtime=1776853188.7380000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/gen/androi0040755 0000000 0000000 00000000000 15172120304 033232 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-rust-s0100644 0000000 0000000 00000000226 15172120304 033225 xustar000000000 0000000 122 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/gen/android/aidl/test/ 28 mtime=1776853188.7380000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/gen/androi0040755 0000000 0000000 00000000000 15172120304 033232 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-rust-s0100644 0000000 0000000 00000000234 15172120304 033224 xustar000000000 0000000 128 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/gen/android/aidl/test/trunk/ 28 mtime=1776853188.7390000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/gen/androi0040755 0000000 0000000 00000000000 15172120304 033232 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-rust-s0100644 0000000 0000000 00000000257 15172120304 033231 xustar000000000 0000000 147 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/gen/android/aidl/test/trunk/ITrunkStableTest.rs 28 mtime=1776853188.7400000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/gen/androi0100644 0000000 0000000 00000202463 15172120304 033240 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --structured --version 2 --hash notfrozen --min_sdk_version current --previous_api_dir=system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1 --previous_hash 88311b9118fb6fe9eff4a2ca19121de0587f6d5f --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/gen/android/aidl/test/trunk/ITrunkStableTest.rs.d -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/gen -Nsystem/tools/aidl/tests/trunk_stable_test system/tools/aidl/tests/trunk_stable_test/android/aidl/test/trunk/ITrunkStableTest.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { ITrunkStableTest["android.aidl.test.trunk.ITrunkStableTest"] { native: BnTrunkStableTest(on_transact), proxy: BpTrunkStableTest { cached_version: std::sync::atomic::AtomicI32 = std::sync::atomic::AtomicI32::new(-1), cached_hash: std::sync::Mutex> = std::sync::Mutex::new(None) }, async: ITrunkStableTestAsync, } } pub trait ITrunkStableTest: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.test.trunk.ITrunkStableTest" } fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result; fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result; fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result; fn r#callMyCallback(&self, _arg_cb: &binder::Strong) -> binder::Result<()>; fn r#repeatOtherParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::Result; fn r#getInterfaceVersion(&self) -> binder::Result { Ok(VERSION) } fn r#getInterfaceHash(&self) -> binder::Result { Ok(HASH.into()) } fn getDefaultImpl() -> ITrunkStableTestDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: ITrunkStableTestDefaultRef) -> ITrunkStableTestDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait ITrunkStableTestAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.test.trunk.ITrunkStableTest" } fn r#repeatParcelable<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::BoxFuture<'a, binder::Result>; fn r#repeatEnum<'a>(&'a self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::BoxFuture<'a, binder::Result>; fn r#repeatUnion<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::BoxFuture<'a, binder::Result>; fn r#callMyCallback<'a>(&'a self, _arg_cb: &'a binder::Strong) -> binder::BoxFuture<'a, binder::Result<()>>; fn r#repeatOtherParcelable<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::BoxFuture<'a, binder::Result>; fn r#getInterfaceVersion<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { Box::pin(async move { Ok(VERSION) }) } fn r#getInterfaceHash<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { Box::pin(async move { Ok(HASH.into()) }) } } #[::async_trait::async_trait] pub trait ITrunkStableTestAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.test.trunk.ITrunkStableTest" } async fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result; async fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result; async fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result; async fn r#callMyCallback(&self, _arg_cb: &binder::Strong) -> binder::Result<()>; async fn r#repeatOtherParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::Result; } impl BnTrunkStableTest { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: ITrunkStableTestAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl ITrunkStableTest for Wrapper where T: ITrunkStableTestAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { self._rt.block_on(self._inner.r#repeatParcelable(_arg_input)) } fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { self._rt.block_on(self._inner.r#repeatEnum(_arg_input)) } fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { self._rt.block_on(self._inner.r#repeatUnion(_arg_input)) } fn r#callMyCallback(&self, _arg_cb: &binder::Strong) -> binder::Result<()> { self._rt.block_on(self._inner.r#callMyCallback(_arg_cb)) } fn r#repeatOtherParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::Result { self._rt.block_on(self._inner.r#repeatOtherParcelable(_arg_input)) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait ITrunkStableTestDefault: Send + Sync { fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#callMyCallback(&self, _arg_cb: &binder::Strong) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#repeatOtherParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#repeatParcelable: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; pub const r#repeatEnum: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 1; pub const r#repeatUnion: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 2; pub const r#callMyCallback: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 3; pub const r#repeatOtherParcelable: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 4; pub const r#getInterfaceVersion: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 16777214; pub const r#getInterfaceHash: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 16777213; } pub type ITrunkStableTestDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); pub const VERSION: i32 = if true {1} else {2}; pub const HASH: &str = if true {"88311b9118fb6fe9eff4a2ca19121de0587f6d5f"} else {"notfrozen"}; impl BpTrunkStableTest { fn build_parcel_repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#repeatParcelable(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(&_arg_input)?; Ok(aidl_data) } fn read_response_repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#repeatEnum(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#repeatUnion(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_callMyCallback(&self, _arg_cb: &binder::Strong) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_cb)?; Ok(aidl_data) } fn read_response_callMyCallback(&self, _arg_cb: &binder::Strong, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#callMyCallback(_arg_cb); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } Ok(()) } fn build_parcel_repeatOtherParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_repeatOtherParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#repeatOtherParcelable(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_getInterfaceVersion(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_getInterfaceVersion(&self, _aidl_reply: std::result::Result) -> binder::Result { let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: i32 = _aidl_reply.read()?; self.cached_version.store(_aidl_return, std::sync::atomic::Ordering::Relaxed); Ok(_aidl_return) } fn build_parcel_getInterfaceHash(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_getInterfaceHash(&self, _aidl_reply: std::result::Result) -> binder::Result { let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: String = _aidl_reply.read()?; *self.cached_hash.lock().unwrap() = Some(_aidl_return.clone()); Ok(_aidl_return) } } impl ITrunkStableTest for BpTrunkStableTest { fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { let _aidl_data = self.build_parcel_repeatParcelable(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#repeatParcelable, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_repeatParcelable(_arg_input, _aidl_reply) } fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { let _aidl_data = self.build_parcel_repeatEnum(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#repeatEnum, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_repeatEnum(_arg_input, _aidl_reply) } fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { let _aidl_data = self.build_parcel_repeatUnion(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#repeatUnion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_repeatUnion(_arg_input, _aidl_reply) } fn r#callMyCallback(&self, _arg_cb: &binder::Strong) -> binder::Result<()> { let _aidl_data = self.build_parcel_callMyCallback(_arg_cb)?; let _aidl_reply = self.binder.submit_transact(transactions::r#callMyCallback, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_callMyCallback(_arg_cb, _aidl_reply) } fn r#repeatOtherParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::Result { if (true) { return Err(binder::Status::from(binder::StatusCode::UNKNOWN_TRANSACTION)); } else { let _aidl_data = self.build_parcel_repeatOtherParcelable(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#repeatOtherParcelable, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_repeatOtherParcelable(_arg_input, _aidl_reply) } } fn r#getInterfaceVersion(&self) -> binder::Result { let _aidl_version = self.cached_version.load(std::sync::atomic::Ordering::Relaxed); if _aidl_version != -1 { return Ok(_aidl_version); } let _aidl_data = self.build_parcel_getInterfaceVersion()?; let _aidl_reply = self.binder.submit_transact(transactions::r#getInterfaceVersion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_getInterfaceVersion(_aidl_reply) } fn r#getInterfaceHash(&self) -> binder::Result { { let _aidl_hash_lock = self.cached_hash.lock().unwrap(); if let Some(ref _aidl_hash) = *_aidl_hash_lock { return Ok(_aidl_hash.clone()); } } let _aidl_data = self.build_parcel_getInterfaceHash()?; let _aidl_reply = self.binder.submit_transact(transactions::r#getInterfaceHash, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_getInterfaceHash(_aidl_reply) } } impl ITrunkStableTestAsync

for BpTrunkStableTest { fn r#repeatParcelable<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_repeatParcelable(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#repeatParcelable, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_repeatParcelable(_arg_input, _aidl_reply) } ) } fn r#repeatEnum<'a>(&'a self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_repeatEnum(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#repeatEnum, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_repeatEnum(_arg_input, _aidl_reply) } ) } fn r#repeatUnion<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_repeatUnion(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#repeatUnion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_repeatUnion(_arg_input, _aidl_reply) } ) } fn r#callMyCallback<'a>(&'a self, _arg_cb: &'a binder::Strong) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_callMyCallback(_arg_cb) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#callMyCallback, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_callMyCallback(_arg_cb, _aidl_reply) } ) } fn r#repeatOtherParcelable<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::BoxFuture<'a, binder::Result> { if (true) { return Box::pin(std::future::ready(Err(binder::Status::from(binder::StatusCode::UNKNOWN_TRANSACTION)))); } else { let _aidl_data = match self.build_parcel_repeatOtherParcelable(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#repeatOtherParcelable, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_repeatOtherParcelable(_arg_input, _aidl_reply) } ) } } fn r#getInterfaceVersion<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { let _aidl_version = self.cached_version.load(std::sync::atomic::Ordering::Relaxed); if _aidl_version != -1 { return Box::pin(std::future::ready(Ok(_aidl_version))); } let _aidl_data = match self.build_parcel_getInterfaceVersion() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#getInterfaceVersion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_getInterfaceVersion(_aidl_reply) } ) } fn r#getInterfaceHash<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { { let _aidl_hash_lock = self.cached_hash.lock().unwrap(); if let Some(ref _aidl_hash) = *_aidl_hash_lock { return Box::pin(std::future::ready(Ok(_aidl_hash.clone()))); } } let _aidl_data = match self.build_parcel_getInterfaceHash() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#getInterfaceHash, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_getInterfaceHash(_aidl_reply) } ) } } impl ITrunkStableTest for binder::binder_impl::Binder { fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { self.0.r#repeatParcelable(_arg_input) } fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { self.0.r#repeatEnum(_arg_input) } fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { self.0.r#repeatUnion(_arg_input) } fn r#callMyCallback(&self, _arg_cb: &binder::Strong) -> binder::Result<()> { self.0.r#callMyCallback(_arg_cb) } fn r#repeatOtherParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::Result { self.0.r#repeatOtherParcelable(_arg_input) } fn r#getInterfaceVersion(&self) -> binder::Result { self.0.r#getInterfaceVersion() } fn r#getInterfaceHash(&self) -> binder::Result { self.0.r#getInterfaceHash() } } fn on_transact(_aidl_service: &dyn ITrunkStableTest, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#repeatParcelable => { let _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable = _aidl_data.read()?; let _aidl_return = _aidl_service.r#repeatParcelable(&_arg_input); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#repeatEnum => { let _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum = _aidl_data.read()?; let _aidl_return = _aidl_service.r#repeatEnum(_arg_input); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#repeatUnion => { let _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion = _aidl_data.read()?; let _aidl_return = _aidl_service.r#repeatUnion(&_arg_input); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#callMyCallback => { let _arg_cb: binder::Strong = _aidl_data.read()?; let _aidl_return = _aidl_service.r#callMyCallback(&_arg_cb); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#repeatOtherParcelable => { if (true) { Err(binder::StatusCode::UNKNOWN_TRANSACTION) } else { let _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable = _aidl_data.read()?; let _aidl_return = _aidl_service.r#repeatOtherParcelable(&_arg_input); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } } transactions::r#getInterfaceVersion => { let _aidl_return = _aidl_service.r#getInterfaceVersion(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#getInterfaceHash => { let _aidl_return = _aidl_service.r#getInterfaceHash(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } pub mod r#MyParcelable { #[derive(Debug)] pub struct r#MyParcelable { pub r#a: i32, pub r#b: i32, pub r#c: i32, } impl Default for r#MyParcelable { fn default() -> Self { Self { r#a: 0, r#b: 0, r#c: 0, } } } impl binder::Parcelable for r#MyParcelable { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#a)?; subparcel.write(&self.r#b)?; if (false) { subparcel.write(&self.r#c)?; } Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#a = subparcel.read()?; } if subparcel.has_more_data() { self.r#b = subparcel.read()?; } if (false) { if subparcel.has_more_data() { self.r#c = subparcel.read()?; } } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#MyParcelable); binder::impl_deserialize_for_parcelable!(r#MyParcelable); impl binder::binder_impl::ParcelableMetadata for r#MyParcelable { fn get_descriptor() -> &'static str { "android.aidl.test.trunk.ITrunkStableTest.MyParcelable" } } } pub mod r#MyEnum { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#MyEnum : [i8; 4] { r#ZERO = 0, r#ONE = 1, r#TWO = 2, r#THREE = 3, } } } pub mod r#MyUnion { #[derive(Debug)] pub enum r#MyUnion { A(i32), B(i32), C(i32), } impl Default for r#MyUnion { fn default() -> Self { Self::A(0) } } impl binder::Parcelable for r#MyUnion { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { match self { Self::A(v) => { parcel.write(&0i32)?; parcel.write(v) } Self::B(v) => { parcel.write(&1i32)?; parcel.write(v) } Self::C(v) => { if (true) { Err(binder::StatusCode::BAD_VALUE) } else { parcel.write(&2i32)?; parcel.write(v) } } } } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { let tag: i32 = parcel.read()?; match tag { 0 => { let value: i32 = parcel.read()?; *self = Self::A(value); Ok(()) } 1 => { let value: i32 = parcel.read()?; *self = Self::B(value); Ok(()) } 2 => { if (true) { Err(binder::StatusCode::BAD_VALUE) } else { let value: i32 = parcel.read()?; *self = Self::C(value); Ok(()) } } _ => { Err(binder::StatusCode::BAD_VALUE) } } } } binder::impl_serialize_for_parcelable!(r#MyUnion); binder::impl_deserialize_for_parcelable!(r#MyUnion); impl binder::binder_impl::ParcelableMetadata for r#MyUnion { fn get_descriptor() -> &'static str { "android.aidl.test.trunk.ITrunkStableTest.MyUnion" } } pub mod r#Tag { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#Tag : [i32; 3] { r#a = 0, r#b = 1, r#c = 2, } } } } pub mod r#IMyCallback { #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { IMyCallback["android.aidl.test.trunk.ITrunkStableTest.IMyCallback"] { native: BnMyCallback(on_transact), proxy: BpMyCallback { cached_version: std::sync::atomic::AtomicI32 = std::sync::atomic::AtomicI32::new(-1), cached_hash: std::sync::Mutex> = std::sync::Mutex::new(None) }, async: IMyCallbackAsync, } } pub trait IMyCallback: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.test.trunk.ITrunkStableTest.IMyCallback" } fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result; fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result; fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result; fn r#repeatOtherParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::Result; fn r#getInterfaceVersion(&self) -> binder::Result { Ok(VERSION) } fn r#getInterfaceHash(&self) -> binder::Result { Ok(HASH.into()) } fn getDefaultImpl() -> IMyCallbackDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: IMyCallbackDefaultRef) -> IMyCallbackDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait IMyCallbackAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.test.trunk.ITrunkStableTest.IMyCallback" } fn r#repeatParcelable<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::BoxFuture<'a, binder::Result>; fn r#repeatEnum<'a>(&'a self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::BoxFuture<'a, binder::Result>; fn r#repeatUnion<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::BoxFuture<'a, binder::Result>; fn r#repeatOtherParcelable<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::BoxFuture<'a, binder::Result>; fn r#getInterfaceVersion<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { Box::pin(async move { Ok(VERSION) }) } fn r#getInterfaceHash<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { Box::pin(async move { Ok(HASH.into()) }) } } #[::async_trait::async_trait] pub trait IMyCallbackAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.test.trunk.ITrunkStableTest.IMyCallback" } async fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result; async fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result; async fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result; async fn r#repeatOtherParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::Result; } impl BnMyCallback { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: IMyCallbackAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl IMyCallback for Wrapper where T: IMyCallbackAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { self._rt.block_on(self._inner.r#repeatParcelable(_arg_input)) } fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { self._rt.block_on(self._inner.r#repeatEnum(_arg_input)) } fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { self._rt.block_on(self._inner.r#repeatUnion(_arg_input)) } fn r#repeatOtherParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::Result { self._rt.block_on(self._inner.r#repeatOtherParcelable(_arg_input)) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait IMyCallbackDefault: Send + Sync { fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#repeatOtherParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#repeatParcelable: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; pub const r#repeatEnum: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 1; pub const r#repeatUnion: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 2; pub const r#repeatOtherParcelable: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 3; pub const r#getInterfaceVersion: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 16777214; pub const r#getInterfaceHash: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 16777213; } pub type IMyCallbackDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); pub const VERSION: i32 = if true {1} else {2}; pub const HASH: &str = if true {"88311b9118fb6fe9eff4a2ca19121de0587f6d5f"} else {"notfrozen"}; impl BpMyCallback { fn build_parcel_repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#repeatParcelable(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(&_arg_input)?; Ok(aidl_data) } fn read_response_repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#repeatEnum(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#repeatUnion(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_repeatOtherParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_repeatOtherParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#repeatOtherParcelable(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_getInterfaceVersion(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_getInterfaceVersion(&self, _aidl_reply: std::result::Result) -> binder::Result { let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: i32 = _aidl_reply.read()?; self.cached_version.store(_aidl_return, std::sync::atomic::Ordering::Relaxed); Ok(_aidl_return) } fn build_parcel_getInterfaceHash(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_getInterfaceHash(&self, _aidl_reply: std::result::Result) -> binder::Result { let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: String = _aidl_reply.read()?; *self.cached_hash.lock().unwrap() = Some(_aidl_return.clone()); Ok(_aidl_return) } } impl IMyCallback for BpMyCallback { fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { let _aidl_data = self.build_parcel_repeatParcelable(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#repeatParcelable, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_repeatParcelable(_arg_input, _aidl_reply) } fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { let _aidl_data = self.build_parcel_repeatEnum(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#repeatEnum, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_repeatEnum(_arg_input, _aidl_reply) } fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { let _aidl_data = self.build_parcel_repeatUnion(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#repeatUnion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_repeatUnion(_arg_input, _aidl_reply) } fn r#repeatOtherParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::Result { if (true) { return Err(binder::Status::from(binder::StatusCode::UNKNOWN_TRANSACTION)); } else { let _aidl_data = self.build_parcel_repeatOtherParcelable(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#repeatOtherParcelable, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_repeatOtherParcelable(_arg_input, _aidl_reply) } } fn r#getInterfaceVersion(&self) -> binder::Result { let _aidl_version = self.cached_version.load(std::sync::atomic::Ordering::Relaxed); if _aidl_version != -1 { return Ok(_aidl_version); } let _aidl_data = self.build_parcel_getInterfaceVersion()?; let _aidl_reply = self.binder.submit_transact(transactions::r#getInterfaceVersion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_getInterfaceVersion(_aidl_reply) } fn r#getInterfaceHash(&self) -> binder::Result { { let _aidl_hash_lock = self.cached_hash.lock().unwrap(); if let Some(ref _aidl_hash) = *_aidl_hash_lock { return Ok(_aidl_hash.clone()); } } let _aidl_data = self.build_parcel_getInterfaceHash()?; let _aidl_reply = self.binder.submit_transact(transactions::r#getInterfaceHash, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_getInterfaceHash(_aidl_reply) } } impl IMyCallbackAsync

for BpMyCallback { fn r#repeatParcelable<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_repeatParcelable(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#repeatParcelable, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_repeatParcelable(_arg_input, _aidl_reply) } ) } fn r#repeatEnum<'a>(&'a self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_repeatEnum(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#repeatEnum, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_repeatEnum(_arg_input, _aidl_reply) } ) } fn r#repeatUnion<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_repeatUnion(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#repeatUnion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_repeatUnion(_arg_input, _aidl_reply) } ) } fn r#repeatOtherParcelable<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::BoxFuture<'a, binder::Result> { if (true) { return Box::pin(std::future::ready(Err(binder::Status::from(binder::StatusCode::UNKNOWN_TRANSACTION)))); } else { let _aidl_data = match self.build_parcel_repeatOtherParcelable(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#repeatOtherParcelable, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_repeatOtherParcelable(_arg_input, _aidl_reply) } ) } } fn r#getInterfaceVersion<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { let _aidl_version = self.cached_version.load(std::sync::atomic::Ordering::Relaxed); if _aidl_version != -1 { return Box::pin(std::future::ready(Ok(_aidl_version))); } let _aidl_data = match self.build_parcel_getInterfaceVersion() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#getInterfaceVersion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_getInterfaceVersion(_aidl_reply) } ) } fn r#getInterfaceHash<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { { let _aidl_hash_lock = self.cached_hash.lock().unwrap(); if let Some(ref _aidl_hash) = *_aidl_hash_lock { return Box::pin(std::future::ready(Ok(_aidl_hash.clone()))); } } let _aidl_data = match self.build_parcel_getInterfaceHash() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#getInterfaceHash, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_getInterfaceHash(_aidl_reply) } ) } } impl IMyCallback for binder::binder_impl::Binder { fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { self.0.r#repeatParcelable(_arg_input) } fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { self.0.r#repeatEnum(_arg_input) } fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { self.0.r#repeatUnion(_arg_input) } fn r#repeatOtherParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::Result { self.0.r#repeatOtherParcelable(_arg_input) } fn r#getInterfaceVersion(&self) -> binder::Result { self.0.r#getInterfaceVersion() } fn r#getInterfaceHash(&self) -> binder::Result { self.0.r#getInterfaceHash() } } fn on_transact(_aidl_service: &dyn IMyCallback, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#repeatParcelable => { let _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable = _aidl_data.read()?; let _aidl_return = _aidl_service.r#repeatParcelable(&_arg_input); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#repeatEnum => { let _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum = _aidl_data.read()?; let _aidl_return = _aidl_service.r#repeatEnum(_arg_input); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#repeatUnion => { let _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion = _aidl_data.read()?; let _aidl_return = _aidl_service.r#repeatUnion(&_arg_input); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#repeatOtherParcelable => { if (true) { Err(binder::StatusCode::UNKNOWN_TRANSACTION) } else { let _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable = _aidl_data.read()?; let _aidl_return = _aidl_service.r#repeatOtherParcelable(&_arg_input); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } } transactions::r#getInterfaceVersion => { let _aidl_return = _aidl_service.r#getInterfaceVersion(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#getInterfaceHash => { let _aidl_return = _aidl_service.r#getInterfaceHash(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } } pub mod r#MyOtherParcelable { #[derive(Debug)] pub struct r#MyOtherParcelable { pub r#a: i32, pub r#b: i32, } impl Default for r#MyOtherParcelable { fn default() -> Self { Self { r#a: 0, r#b: 0, } } } impl binder::Parcelable for r#MyOtherParcelable { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#a)?; subparcel.write(&self.r#b)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#a = subparcel.read()?; } if subparcel.has_more_data() { self.r#b = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#MyOtherParcelable); binder::impl_deserialize_for_parcelable!(r#MyOtherParcelable); impl binder::binder_impl::ParcelableMetadata for r#MyOtherParcelable { fn get_descriptor() -> &'static str { "android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable" } } } pub(crate) mod mangled { pub use super::r#ITrunkStableTest as _7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest; pub use super::r#MyParcelable::r#MyParcelable as _7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable; pub use super::r#MyEnum::r#MyEnum as _7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum; pub use super::r#MyUnion::r#MyUnion as _7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion; pub use super::r#MyUnion::r#Tag::r#Tag as _7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion_3_Tag; pub use super::r#IMyCallback::r#IMyCallback as _7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_11_IMyCallback; pub use super::r#MyOtherParcelable::r#MyOtherParcelable as _7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable; } ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-rust-s0100644 0000000 0000000 00000000261 15172120304 033224 xustar000000000 0000000 149 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/gen/android/aidl/test/trunk/ITrunkStableTest.rs.d 28 mtime=1776853188.7480000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/gen/androi0100644 0000000 0000000 00000000370 15172120304 033231 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/gen/android/aidl/test/trunk/ITrunkStableTest.rs : \ system/tools/aidl/tests/trunk_stable_test/android/aidl/test/trunk/ITrunkStableTest.aidl ./PaxHeaders.X/tests_golden_output_frozen_tests_trunk_stable_test_android.aidl.test.trunk-V2-rust-s0100644 0000000 0000000 00000000215 15172120304 033223 xustar000000000 0000000 113 path=tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/gen/timestamp 28 mtime=1776853188.7480000 tests/golden_output/frozen/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/gen/timest0100644 0000000 0000000 00000000000 15172120304 033250 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_0100644 0000000 0000000 00000000034 15172120304 017712 xustar000000000 0000000 28 mtime=1776853188.7490000 tests/golden_output/tests/0040755 0000000 0000000 00000000000 15172120304 014777 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_0100644 0000000 0000000 00000000034 15172120304 023526 xustar000000000 0000000 28 mtime=1776853188.7490000 tests/golden_output/tests/trunk_stable_test/0040755 0000000 0000000 00000000000 15172120304 020533 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-cpp-source_0100644 0000000 0000000 00000000034 15172120304 032620 xustar000000000 0000000 28 mtime=1776853188.7490000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/0040755 0000000 0000000 00000000000 15172120304 027545 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-cpp-source_ge0100644 0000000 0000000 00000000034 15172120304 033134 xustar000000000 0000000 28 mtime=1776853188.7490000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/0040755 0000000 0000000 00000000000 15172120304 030316 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-cpp-source_ge0100644 0000000 0000000 00000000034 15172120304 033134 xustar000000000 0000000 28 mtime=1776853188.7490000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 031736 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-cpp-source_ge0100644 0000000 0000000 00000000034 15172120304 033134 xustar000000000 0000000 28 mtime=1776853188.7490000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 032647 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-cpp-source_ge0100644 0000000 0000000 00000000216 15172120304 033136 xustar000000000 0000000 114 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/android/aidl/test/ 28 mtime=1776853188.7490000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/android/aidl/t0040755 0000000 0000000 00000000000 15172120304 033033 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-cpp-source_ge0100644 0000000 0000000 00000000224 15172120304 033135 xustar000000000 0000000 120 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/android/aidl/test/trunk/ 28 mtime=1776853188.7490000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/android/aidl/t0040755 0000000 0000000 00000000000 15172120304 033033 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-cpp-source_ge0100644 0000000 0000000 00000000250 15172120304 033134 xustar000000000 0000000 140 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/android/aidl/test/trunk/ITrunkStableTest.cpp 28 mtime=1776853188.7490000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/android/aidl/t0100644 0000000 0000000 00000136614 15172120304 033045 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 1 --hash 88311b9118fb6fe9eff4a2ca19121de0587f6d5f -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/staging/android/aidl/test/trunk/ITrunkStableTest.cpp.d -h out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/staging -Nsystem/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1 system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/android/aidl/test/trunk/ITrunkStableTest.aidl */ #include #include namespace android { namespace aidl { namespace test { namespace trunk { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE(TrunkStableTest, "android.aidl.test.trunk.ITrunkStableTest") } // namespace trunk } // namespace test } // namespace aidl } // namespace android #include #include #include #include #include namespace android { namespace aidl { namespace test { namespace trunk { BpTrunkStableTest::BpTrunkStableTest(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } std::function BpTrunkStableTest::logFunc; ::android::binder::Status BpTrunkStableTest::repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::repeatParcelable::cppClient"); BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("input", ::android::internal::ToString(input)); } auto _log_start = std::chrono::steady_clock::now(); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTrunkStableTest::TRANSACTION_repeatParcelable, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) [[unlikely]] { return ITrunkStableTest::getDefaultImpl()->repeatParcelable(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatParcelable"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::android::binder::Status BpTrunkStableTest::repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum input, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::repeatEnum::cppClient"); BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("input", ::android::internal::ToString(input)); } auto _log_start = std::chrono::steady_clock::now(); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeByte(static_cast(input)); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTrunkStableTest::TRANSACTION_repeatEnum, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) [[unlikely]] { return ITrunkStableTest::getDefaultImpl()->repeatEnum(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readByte(reinterpret_cast(_aidl_return)); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatEnum"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::android::binder::Status BpTrunkStableTest::repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& input, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::repeatUnion::cppClient"); BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("input", ::android::internal::ToString(input)); } auto _log_start = std::chrono::steady_clock::now(); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTrunkStableTest::TRANSACTION_repeatUnion, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) [[unlikely]] { return ITrunkStableTest::getDefaultImpl()->repeatUnion(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatUnion"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::android::binder::Status BpTrunkStableTest::callMyCallback(const ::android::sp<::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& cb) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::callMyCallback::cppClient"); BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("cb", ::android::internal::ToString(cb)); } auto _log_start = std::chrono::steady_clock::now(); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinder(cb); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTrunkStableTest::TRANSACTION_callMyCallback, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) [[unlikely]] { return ITrunkStableTest::getDefaultImpl()->callMyCallback(cb); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "callMyCallback"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } int32_t BpTrunkStableTest::getInterfaceVersion() { if (cached_version_ == -1) { ::android::Parcel data; ::android::Parcel reply; data.writeInterfaceToken(getInterfaceDescriptor()); ::android::status_t err = remote()->transact(BnTrunkStableTest::TRANSACTION_getInterfaceVersion, data, &reply); if (err == ::android::OK) { ::android::binder::Status _aidl_status; err = _aidl_status.readFromParcel(reply); if (err == ::android::OK && _aidl_status.isOk()) { cached_version_ = reply.readInt32(); } } } return cached_version_; } std::string BpTrunkStableTest::getInterfaceHash() { std::lock_guard lockGuard(cached_hash_mutex_); if (cached_hash_ == "-1") { ::android::Parcel data; ::android::Parcel reply; data.writeInterfaceToken(getInterfaceDescriptor()); ::android::status_t err = remote()->transact(BnTrunkStableTest::TRANSACTION_getInterfaceHash, data, &reply); if (err == ::android::OK) { ::android::binder::Status _aidl_status; err = _aidl_status.readFromParcel(reply); if (err == ::android::OK && _aidl_status.isOk()) { reply.readUtf8FromUtf16(&cached_hash_); } } } return cached_hash_; } } // namespace trunk } // namespace test } // namespace aidl } // namespace android #include #include #include #include #include namespace android { namespace aidl { namespace test { namespace trunk { BnTrunkStableTest::BnTrunkStableTest() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t BnTrunkStableTest::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnTrunkStableTest::TRANSACTION_repeatParcelable: { ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable in_input; ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::repeatParcelable::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(repeatParcelable(in_input, &_aidl_return)); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatParcelable"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTrunkStableTest::TRANSACTION_repeatEnum: { ::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input; ::android::aidl::test::trunk::ITrunkStableTest::MyEnum _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::repeatEnum::cppServer"); _aidl_ret_status = _aidl_data.readByte(reinterpret_cast(&in_input)); if (((_aidl_ret_status) != (::android::OK))) { break; } BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(repeatEnum(in_input, &_aidl_return)); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatEnum"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeByte(static_cast(_aidl_return)); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTrunkStableTest::TRANSACTION_repeatUnion: { ::android::aidl::test::trunk::ITrunkStableTest::MyUnion in_input; ::android::aidl::test::trunk::ITrunkStableTest::MyUnion _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::repeatUnion::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(repeatUnion(in_input, &_aidl_return)); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatUnion"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTrunkStableTest::TRANSACTION_callMyCallback: { ::android::sp<::android::aidl::test::trunk::ITrunkStableTest::IMyCallback> in_cb; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::callMyCallback::cppServer"); _aidl_ret_status = _aidl_data.readStrongBinder(&in_cb); if (((_aidl_ret_status) != (::android::OK))) { break; } BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_cb", ::android::internal::ToString(in_cb)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(callMyCallback(in_cb)); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "callMyCallback"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; case BnTrunkStableTest::TRANSACTION_getInterfaceVersion: { _aidl_data.checkInterface(this); _aidl_reply->writeNoException(); _aidl_reply->writeInt32(ITrunkStableTest::VERSION); } break; case BnTrunkStableTest::TRANSACTION_getInterfaceHash: { _aidl_data.checkInterface(this); _aidl_reply->writeNoException(); _aidl_reply->writeUtf8AsUtf16(ITrunkStableTest::HASH); } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } int32_t BnTrunkStableTest::getInterfaceVersion() { return ITrunkStableTest::VERSION; } std::string BnTrunkStableTest::getInterfaceHash() { return ITrunkStableTest::HASH; } std::function BnTrunkStableTest::logFunc; } // namespace trunk } // namespace test } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace test { namespace trunk { ::android::status_t ITrunkStableTest::MyParcelable::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&a); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&b); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t ITrunkStableTest::MyParcelable::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeInt32(a); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(b); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace trunk } // namespace test } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace test { namespace trunk { ::android::status_t ITrunkStableTest::MyUnion::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_tag)) != ::android::OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case a: { int32_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case b: { int32_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } } return ::android::BAD_VALUE; } ::android::status_t ITrunkStableTest::MyUnion::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(getTag())); if (_aidl_ret_status != ::android::OK) return _aidl_ret_status; switch (getTag()) { case a: return _aidl_parcel->writeInt32(get()); case b: return _aidl_parcel->writeInt32(get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace trunk } // namespace test } // namespace aidl } // namespace android #include #include namespace android { namespace aidl { namespace test { namespace trunk { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_NESTED_INTERFACE(ITrunkStableTest, MyCallback, "android.aidl.test.trunk.ITrunkStableTest.IMyCallback") } // namespace trunk } // namespace test } // namespace aidl } // namespace android #include #include #include #include #include namespace android { namespace aidl { namespace test { namespace trunk { ITrunkStableTest::BpMyCallback::BpMyCallback(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } std::function ITrunkStableTest::BpMyCallback::logFunc; ::android::binder::Status ITrunkStableTest::BpMyCallback::repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyCallback::repeatParcelable::cppClient"); ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("input", ::android::internal::ToString(input)); } auto _log_start = std::chrono::steady_clock::now(); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(ITrunkStableTest::BnMyCallback::TRANSACTION_repeatParcelable, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) [[unlikely]] { return IMyCallback::getDefaultImpl()->repeatParcelable(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatParcelable"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } ::android::binder::Status ITrunkStableTest::BpMyCallback::repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum input, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyCallback::repeatEnum::cppClient"); ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("input", ::android::internal::ToString(input)); } auto _log_start = std::chrono::steady_clock::now(); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeByte(static_cast(input)); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(ITrunkStableTest::BnMyCallback::TRANSACTION_repeatEnum, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) [[unlikely]] { return IMyCallback::getDefaultImpl()->repeatEnum(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readByte(reinterpret_cast(_aidl_return)); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatEnum"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } ::android::binder::Status ITrunkStableTest::BpMyCallback::repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& input, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyCallback::repeatUnion::cppClient"); ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("input", ::android::internal::ToString(input)); } auto _log_start = std::chrono::steady_clock::now(); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(ITrunkStableTest::BnMyCallback::TRANSACTION_repeatUnion, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) [[unlikely]] { return IMyCallback::getDefaultImpl()->repeatUnion(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatUnion"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } int32_t ITrunkStableTest::BpMyCallback::getInterfaceVersion() { if (cached_version_ == -1) { ::android::Parcel data; ::android::Parcel reply; data.writeInterfaceToken(getInterfaceDescriptor()); ::android::status_t err = remote()->transact(ITrunkStableTest::BnMyCallback::TRANSACTION_getInterfaceVersion, data, &reply); if (err == ::android::OK) { ::android::binder::Status _aidl_status; err = _aidl_status.readFromParcel(reply); if (err == ::android::OK && _aidl_status.isOk()) { cached_version_ = reply.readInt32(); } } } return cached_version_; } std::string ITrunkStableTest::BpMyCallback::getInterfaceHash() { std::lock_guard lockGuard(cached_hash_mutex_); if (cached_hash_ == "-1") { ::android::Parcel data; ::android::Parcel reply; data.writeInterfaceToken(getInterfaceDescriptor()); ::android::status_t err = remote()->transact(ITrunkStableTest::BnMyCallback::TRANSACTION_getInterfaceHash, data, &reply); if (err == ::android::OK) { ::android::binder::Status _aidl_status; err = _aidl_status.readFromParcel(reply); if (err == ::android::OK && _aidl_status.isOk()) { reply.readUtf8FromUtf16(&cached_hash_); } } } return cached_hash_; } } // namespace trunk } // namespace test } // namespace aidl } // namespace android #include #include #include #include #include namespace android { namespace aidl { namespace test { namespace trunk { ITrunkStableTest::BnMyCallback::BnMyCallback() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t ITrunkStableTest::BnMyCallback::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnMyCallback::TRANSACTION_repeatParcelable: { ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable in_input; ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyCallback::repeatParcelable::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(repeatParcelable(in_input, &_aidl_return)); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatParcelable"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnMyCallback::TRANSACTION_repeatEnum: { ::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input; ::android::aidl::test::trunk::ITrunkStableTest::MyEnum _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyCallback::repeatEnum::cppServer"); _aidl_ret_status = _aidl_data.readByte(reinterpret_cast(&in_input)); if (((_aidl_ret_status) != (::android::OK))) { break; } ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(repeatEnum(in_input, &_aidl_return)); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatEnum"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeByte(static_cast(_aidl_return)); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnMyCallback::TRANSACTION_repeatUnion: { ::android::aidl::test::trunk::ITrunkStableTest::MyUnion in_input; ::android::aidl::test::trunk::ITrunkStableTest::MyUnion _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyCallback::repeatUnion::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(repeatUnion(in_input, &_aidl_return)); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatUnion"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnMyCallback::TRANSACTION_getInterfaceVersion: { _aidl_data.checkInterface(this); _aidl_reply->writeNoException(); _aidl_reply->writeInt32(IMyCallback::VERSION); } break; case BnMyCallback::TRANSACTION_getInterfaceHash: { _aidl_data.checkInterface(this); _aidl_reply->writeNoException(); _aidl_reply->writeUtf8AsUtf16(IMyCallback::HASH); } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } int32_t ITrunkStableTest::BnMyCallback::getInterfaceVersion() { return IMyCallback::VERSION; } std::string ITrunkStableTest::BnMyCallback::getInterfaceHash() { return IMyCallback::HASH; } std::function ITrunkStableTest::BnMyCallback::logFunc; } // namespace trunk } // namespace test } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-cpp-source_ge0100644 0000000 0000000 00000000252 15172120304 033136 xustar000000000 0000000 142 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/android/aidl/test/trunk/ITrunkStableTest.cpp.d 28 mtime=1776853188.7500000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/android/aidl/t0100644 0000000 0000000 00000000433 15172120304 033032 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/android/aidl/test/trunk/ITrunkStableTest.cpp : \ system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/android/aidl/test/trunk/ITrunkStableTest.aidl ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-cpp-source_ge0100644 0000000 0000000 00000000034 15172120304 033134 xustar000000000 0000000 28 mtime=1776853188.7500000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include/0040755 0000000 0000000 00000000000 15172120304 031741 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-cpp-source_ge0100644 0000000 0000000 00000000214 15172120304 033134 xustar000000000 0000000 112 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include/android/ 28 mtime=1776853188.7500000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include/androi0040755 0000000 0000000 00000000000 15172120304 033136 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-cpp-source_ge0100644 0000000 0000000 00000000221 15172120304 033132 xustar000000000 0000000 117 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include/android/aidl/ 28 mtime=1776853188.7500000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include/androi0040755 0000000 0000000 00000000000 15172120304 033136 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-cpp-source_ge0100644 0000000 0000000 00000000226 15172120304 033137 xustar000000000 0000000 122 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include/android/aidl/test/ 28 mtime=1776853188.7500000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include/androi0040755 0000000 0000000 00000000000 15172120304 033136 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-cpp-source_ge0100644 0000000 0000000 00000000234 15172120304 033136 xustar000000000 0000000 128 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include/android/aidl/test/trunk/ 28 mtime=1776853188.7500000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include/androi0040755 0000000 0000000 00000000000 15172120304 033136 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-cpp-source_ge0100644 0000000 0000000 00000000257 15172120304 033143 xustar000000000 0000000 147 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include/android/aidl/test/trunk/BnTrunkStableTest.h 28 mtime=1776853188.7500000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include/androi0100644 0000000 0000000 00000011175 15172120304 033142 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 1 --hash 88311b9118fb6fe9eff4a2ca19121de0587f6d5f -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/staging/android/aidl/test/trunk/ITrunkStableTest.cpp.d -h out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/staging -Nsystem/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1 system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/android/aidl/test/trunk/ITrunkStableTest.aidl */ #pragma once #include #include #include #include #include #include #include namespace android { namespace aidl { namespace test { namespace trunk { class BnTrunkStableTest : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_repeatParcelable = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_repeatEnum = ::android::IBinder::FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_repeatUnion = ::android::IBinder::FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_callMyCallback = ::android::IBinder::FIRST_CALL_TRANSACTION + 3; static constexpr uint32_t TRANSACTION_getInterfaceVersion = ::android::IBinder::FIRST_CALL_TRANSACTION + 16777214; static constexpr uint32_t TRANSACTION_getInterfaceHash = ::android::IBinder::FIRST_CALL_TRANSACTION + 16777213; explicit BnTrunkStableTest(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; int32_t getInterfaceVersion(); std::string getInterfaceHash(); struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; }; // class BnTrunkStableTest class ITrunkStableTestDelegator : public BnTrunkStableTest { public: explicit ITrunkStableTestDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override { return _aidl_delegate->repeatParcelable(input, _aidl_return); } ::android::binder::Status repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum input, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override { return _aidl_delegate->repeatEnum(input, _aidl_return); } ::android::binder::Status repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& input, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override { return _aidl_delegate->repeatUnion(input, _aidl_return); } ::android::binder::Status callMyCallback(const ::android::sp<::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& cb) override { ::android::sp<::android::aidl::test::trunk::ITrunkStableTest::IMyCallbackDelegator> _cb; if (cb) { _cb = ::android::sp<::android::aidl::test::trunk::ITrunkStableTest::IMyCallbackDelegator>::cast(delegate(cb)); } return _aidl_delegate->callMyCallback(_cb); } int32_t getInterfaceVersion() override { int32_t _delegator_ver = BnTrunkStableTest::getInterfaceVersion(); int32_t _impl_ver = _aidl_delegate->getInterfaceVersion(); return _delegator_ver < _impl_ver ? _delegator_ver : _impl_ver; } std::string getInterfaceHash() override { return _aidl_delegate->getInterfaceHash(); } private: ::android::sp _aidl_delegate; }; // class ITrunkStableTestDelegator } // namespace trunk } // namespace test } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-cpp-source_ge0100644 0000000 0000000 00000000257 15172120304 033143 xustar000000000 0000000 147 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include/android/aidl/test/trunk/BpTrunkStableTest.h 28 mtime=1776853188.7510000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include/androi0100644 0000000 0000000 00000005512 15172120304 033140 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 1 --hash 88311b9118fb6fe9eff4a2ca19121de0587f6d5f -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/staging/android/aidl/test/trunk/ITrunkStableTest.cpp.d -h out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/staging -Nsystem/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1 system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/android/aidl/test/trunk/ITrunkStableTest.aidl */ #pragma once #include #include #include #include #include #include namespace android { namespace aidl { namespace test { namespace trunk { class BpTrunkStableTest : public ::android::BpInterface { public: explicit BpTrunkStableTest(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpTrunkStableTest() = default; ::android::binder::Status repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override; ::android::binder::Status repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum input, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override; ::android::binder::Status repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& input, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override; ::android::binder::Status callMyCallback(const ::android::sp<::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& cb) override; int32_t getInterfaceVersion() override; std::string getInterfaceHash() override; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; private: int32_t cached_version_ = -1; std::string cached_hash_ = "-1"; std::mutex cached_hash_mutex_; }; // class BpTrunkStableTest } // namespace trunk } // namespace test } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-cpp-source_ge0100644 0000000 0000000 00000000256 15172120304 033142 xustar000000000 0000000 146 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include/android/aidl/test/trunk/ITrunkStableTest.h 28 mtime=1776853188.7510000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include/androi0100644 0000000 0000000 00000042605 15172120304 033144 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp --structured --version 1 --hash 88311b9118fb6fe9eff4a2ca19121de0587f6d5f -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/staging/android/aidl/test/trunk/ITrunkStableTest.cpp.d -h out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/staging -Nsystem/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1 system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/android/aidl/test/trunk/ITrunkStableTest.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace android { namespace aidl { namespace test { namespace trunk { class ITrunkStableTestDelegator; class ITrunkStableTest : public ::android::IInterface { public: typedef ITrunkStableTestDelegator DefaultDelegator; DECLARE_META_INTERFACE(TrunkStableTest) static inline const int32_t VERSION = 1; static inline const std::string HASH = "88311b9118fb6fe9eff4a2ca19121de0587f6d5f"; class MyParcelable : public ::android::Parcelable { public: int32_t a = 0; int32_t b = 0; inline bool operator==(const MyParcelable& _rhs) const { return std::tie(a, b) == std::tie(_rhs.a, _rhs.b); } inline bool operator<(const MyParcelable& _rhs) const { return std::tie(a, b) < std::tie(_rhs.a, _rhs.b); } inline bool operator!=(const MyParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyParcelable& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.test.trunk.ITrunkStableTest.MyParcelable"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "MyParcelable{"; _aidl_os << "a: " << ::android::internal::ToString(a); _aidl_os << ", b: " << ::android::internal::ToString(b); _aidl_os << "}"; return _aidl_os.str(); } }; // class MyParcelable enum class MyEnum : int8_t { ZERO = 0, ONE = 1, TWO = 2, }; class MyUnion : public ::android::Parcelable { public: enum class Tag : int32_t { a = 0, b = 1, }; // Expose tag symbols for legacy code static const inline Tag a = Tag::a; static const inline Tag b = Tag::b; template static constexpr bool _not_self = !std::is_same_v>, MyUnion>; MyUnion() : _value(std::in_place_index(a)>, int32_t(0)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr MyUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit MyUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static MyUnion make(_Tp&&... _args) { return MyUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static MyUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return MyUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } inline bool operator==(const MyUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const MyUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const MyUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyUnion& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.test.trunk.ITrunkStableTest.MyUnion"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream os; os << "MyUnion{"; switch (getTag()) { case a: os << "a: " << ::android::internal::ToString(get()); break; case b: os << "b: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant _value; }; // class MyUnion class IMyCallbackDelegator; class IMyCallback : public ::android::IInterface { public: typedef IMyCallbackDelegator DefaultDelegator; DECLARE_META_INTERFACE(MyCallback) static inline const int32_t VERSION = 1; static inline const std::string HASH = "88311b9118fb6fe9eff4a2ca19121de0587f6d5f"; virtual ::android::binder::Status repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) = 0; virtual ::android::binder::Status repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum input, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) = 0; virtual ::android::binder::Status repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& input, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) = 0; virtual int32_t getInterfaceVersion() = 0; virtual std::string getInterfaceHash() = 0; }; // class IMyCallback class IMyCallbackDefault : public IMyCallback { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& /*input*/, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum /*input*/, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& /*input*/, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } int32_t getInterfaceVersion() override { return 0; } std::string getInterfaceHash() override { return ""; } }; // class IMyCallbackDefault class BpMyCallback : public ::android::BpInterface { public: explicit BpMyCallback(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpMyCallback() = default; ::android::binder::Status repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override; ::android::binder::Status repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum input, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override; ::android::binder::Status repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& input, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override; int32_t getInterfaceVersion() override; std::string getInterfaceHash() override; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; private: int32_t cached_version_ = -1; std::string cached_hash_ = "-1"; std::mutex cached_hash_mutex_; }; // class BpMyCallback class BnMyCallback : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_repeatParcelable = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_repeatEnum = ::android::IBinder::FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_repeatUnion = ::android::IBinder::FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_getInterfaceVersion = ::android::IBinder::FIRST_CALL_TRANSACTION + 16777214; static constexpr uint32_t TRANSACTION_getInterfaceHash = ::android::IBinder::FIRST_CALL_TRANSACTION + 16777213; explicit BnMyCallback(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; int32_t getInterfaceVersion(); std::string getInterfaceHash(); struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; }; // class BnMyCallback class IMyCallbackDelegator : public BnMyCallback { public: explicit IMyCallbackDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override { return _aidl_delegate->repeatParcelable(input, _aidl_return); } ::android::binder::Status repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum input, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override { return _aidl_delegate->repeatEnum(input, _aidl_return); } ::android::binder::Status repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& input, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override { return _aidl_delegate->repeatUnion(input, _aidl_return); } int32_t getInterfaceVersion() override { int32_t _delegator_ver = BnMyCallback::getInterfaceVersion(); int32_t _impl_ver = _aidl_delegate->getInterfaceVersion(); return _delegator_ver < _impl_ver ? _delegator_ver : _impl_ver; } std::string getInterfaceHash() override { return _aidl_delegate->getInterfaceHash(); } private: ::android::sp _aidl_delegate; }; // class IMyCallbackDelegator virtual ::android::binder::Status repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) = 0; virtual ::android::binder::Status repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum input, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) = 0; virtual ::android::binder::Status repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& input, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) = 0; virtual ::android::binder::Status callMyCallback(const ::android::sp<::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& cb) = 0; virtual int32_t getInterfaceVersion() = 0; virtual std::string getInterfaceHash() = 0; }; // class ITrunkStableTest class ITrunkStableTestDefault : public ITrunkStableTest { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& /*input*/, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum /*input*/, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& /*input*/, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status callMyCallback(const ::android::sp<::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& /*cb*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } int32_t getInterfaceVersion() override { return 0; } std::string getInterfaceHash() override { return ""; } }; // class ITrunkStableTestDefault } // namespace trunk } // namespace test } // namespace aidl } // namespace android namespace android { namespace aidl { namespace test { namespace trunk { [[nodiscard]] static inline std::string toString(ITrunkStableTest::MyEnum val) { switch(val) { case ITrunkStableTest::MyEnum::ZERO: return "ZERO"; case ITrunkStableTest::MyEnum::ONE: return "ONE"; case ITrunkStableTest::MyEnum::TWO: return "TWO"; default: return std::to_string(static_cast(val)); } } } // namespace trunk } // namespace test } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::test::trunk::ITrunkStableTest::MyEnum, 3> enum_values<::android::aidl::test::trunk::ITrunkStableTest::MyEnum> = { ::android::aidl::test::trunk::ITrunkStableTest::MyEnum::ZERO, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum::ONE, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum::TWO, }; #pragma clang diagnostic pop } // namespace internal } // namespace android namespace android { namespace aidl { namespace test { namespace trunk { [[nodiscard]] static inline std::string toString(ITrunkStableTest::MyUnion::Tag val) { switch(val) { case ITrunkStableTest::MyUnion::Tag::a: return "a"; case ITrunkStableTest::MyUnion::Tag::b: return "b"; default: return std::to_string(static_cast(val)); } } } // namespace trunk } // namespace test } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::test::trunk::ITrunkStableTest::MyUnion::Tag, 2> enum_values<::android::aidl::test::trunk::ITrunkStableTest::MyUnion::Tag> = { ::android::aidl::test::trunk::ITrunkStableTest::MyUnion::Tag::a, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion::Tag::b, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-cpp-source_ge0100644 0000000 0000000 00000000034 15172120304 033134 xustar000000000 0000000 28 mtime=1776853188.7520000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 032227 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-java-source_0100644 0000000 0000000 00000000034 15172120304 032757 xustar000000000 0000000 28 mtime=1776853188.7520000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/0040755 0000000 0000000 00000000000 15172120304 027704 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-java-source_g0100644 0000000 0000000 00000000034 15172120304 033126 xustar000000000 0000000 28 mtime=1776853188.7520000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/gen/0040755 0000000 0000000 00000000000 15172120304 030455 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-java-source_g0100644 0000000 0000000 00000000034 15172120304 033126 xustar000000000 0000000 28 mtime=1776853188.7520000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 032075 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-java-source_g0100644 0000000 0000000 00000000212 15172120304 033124 xustar000000000 0000000 110 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/gen/android/aidl/ 28 mtime=1776853188.7520000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 033006 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-java-source_g0100644 0000000 0000000 00000000217 15172120304 033131 xustar000000000 0000000 115 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/gen/android/aidl/test/ 28 mtime=1776853188.7520000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 033006 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-java-source_g0100644 0000000 0000000 00000000225 15172120304 033130 xustar000000000 0000000 121 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/gen/android/aidl/test/trunk/ 28 mtime=1776853188.7520000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 033006 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-java-source_g0100644 0000000 0000000 00000000252 15172120304 033130 xustar000000000 0000000 142 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/gen/android/aidl/test/trunk/ITrunkStableTest.java 28 mtime=1776853188.7520000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/gen/android/aidl/0100644 0000000 0000000 00000074457 15172120304 033026 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java --structured --version 1 --hash 88311b9118fb6fe9eff4a2ca19121de0587f6d5f -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/gen/android/aidl/test/trunk/ITrunkStableTest.java.d -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/gen -Nsystem/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1 system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/android/aidl/test/trunk/ITrunkStableTest.aidl */ package android.aidl.test.trunk; public interface ITrunkStableTest extends android.os.IInterface { /** * The version of this interface that the caller is built against. * This might be different from what {@link #getInterfaceVersion() * getInterfaceVersion} returns as that is the version of the interface * that the remote object is implementing. */ public static final int VERSION = 1; public static final String HASH = "88311b9118fb6fe9eff4a2ca19121de0587f6d5f"; /** Default implementation for ITrunkStableTest. */ public static class Default implements android.aidl.test.trunk.ITrunkStableTest { @Override public android.aidl.test.trunk.ITrunkStableTest.MyParcelable repeatParcelable(android.aidl.test.trunk.ITrunkStableTest.MyParcelable input) throws android.os.RemoteException { return null; } @Override public byte repeatEnum(byte input) throws android.os.RemoteException { return 0; } @Override public android.aidl.test.trunk.ITrunkStableTest.MyUnion repeatUnion(android.aidl.test.trunk.ITrunkStableTest.MyUnion input) throws android.os.RemoteException { return null; } @Override public void callMyCallback(android.aidl.test.trunk.ITrunkStableTest.IMyCallback cb) throws android.os.RemoteException { } @Override public int getInterfaceVersion() { return 0; } @Override public String getInterfaceHash() { return ""; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.test.trunk.ITrunkStableTest { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.test.trunk.ITrunkStableTest interface, * generating a proxy if needed. */ public static android.aidl.test.trunk.ITrunkStableTest asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.test.trunk.ITrunkStableTest))) { return ((android.aidl.test.trunk.ITrunkStableTest)iin); } return new android.aidl.test.trunk.ITrunkStableTest.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_repeatParcelable: { return "repeatParcelable"; } case TRANSACTION_repeatEnum: { return "repeatEnum"; } case TRANSACTION_repeatUnion: { return "repeatUnion"; } case TRANSACTION_callMyCallback: { return "callMyCallback"; } case TRANSACTION_getInterfaceVersion: { return "getInterfaceVersion"; } case TRANSACTION_getInterfaceHash: { return "getInterfaceHash"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } else if (code == TRANSACTION_getInterfaceVersion) { reply.writeNoException(); reply.writeInt(getInterfaceVersion()); return true; } else if (code == TRANSACTION_getInterfaceHash) { reply.writeNoException(); reply.writeString(getInterfaceHash()); return true; } switch (code) { case TRANSACTION_repeatParcelable: { android.aidl.test.trunk.ITrunkStableTest.MyParcelable _arg0; _arg0 = data.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyParcelable.CREATOR); data.enforceNoDataAvail(); android.aidl.test.trunk.ITrunkStableTest.MyParcelable _result = this.repeatParcelable(_arg0); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_repeatEnum: { byte _arg0; _arg0 = data.readByte(); data.enforceNoDataAvail(); byte _result = this.repeatEnum(_arg0); reply.writeNoException(); reply.writeByte(_result); break; } case TRANSACTION_repeatUnion: { android.aidl.test.trunk.ITrunkStableTest.MyUnion _arg0; _arg0 = data.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyUnion.CREATOR); data.enforceNoDataAvail(); android.aidl.test.trunk.ITrunkStableTest.MyUnion _result = this.repeatUnion(_arg0); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_callMyCallback: { android.aidl.test.trunk.ITrunkStableTest.IMyCallback _arg0; _arg0 = android.aidl.test.trunk.ITrunkStableTest.IMyCallback.Stub.asInterface(data.readStrongBinder()); data.enforceNoDataAvail(); this.callMyCallback(_arg0); reply.writeNoException(); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.test.trunk.ITrunkStableTest { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } private int mCachedVersion = -1; private String mCachedHash = "-1"; @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public android.aidl.test.trunk.ITrunkStableTest.MyParcelable repeatParcelable(android.aidl.test.trunk.ITrunkStableTest.MyParcelable input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.test.trunk.ITrunkStableTest.MyParcelable _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_repeatParcelable, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method repeatParcelable is unimplemented."); } _reply.readException(); _result = _reply.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyParcelable.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public byte repeatEnum(byte input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); byte _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeByte(input); boolean _status = mRemote.transact(Stub.TRANSACTION_repeatEnum, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method repeatEnum is unimplemented."); } _reply.readException(); _result = _reply.readByte(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.test.trunk.ITrunkStableTest.MyUnion repeatUnion(android.aidl.test.trunk.ITrunkStableTest.MyUnion input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.test.trunk.ITrunkStableTest.MyUnion _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_repeatUnion, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method repeatUnion is unimplemented."); } _reply.readException(); _result = _reply.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyUnion.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public void callMyCallback(android.aidl.test.trunk.ITrunkStableTest.IMyCallback cb) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeStrongInterface(cb); boolean _status = mRemote.transact(Stub.TRANSACTION_callMyCallback, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method callMyCallback is unimplemented."); } _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } @Override public int getInterfaceVersion() throws android.os.RemoteException { if (mCachedVersion == -1) { android.os.Parcel data = android.os.Parcel.obtain(asBinder()); android.os.Parcel reply = android.os.Parcel.obtain(); try { data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getInterfaceVersion, data, reply, 0); reply.readException(); mCachedVersion = reply.readInt(); } finally { reply.recycle(); data.recycle(); } } return mCachedVersion; } @Override public synchronized String getInterfaceHash() throws android.os.RemoteException { if ("-1".equals(mCachedHash)) { android.os.Parcel data = android.os.Parcel.obtain(asBinder()); android.os.Parcel reply = android.os.Parcel.obtain(); try { data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getInterfaceHash, data, reply, 0); reply.readException(); mCachedHash = reply.readString(); } finally { reply.recycle(); data.recycle(); } } return mCachedHash; } } static final int TRANSACTION_repeatParcelable = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); static final int TRANSACTION_repeatEnum = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1); static final int TRANSACTION_repeatUnion = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2); static final int TRANSACTION_callMyCallback = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3); static final int TRANSACTION_getInterfaceVersion = (android.os.IBinder.FIRST_CALL_TRANSACTION + 16777214); static final int TRANSACTION_getInterfaceHash = (android.os.IBinder.FIRST_CALL_TRANSACTION + 16777213); /** @hide */ public int getMaxTransactionId() { return 16777214; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android$aidl$test$trunk$ITrunkStableTest".replace('$', '.'); public android.aidl.test.trunk.ITrunkStableTest.MyParcelable repeatParcelable(android.aidl.test.trunk.ITrunkStableTest.MyParcelable input) throws android.os.RemoteException; public byte repeatEnum(byte input) throws android.os.RemoteException; public android.aidl.test.trunk.ITrunkStableTest.MyUnion repeatUnion(android.aidl.test.trunk.ITrunkStableTest.MyUnion input) throws android.os.RemoteException; public void callMyCallback(android.aidl.test.trunk.ITrunkStableTest.IMyCallback cb) throws android.os.RemoteException; public int getInterfaceVersion() throws android.os.RemoteException; public String getInterfaceHash() throws android.os.RemoteException; public static class MyParcelable implements android.os.Parcelable { public int a = 0; public int b = 0; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public MyParcelable createFromParcel(android.os.Parcel _aidl_source) { MyParcelable _aidl_out = new MyParcelable(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public MyParcelable[] newArray(int _aidl_size) { return new MyParcelable[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(a); _aidl_parcel.writeInt(b); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; a = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; b = _aidl_parcel.readInt(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } } public static @interface MyEnum { public static final byte ZERO = 0; public static final byte ONE = 1; public static final byte TWO = 2; } public static final class MyUnion implements android.os.Parcelable { // tags for union fields public final static int a = 0; // int a; public final static int b = 1; // int b; private int _tag; private Object _value; public MyUnion() { int _value = 0; this._tag = a; this._value = _value; } private MyUnion(android.os.Parcel _aidl_parcel) { readFromParcel(_aidl_parcel); } private MyUnion(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public int getTag() { return _tag; } // int a; public static MyUnion a(int _value) { return new MyUnion(a, _value); } public int getA() { _assertTag(a); return (int) _value; } public void setA(int _value) { _set(a, _value); } // int b; public static MyUnion b(int _value) { return new MyUnion(b, _value); } public int getB() { _assertTag(b); return (int) _value; } public void setB(int _value) { _set(b, _value); } public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public MyUnion createFromParcel(android.os.Parcel _aidl_source) { return new MyUnion(_aidl_source); } @Override public MyUnion[] newArray(int _aidl_size) { return new MyUnion[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { _aidl_parcel.writeInt(_tag); switch (_tag) { case a: _aidl_parcel.writeInt(getA()); break; case b: _aidl_parcel.writeInt(getB()); break; } } public void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_tag; _aidl_tag = _aidl_parcel.readInt(); switch (_aidl_tag) { case a: { int _aidl_value; _aidl_value = _aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } case b: { int _aidl_value; _aidl_value = _aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } } throw new IllegalArgumentException("union: unknown tag: " + _aidl_tag); } @Override public int describeContents() { int _mask = 0; switch (getTag()) { } return _mask; } private void _assertTag(int tag) { if (getTag() != tag) { throw new IllegalStateException("bad access: " + _tagString(tag) + ", " + _tagString(getTag()) + " is available."); } } private String _tagString(int _tag) { switch (_tag) { case a: return "a"; case b: return "b"; } throw new IllegalStateException("unknown field: " + _tag); } private void _set(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public static @interface Tag { public static final int a = 0; public static final int b = 1; } } public interface IMyCallback extends android.os.IInterface { /** * The version of this interface that the caller is built against. * This might be different from what {@link #getInterfaceVersion() * getInterfaceVersion} returns as that is the version of the interface * that the remote object is implementing. */ public static final int VERSION = 1; public static final String HASH = "88311b9118fb6fe9eff4a2ca19121de0587f6d5f"; /** Default implementation for IMyCallback. */ public static class Default implements android.aidl.test.trunk.ITrunkStableTest.IMyCallback { @Override public android.aidl.test.trunk.ITrunkStableTest.MyParcelable repeatParcelable(android.aidl.test.trunk.ITrunkStableTest.MyParcelable input) throws android.os.RemoteException { return null; } @Override public byte repeatEnum(byte input) throws android.os.RemoteException { return 0; } @Override public android.aidl.test.trunk.ITrunkStableTest.MyUnion repeatUnion(android.aidl.test.trunk.ITrunkStableTest.MyUnion input) throws android.os.RemoteException { return null; } @Override public int getInterfaceVersion() { return 0; } @Override public String getInterfaceHash() { return ""; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.test.trunk.ITrunkStableTest.IMyCallback { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.test.trunk.ITrunkStableTest.IMyCallback interface, * generating a proxy if needed. */ public static android.aidl.test.trunk.ITrunkStableTest.IMyCallback asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.test.trunk.ITrunkStableTest.IMyCallback))) { return ((android.aidl.test.trunk.ITrunkStableTest.IMyCallback)iin); } return new android.aidl.test.trunk.ITrunkStableTest.IMyCallback.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_repeatParcelable: { return "repeatParcelable"; } case TRANSACTION_repeatEnum: { return "repeatEnum"; } case TRANSACTION_repeatUnion: { return "repeatUnion"; } case TRANSACTION_getInterfaceVersion: { return "getInterfaceVersion"; } case TRANSACTION_getInterfaceHash: { return "getInterfaceHash"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } else if (code == TRANSACTION_getInterfaceVersion) { reply.writeNoException(); reply.writeInt(getInterfaceVersion()); return true; } else if (code == TRANSACTION_getInterfaceHash) { reply.writeNoException(); reply.writeString(getInterfaceHash()); return true; } switch (code) { case TRANSACTION_repeatParcelable: { android.aidl.test.trunk.ITrunkStableTest.MyParcelable _arg0; _arg0 = data.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyParcelable.CREATOR); data.enforceNoDataAvail(); android.aidl.test.trunk.ITrunkStableTest.MyParcelable _result = this.repeatParcelable(_arg0); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_repeatEnum: { byte _arg0; _arg0 = data.readByte(); data.enforceNoDataAvail(); byte _result = this.repeatEnum(_arg0); reply.writeNoException(); reply.writeByte(_result); break; } case TRANSACTION_repeatUnion: { android.aidl.test.trunk.ITrunkStableTest.MyUnion _arg0; _arg0 = data.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyUnion.CREATOR); data.enforceNoDataAvail(); android.aidl.test.trunk.ITrunkStableTest.MyUnion _result = this.repeatUnion(_arg0); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.test.trunk.ITrunkStableTest.IMyCallback { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } private int mCachedVersion = -1; private String mCachedHash = "-1"; @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public android.aidl.test.trunk.ITrunkStableTest.MyParcelable repeatParcelable(android.aidl.test.trunk.ITrunkStableTest.MyParcelable input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.test.trunk.ITrunkStableTest.MyParcelable _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_repeatParcelable, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method repeatParcelable is unimplemented."); } _reply.readException(); _result = _reply.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyParcelable.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public byte repeatEnum(byte input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); byte _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeByte(input); boolean _status = mRemote.transact(Stub.TRANSACTION_repeatEnum, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method repeatEnum is unimplemented."); } _reply.readException(); _result = _reply.readByte(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.test.trunk.ITrunkStableTest.MyUnion repeatUnion(android.aidl.test.trunk.ITrunkStableTest.MyUnion input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.test.trunk.ITrunkStableTest.MyUnion _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_repeatUnion, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method repeatUnion is unimplemented."); } _reply.readException(); _result = _reply.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyUnion.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int getInterfaceVersion() throws android.os.RemoteException { if (mCachedVersion == -1) { android.os.Parcel data = android.os.Parcel.obtain(asBinder()); android.os.Parcel reply = android.os.Parcel.obtain(); try { data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getInterfaceVersion, data, reply, 0); reply.readException(); mCachedVersion = reply.readInt(); } finally { reply.recycle(); data.recycle(); } } return mCachedVersion; } @Override public synchronized String getInterfaceHash() throws android.os.RemoteException { if ("-1".equals(mCachedHash)) { android.os.Parcel data = android.os.Parcel.obtain(asBinder()); android.os.Parcel reply = android.os.Parcel.obtain(); try { data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getInterfaceHash, data, reply, 0); reply.readException(); mCachedHash = reply.readString(); } finally { reply.recycle(); data.recycle(); } } return mCachedHash; } } static final int TRANSACTION_repeatParcelable = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); static final int TRANSACTION_repeatEnum = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1); static final int TRANSACTION_repeatUnion = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2); static final int TRANSACTION_getInterfaceVersion = (android.os.IBinder.FIRST_CALL_TRANSACTION + 16777214); static final int TRANSACTION_getInterfaceHash = (android.os.IBinder.FIRST_CALL_TRANSACTION + 16777213); /** @hide */ public int getMaxTransactionId() { return 16777214; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android$aidl$test$trunk$ITrunkStableTest$IMyCallback".replace('$', '.'); public android.aidl.test.trunk.ITrunkStableTest.MyParcelable repeatParcelable(android.aidl.test.trunk.ITrunkStableTest.MyParcelable input) throws android.os.RemoteException; public byte repeatEnum(byte input) throws android.os.RemoteException; public android.aidl.test.trunk.ITrunkStableTest.MyUnion repeatUnion(android.aidl.test.trunk.ITrunkStableTest.MyUnion input) throws android.os.RemoteException; public int getInterfaceVersion() throws android.os.RemoteException; public String getInterfaceHash() throws android.os.RemoteException; } } ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-java-source_g0100644 0000000 0000000 00000000254 15172120304 033132 xustar000000000 0000000 144 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/gen/android/aidl/test/trunk/ITrunkStableTest.java.d 28 mtime=1776853188.7530000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/gen/android/aidl/0100644 0000000 0000000 00000000435 15172120304 033007 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/gen/android/aidl/test/trunk/ITrunkStableTest.java : \ system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/android/aidl/test/trunk/ITrunkStableTest.aidl ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-java-source_g0100644 0000000 0000000 00000000034 15172120304 033126 xustar000000000 0000000 28 mtime=1776853188.7530000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 032366 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-source_0100644 0000000 0000000 00000000034 15172120304 032612 xustar000000000 0000000 28 mtime=1776853188.7530000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/0040755 0000000 0000000 00000000000 15172120304 027537 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-source_ge0100644 0000000 0000000 00000000034 15172120304 033126 xustar000000000 0000000 28 mtime=1776853188.7530000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/0040755 0000000 0000000 00000000000 15172120304 030310 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-source_ge0100644 0000000 0000000 00000000034 15172120304 033126 xustar000000000 0000000 28 mtime=1776853188.7530000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 031730 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-source_ge0100644 0000000 0000000 00000000034 15172120304 033126 xustar000000000 0000000 28 mtime=1776853188.7530000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 032641 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-source_ge0100644 0000000 0000000 00000000216 15172120304 033130 xustar000000000 0000000 114 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/android/aidl/test/ 28 mtime=1776853188.7530000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/android/aidl/t0040755 0000000 0000000 00000000000 15172120304 033025 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-source_ge0100644 0000000 0000000 00000000224 15172120304 033127 xustar000000000 0000000 120 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/android/aidl/test/trunk/ 28 mtime=1776853188.7530000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/android/aidl/t0040755 0000000 0000000 00000000000 15172120304 033025 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-source_ge0100644 0000000 0000000 00000000250 15172120304 033126 xustar000000000 0000000 140 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/android/aidl/test/trunk/ITrunkStableTest.cpp 28 mtime=1776853188.7530000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/android/aidl/t0100644 0000000 0000000 00000213127 15172120304 033032 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 1 --hash 88311b9118fb6fe9eff4a2ca19121de0587f6d5f -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/staging/android/aidl/test/trunk/ITrunkStableTest.cpp.d -h out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/staging -Nsystem/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1 system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/android/aidl/test/trunk/ITrunkStableTest.aidl */ #include "aidl/android/aidl/test/trunk/ITrunkStableTest.h" #include #include #include #include namespace { struct ScopedTrace { inline explicit ScopedTrace(const char* name) { ATrace_beginSection(name); } inline ~ScopedTrace() { ATrace_endSection(); } }; } // namespace namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { static binder_status_t _aidl_android_aidl_test_trunk_ITrunkStableTest_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*repeatParcelable*/): { ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable in_input; ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::repeatParcelable::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->repeatParcelable(in_input, &_aidl_return); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatParcelable"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 1 /*repeatEnum*/): { ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input; ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::repeatEnum::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->repeatEnum(in_input, &_aidl_return); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatEnum"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 2 /*repeatUnion*/): { ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion in_input; ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::repeatUnion::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->repeatUnion(in_input, &_aidl_return); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatUnion"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 3 /*callMyCallback*/): { std::shared_ptr<::aidl::android::aidl::test::trunk::ITrunkStableTest::IMyCallback> in_cb; ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::callMyCallback::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_cb); if (_aidl_ret_status != STATUS_OK) break; BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_cb", ::android::internal::ToString(in_cb)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->callMyCallback(in_cb); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "callMyCallback"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } case (FIRST_CALL_TRANSACTION + 16777214 /*getInterfaceVersion*/): { int32_t _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::getInterfaceVersion::server"); BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->getInterfaceVersion(&_aidl_return); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "getInterfaceVersion"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 16777213 /*getInterfaceHash*/): { std::string _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::getInterfaceHash::server"); BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->getInterfaceHash(&_aidl_return); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "getInterfaceHash"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_test_trunk_ITrunkStableTest_clazz = ::ndk::ICInterface::defineClass(ITrunkStableTest::descriptor, _aidl_android_aidl_test_trunk_ITrunkStableTest_onTransact); BpTrunkStableTest::BpTrunkStableTest(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} BpTrunkStableTest::~BpTrunkStableTest() {} std::function BpTrunkStableTest::logFunc; ::ndk::ScopedAStatus BpTrunkStableTest::repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::repeatParcelable::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*repeatParcelable*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) { _aidl_status = ITrunkStableTest::getDefaultImpl()->repeatParcelable(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatParcelable"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus BpTrunkStableTest::repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::repeatEnum::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 1 /*repeatEnum*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) { _aidl_status = ITrunkStableTest::getDefaultImpl()->repeatEnum(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatEnum"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus BpTrunkStableTest::repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::repeatUnion::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 2 /*repeatUnion*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) { _aidl_status = ITrunkStableTest::getDefaultImpl()->repeatUnion(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatUnion"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus BpTrunkStableTest::callMyCallback(const std::shared_ptr<::aidl::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& in_cb) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_cb", ::android::internal::ToString(in_cb)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::callMyCallback::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_cb); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 3 /*callMyCallback*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) { _aidl_status = ITrunkStableTest::getDefaultImpl()->callMyCallback(in_cb); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "callMyCallback"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus BpTrunkStableTest::getInterfaceVersion(int32_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; if (_aidl_cached_version != -1) { *_aidl_return = _aidl_cached_version; _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); return _aidl_status; } ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::getInterfaceVersion::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 16777214 /*getInterfaceVersion*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) { _aidl_status = ITrunkStableTest::getDefaultImpl()->getInterfaceVersion(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_cached_version = *_aidl_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "getInterfaceVersion"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus BpTrunkStableTest::getInterfaceHash(std::string* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; const std::lock_guard lock(_aidl_cached_hash_mutex); if (_aidl_cached_hash != "-1") { *_aidl_return = _aidl_cached_hash; _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); return _aidl_status; } ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::getInterfaceHash::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 16777213 /*getInterfaceHash*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) { _aidl_status = ITrunkStableTest::getDefaultImpl()->getInterfaceHash(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_cached_hash = *_aidl_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "getInterfaceHash"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } // Source for BnTrunkStableTest BnTrunkStableTest::BnTrunkStableTest() {} BnTrunkStableTest::~BnTrunkStableTest() {} std::function BnTrunkStableTest::logFunc; ::ndk::SpAIBinder BnTrunkStableTest::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_test_trunk_ITrunkStableTest_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } ::ndk::ScopedAStatus BnTrunkStableTest::getInterfaceVersion(int32_t* _aidl_return) { *_aidl_return = ITrunkStableTest::version; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::ScopedAStatus BnTrunkStableTest::getInterfaceHash(std::string* _aidl_return) { *_aidl_return = ITrunkStableTest::hash; return ::ndk::ScopedAStatus(AStatus_newOk()); } // Source for ITrunkStableTest const char* ITrunkStableTest::descriptor = "android.aidl.test.trunk.ITrunkStableTest"; ITrunkStableTest::ITrunkStableTest() {} ITrunkStableTest::~ITrunkStableTest() {} std::shared_ptr ITrunkStableTest::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_test_trunk_ITrunkStableTest_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t ITrunkStableTest::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t ITrunkStableTest::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = ITrunkStableTest::fromBinder(binder); return STATUS_OK; } bool ITrunkStableTest::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!ITrunkStableTest::default_impl); if (impl) { ITrunkStableTest::default_impl = impl; return true; } return false; } const std::shared_ptr& ITrunkStableTest::getDefaultImpl() { return ITrunkStableTest::default_impl; } std::shared_ptr ITrunkStableTest::default_impl = nullptr; ::ndk::ScopedAStatus ITrunkStableTestDefault::repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& /*in_input*/, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTestDefault::repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum /*in_input*/, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTestDefault::repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& /*in_input*/, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTestDefault::callMyCallback(const std::shared_ptr<::aidl::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& /*in_cb*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTestDefault::getInterfaceVersion(int32_t* _aidl_return) { *_aidl_return = 0; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::ScopedAStatus ITrunkStableTestDefault::getInterfaceHash(std::string* _aidl_return) { *_aidl_return = ""; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::SpAIBinder ITrunkStableTestDefault::asBinder() { return ::ndk::SpAIBinder(); } bool ITrunkStableTestDefault::isRemote() { return false; } } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { const char* ITrunkStableTest::MyParcelable::descriptor = "android.aidl.test.trunk.ITrunkStableTest.MyParcelable"; binder_status_t ITrunkStableTest::MyParcelable::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &a); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &b); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t ITrunkStableTest::MyParcelable::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, a); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, b); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { const char* ITrunkStableTest::MyUnion::descriptor = "android.aidl.test.trunk.ITrunkStableTest.MyUnion"; binder_status_t ITrunkStableTest::MyUnion::readFromParcel(const AParcel* _parcel) { binder_status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_tag)) != STATUS_OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case a: { int32_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case b: { int32_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } } return STATUS_BAD_VALUE; } binder_status_t ITrunkStableTest::MyUnion::writeToParcel(AParcel* _parcel) const { binder_status_t _aidl_ret_status = ::ndk::AParcel_writeData(_parcel, static_cast(getTag())); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; switch (getTag()) { case a: return ::ndk::AParcel_writeData(_parcel, get()); case b: return ::ndk::AParcel_writeData(_parcel, get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { static binder_status_t _aidl_android_aidl_test_trunk_ITrunkStableTest_IMyCallback_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*repeatParcelable*/): { ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable in_input; ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::repeatParcelable::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->repeatParcelable(in_input, &_aidl_return); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatParcelable"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 1 /*repeatEnum*/): { ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input; ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::repeatEnum::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->repeatEnum(in_input, &_aidl_return); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatEnum"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 2 /*repeatUnion*/): { ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion in_input; ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::repeatUnion::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->repeatUnion(in_input, &_aidl_return); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatUnion"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 16777214 /*getInterfaceVersion*/): { int32_t _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::getInterfaceVersion::server"); ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->getInterfaceVersion(&_aidl_return); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "getInterfaceVersion"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 16777213 /*getInterfaceHash*/): { std::string _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::getInterfaceHash::server"); ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->getInterfaceHash(&_aidl_return); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "getInterfaceHash"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_test_trunk_ITrunkStableTest_IMyCallback_clazz = ::ndk::ICInterface::defineClass(ITrunkStableTest::IMyCallback::descriptor, _aidl_android_aidl_test_trunk_ITrunkStableTest_IMyCallback_onTransact); ITrunkStableTest::BpMyCallback::BpMyCallback(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} ITrunkStableTest::BpMyCallback::~BpMyCallback() {} std::function ITrunkStableTest::BpMyCallback::logFunc; ::ndk::ScopedAStatus ITrunkStableTest::BpMyCallback::repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::repeatParcelable::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*repeatParcelable*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) { _aidl_status = IMyCallback::getDefaultImpl()->repeatParcelable(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatParcelable"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTest::BpMyCallback::repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::repeatEnum::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 1 /*repeatEnum*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) { _aidl_status = IMyCallback::getDefaultImpl()->repeatEnum(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatEnum"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTest::BpMyCallback::repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::repeatUnion::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 2 /*repeatUnion*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) { _aidl_status = IMyCallback::getDefaultImpl()->repeatUnion(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatUnion"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTest::BpMyCallback::getInterfaceVersion(int32_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; if (_aidl_cached_version != -1) { *_aidl_return = _aidl_cached_version; _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); return _aidl_status; } ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::getInterfaceVersion::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 16777214 /*getInterfaceVersion*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) { _aidl_status = IMyCallback::getDefaultImpl()->getInterfaceVersion(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_cached_version = *_aidl_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "getInterfaceVersion"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTest::BpMyCallback::getInterfaceHash(std::string* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; const std::lock_guard lock(_aidl_cached_hash_mutex); if (_aidl_cached_hash != "-1") { *_aidl_return = _aidl_cached_hash; _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); return _aidl_status; } ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::getInterfaceHash::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 16777213 /*getInterfaceHash*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) { _aidl_status = IMyCallback::getDefaultImpl()->getInterfaceHash(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_cached_hash = *_aidl_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "getInterfaceHash"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } // Source for BnMyCallback ITrunkStableTest::BnMyCallback::BnMyCallback() {} ITrunkStableTest::BnMyCallback::~BnMyCallback() {} std::function ITrunkStableTest::BnMyCallback::logFunc; ::ndk::SpAIBinder ITrunkStableTest::BnMyCallback::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_test_trunk_ITrunkStableTest_IMyCallback_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } ::ndk::ScopedAStatus ITrunkStableTest::BnMyCallback::getInterfaceVersion(int32_t* _aidl_return) { *_aidl_return = IMyCallback::version; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::ScopedAStatus ITrunkStableTest::BnMyCallback::getInterfaceHash(std::string* _aidl_return) { *_aidl_return = IMyCallback::hash; return ::ndk::ScopedAStatus(AStatus_newOk()); } // Source for IMyCallback const char* ITrunkStableTest::IMyCallback::descriptor = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; ITrunkStableTest::IMyCallback::IMyCallback() {} ITrunkStableTest::IMyCallback::~IMyCallback() {} std::shared_ptr ITrunkStableTest::IMyCallback::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_test_trunk_ITrunkStableTest_IMyCallback_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t ITrunkStableTest::IMyCallback::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t ITrunkStableTest::IMyCallback::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = IMyCallback::fromBinder(binder); return STATUS_OK; } bool ITrunkStableTest::IMyCallback::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!IMyCallback::default_impl); if (impl) { IMyCallback::default_impl = impl; return true; } return false; } const std::shared_ptr& ITrunkStableTest::IMyCallback::getDefaultImpl() { return IMyCallback::default_impl; } std::shared_ptr ITrunkStableTest::IMyCallback::default_impl = nullptr; ::ndk::ScopedAStatus ITrunkStableTest::IMyCallbackDefault::repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& /*in_input*/, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTest::IMyCallbackDefault::repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum /*in_input*/, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTest::IMyCallbackDefault::repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& /*in_input*/, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTest::IMyCallbackDefault::getInterfaceVersion(int32_t* _aidl_return) { *_aidl_return = 0; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::ScopedAStatus ITrunkStableTest::IMyCallbackDefault::getInterfaceHash(std::string* _aidl_return) { *_aidl_return = ""; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::SpAIBinder ITrunkStableTest::IMyCallbackDefault::asBinder() { return ::ndk::SpAIBinder(); } bool ITrunkStableTest::IMyCallbackDefault::isRemote() { return false; } } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-source_ge0100644 0000000 0000000 00000000252 15172120304 033130 xustar000000000 0000000 142 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/android/aidl/test/trunk/ITrunkStableTest.cpp.d 28 mtime=1776853188.7540000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/android/aidl/t0100644 0000000 0000000 00000000433 15172120304 033024 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/android/aidl/test/trunk/ITrunkStableTest.cpp : \ system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/android/aidl/test/trunk/ITrunkStableTest.aidl ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-source_ge0100644 0000000 0000000 00000000034 15172120304 033126 xustar000000000 0000000 28 mtime=1776853188.7540000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include/0040755 0000000 0000000 00000000000 15172120304 031733 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-source_ge0100644 0000000 0000000 00000000034 15172120304 033126 xustar000000000 0000000 28 mtime=1776853188.7540000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include/aidl/0040755 0000000 0000000 00000000000 15172120304 032644 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-source_ge0100644 0000000 0000000 00000000221 15172120304 033124 xustar000000000 0000000 117 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include/aidl/android/ 28 mtime=1776853188.7540000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include/aidl/a0040755 0000000 0000000 00000000000 15172120304 033005 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-source_ge0100644 0000000 0000000 00000000226 15172120304 033131 xustar000000000 0000000 122 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include/aidl/android/aidl/ 28 mtime=1776853188.7540000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include/aidl/a0040755 0000000 0000000 00000000000 15172120304 033005 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-source_ge0100644 0000000 0000000 00000000233 15172120304 033127 xustar000000000 0000000 127 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include/aidl/android/aidl/test/ 28 mtime=1776853188.7550000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include/aidl/a0040755 0000000 0000000 00000000000 15172120304 033005 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-source_ge0100644 0000000 0000000 00000000241 15172120304 033126 xustar000000000 0000000 133 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include/aidl/android/aidl/test/trunk/ 28 mtime=1776853188.7550000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include/aidl/a0040755 0000000 0000000 00000000000 15172120304 033005 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-source_ge0100644 0000000 0000000 00000000264 15172120304 033133 xustar000000000 0000000 152 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include/aidl/android/aidl/test/trunk/BnTrunkStableTest.h 28 mtime=1776853188.7550000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include/aidl/a0100644 0000000 0000000 00000007256 15172120304 033016 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 1 --hash 88311b9118fb6fe9eff4a2ca19121de0587f6d5f -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/staging/android/aidl/test/trunk/ITrunkStableTest.cpp.d -h out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/staging -Nsystem/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1 system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/android/aidl/test/trunk/ITrunkStableTest.aidl */ #pragma once #include "aidl/android/aidl/test/trunk/ITrunkStableTest.h" #include #include #ifndef __BIONIC__ #ifndef __assert2 #define __assert2(a,b,c,d) ((void)0) #endif #endif namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { class BnTrunkStableTest : public ::ndk::BnCInterface { public: BnTrunkStableTest(); virtual ~BnTrunkStableTest(); ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) final; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) final; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; protected: ::ndk::SpAIBinder createBinder() override; private: }; class ITrunkStableTestDelegator : public BnTrunkStableTest { public: explicit ITrunkStableTestDelegator(const std::shared_ptr &impl) : _impl(impl) { int32_t _impl_ver = 0; if (!impl->getInterfaceVersion(&_impl_ver).isOk()) {; __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Delegator failed to get version of the implementation."); } if (_impl_ver != ITrunkStableTest::version) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Mismatched versions of delegator and implementation is not allowed."); } } ::ndk::ScopedAStatus repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override { return _impl->repeatParcelable(in_input, _aidl_return); } ::ndk::ScopedAStatus repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override { return _impl->repeatEnum(in_input, _aidl_return); } ::ndk::ScopedAStatus repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override { return _impl->repeatUnion(in_input, _aidl_return); } ::ndk::ScopedAStatus callMyCallback(const std::shared_ptr<::aidl::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& in_cb) override { return _impl->callMyCallback(in_cb); } protected: private: std::shared_ptr _impl; }; } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-source_ge0100644 0000000 0000000 00000000264 15172120304 033133 xustar000000000 0000000 152 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include/aidl/android/aidl/test/trunk/BpTrunkStableTest.h 28 mtime=1776853188.7550000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include/aidl/a0100644 0000000 0000000 00000005621 15172120304 033010 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 1 --hash 88311b9118fb6fe9eff4a2ca19121de0587f6d5f -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/staging/android/aidl/test/trunk/ITrunkStableTest.cpp.d -h out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/staging -Nsystem/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1 system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/android/aidl/test/trunk/ITrunkStableTest.aidl */ #pragma once #include "aidl/android/aidl/test/trunk/ITrunkStableTest.h" #include #include #include #include #include namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { class BpTrunkStableTest : public ::ndk::BpCInterface { public: explicit BpTrunkStableTest(const ::ndk::SpAIBinder& binder); virtual ~BpTrunkStableTest(); ::ndk::ScopedAStatus repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override; ::ndk::ScopedAStatus repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override; ::ndk::ScopedAStatus repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override; ::ndk::ScopedAStatus callMyCallback(const std::shared_ptr<::aidl::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& in_cb) override; ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) override; int32_t _aidl_cached_version = -1; std::string _aidl_cached_hash = "-1"; std::mutex _aidl_cached_hash_mutex; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; }; } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-source_ge0100644 0000000 0000000 00000000263 15172120304 033132 xustar000000000 0000000 151 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include/aidl/android/aidl/test/trunk/ITrunkStableTest.h 28 mtime=1776853188.7550000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include/aidl/a0100644 0000000 0000000 00000041116 15172120304 033007 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk --structured --version 1 --hash 88311b9118fb6fe9eff4a2ca19121de0587f6d5f -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/staging/android/aidl/test/trunk/ITrunkStableTest.cpp.d -h out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/staging -Nsystem/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1 system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/android/aidl/test/trunk/ITrunkStableTest.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { class ITrunkStableTestDelegator; class ITrunkStableTest : public ::ndk::ICInterface { public: typedef ITrunkStableTestDelegator DefaultDelegator; static const char* descriptor; ITrunkStableTest(); virtual ~ITrunkStableTest(); class MyParcelable { public: typedef std::false_type fixed_size; static const char* descriptor; int32_t a = 0; int32_t b = 0; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const MyParcelable& _rhs) const { return std::tie(a, b) == std::tie(_rhs.a, _rhs.b); } inline bool operator<(const MyParcelable& _rhs) const { return std::tie(a, b) < std::tie(_rhs.a, _rhs.b); } inline bool operator!=(const MyParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyParcelable& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "MyParcelable{"; _aidl_os << "a: " << ::android::internal::ToString(a); _aidl_os << ", b: " << ::android::internal::ToString(b); _aidl_os << "}"; return _aidl_os.str(); } }; enum class MyEnum : int8_t { ZERO = 0, ONE = 1, TWO = 2, }; class MyUnion { public: typedef std::false_type fixed_size; static const char* descriptor; enum class Tag : int32_t { a = 0, b = 1, }; // Expose tag symbols for legacy code static const inline Tag a = Tag::a; static const inline Tag b = Tag::b; template static constexpr bool _not_self = !std::is_same_v>, MyUnion>; MyUnion() : _value(std::in_place_index(a)>, int32_t(0)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr MyUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit MyUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static MyUnion make(_Tp&&... _args) { return MyUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static MyUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return MyUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } binder_status_t readFromParcel(const AParcel* _parcel); binder_status_t writeToParcel(AParcel* _parcel) const; inline bool operator==(const MyUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const MyUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const MyUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyUnion& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream os; os << "MyUnion{"; switch (getTag()) { case a: os << "a: " << ::android::internal::ToString(get()); break; case b: os << "b: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant _value; }; class IMyCallbackDelegator; class IMyCallback : public ::ndk::ICInterface { public: typedef IMyCallbackDelegator DefaultDelegator; static const char* descriptor; IMyCallback(); virtual ~IMyCallback(); static inline const int32_t version = 1; static inline const std::string hash = "88311b9118fb6fe9eff4a2ca19121de0587f6d5f"; static constexpr uint32_t TRANSACTION_repeatParcelable = FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_repeatEnum = FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_repeatUnion = FIRST_CALL_TRANSACTION + 2; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) = 0; virtual ::ndk::ScopedAStatus repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) = 0; virtual ::ndk::ScopedAStatus repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) = 0; virtual ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) = 0; private: static std::shared_ptr default_impl; }; class IMyCallbackDefault : public IMyCallback { public: ::ndk::ScopedAStatus repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override; ::ndk::ScopedAStatus repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override; ::ndk::ScopedAStatus repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; class BpMyCallback : public ::ndk::BpCInterface { public: explicit BpMyCallback(const ::ndk::SpAIBinder& binder); virtual ~BpMyCallback(); ::ndk::ScopedAStatus repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override; ::ndk::ScopedAStatus repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override; ::ndk::ScopedAStatus repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) override; int32_t _aidl_cached_version = -1; std::string _aidl_cached_hash = "-1"; std::mutex _aidl_cached_hash_mutex; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; }; class BnMyCallback : public ::ndk::BnCInterface { public: BnMyCallback(); virtual ~BnMyCallback(); ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) final; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) final; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; protected: ::ndk::SpAIBinder createBinder() override; private: }; static inline const int32_t version = 1; static inline const std::string hash = "88311b9118fb6fe9eff4a2ca19121de0587f6d5f"; static constexpr uint32_t TRANSACTION_repeatParcelable = FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_repeatEnum = FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_repeatUnion = FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_callMyCallback = FIRST_CALL_TRANSACTION + 3; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) = 0; virtual ::ndk::ScopedAStatus repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) = 0; virtual ::ndk::ScopedAStatus repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) = 0; virtual ::ndk::ScopedAStatus callMyCallback(const std::shared_ptr<::aidl::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& in_cb) = 0; virtual ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) = 0; private: static std::shared_ptr default_impl; }; class ITrunkStableTestDefault : public ITrunkStableTest { public: ::ndk::ScopedAStatus repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override; ::ndk::ScopedAStatus repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override; ::ndk::ScopedAStatus repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override; ::ndk::ScopedAStatus callMyCallback(const std::shared_ptr<::aidl::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& in_cb) override; ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { [[nodiscard]] static inline std::string toString(ITrunkStableTest::MyEnum val) { switch(val) { case ITrunkStableTest::MyEnum::ZERO: return "ZERO"; case ITrunkStableTest::MyEnum::ONE: return "ONE"; case ITrunkStableTest::MyEnum::TWO: return "TWO"; default: return std::to_string(static_cast(val)); } } } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum::ZERO, aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum::ONE, aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum::TWO, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { [[nodiscard]] static inline std::string toString(ITrunkStableTest::MyUnion::Tag val) { switch(val) { case ITrunkStableTest::MyUnion::Tag::a: return "a"; case ITrunkStableTest::MyUnion::Tag::b: return "b"; default: return std::to_string(static_cast(val)); } } } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion::Tag::a, aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion::Tag::b, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-ndk-source_ge0100644 0000000 0000000 00000000034 15172120304 033126 xustar000000000 0000000 28 mtime=1776853188.7550000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 032221 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-rust-source_0100644 0000000 0000000 00000000034 15172120304 033033 xustar000000000 0000000 28 mtime=1776853188.7550000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/0040755 0000000 0000000 00000000000 15172120304 027760 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-rust-source_g0100644 0000000 0000000 00000000034 15172120304 033202 xustar000000000 0000000 28 mtime=1776853188.7550000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/gen/0040755 0000000 0000000 00000000000 15172120304 030531 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-rust-source_g0100644 0000000 0000000 00000000034 15172120304 033202 xustar000000000 0000000 28 mtime=1776853188.7550000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 032151 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-rust-source_g0100644 0000000 0000000 00000000212 15172120304 033200 xustar000000000 0000000 110 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/gen/android/aidl/ 28 mtime=1776853188.7550000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 033062 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-rust-source_g0100644 0000000 0000000 00000000217 15172120304 033205 xustar000000000 0000000 115 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/gen/android/aidl/test/ 28 mtime=1776853188.7560000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 033062 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-rust-source_g0100644 0000000 0000000 00000000225 15172120304 033204 xustar000000000 0000000 121 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/gen/android/aidl/test/trunk/ 28 mtime=1776853188.7560000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 033062 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-rust-source_g0100644 0000000 0000000 00000000250 15172120304 033202 xustar000000000 0000000 140 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/gen/android/aidl/test/trunk/ITrunkStableTest.rs 28 mtime=1776853188.7560000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/gen/android/aidl/0100644 0000000 0000000 00000150751 15172120304 033072 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust --structured --version 1 --hash 88311b9118fb6fe9eff4a2ca19121de0587f6d5f --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/gen/android/aidl/test/trunk/ITrunkStableTest.rs.d -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/gen -Nsystem/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1 system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/android/aidl/test/trunk/ITrunkStableTest.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { ITrunkStableTest["android.aidl.test.trunk.ITrunkStableTest"] { native: BnTrunkStableTest(on_transact), proxy: BpTrunkStableTest { cached_version: std::sync::atomic::AtomicI32 = std::sync::atomic::AtomicI32::new(-1), cached_hash: std::sync::Mutex> = std::sync::Mutex::new(None) }, async: ITrunkStableTestAsync, } } pub trait ITrunkStableTest: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.test.trunk.ITrunkStableTest" } fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result; fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result; fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result; fn r#callMyCallback(&self, _arg_cb: &binder::Strong) -> binder::Result<()>; fn r#getInterfaceVersion(&self) -> binder::Result { Ok(VERSION) } fn r#getInterfaceHash(&self) -> binder::Result { Ok(HASH.into()) } fn getDefaultImpl() -> ITrunkStableTestDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: ITrunkStableTestDefaultRef) -> ITrunkStableTestDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait ITrunkStableTestAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.test.trunk.ITrunkStableTest" } fn r#repeatParcelable<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::BoxFuture<'a, binder::Result>; fn r#repeatEnum<'a>(&'a self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::BoxFuture<'a, binder::Result>; fn r#repeatUnion<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::BoxFuture<'a, binder::Result>; fn r#callMyCallback<'a>(&'a self, _arg_cb: &'a binder::Strong) -> binder::BoxFuture<'a, binder::Result<()>>; fn r#getInterfaceVersion<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { Box::pin(async move { Ok(VERSION) }) } fn r#getInterfaceHash<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { Box::pin(async move { Ok(HASH.into()) }) } } #[::async_trait::async_trait] pub trait ITrunkStableTestAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.test.trunk.ITrunkStableTest" } async fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result; async fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result; async fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result; async fn r#callMyCallback(&self, _arg_cb: &binder::Strong) -> binder::Result<()>; } impl BnTrunkStableTest { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: ITrunkStableTestAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl ITrunkStableTest for Wrapper where T: ITrunkStableTestAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { self._rt.block_on(self._inner.r#repeatParcelable(_arg_input)) } fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { self._rt.block_on(self._inner.r#repeatEnum(_arg_input)) } fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { self._rt.block_on(self._inner.r#repeatUnion(_arg_input)) } fn r#callMyCallback(&self, _arg_cb: &binder::Strong) -> binder::Result<()> { self._rt.block_on(self._inner.r#callMyCallback(_arg_cb)) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait ITrunkStableTestDefault: Send + Sync { fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#callMyCallback(&self, _arg_cb: &binder::Strong) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#repeatParcelable: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; pub const r#repeatEnum: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 1; pub const r#repeatUnion: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 2; pub const r#callMyCallback: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 3; pub const r#getInterfaceVersion: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 16777214; pub const r#getInterfaceHash: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 16777213; } pub type ITrunkStableTestDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); pub const VERSION: i32 = 1; pub const HASH: &str = "88311b9118fb6fe9eff4a2ca19121de0587f6d5f"; impl BpTrunkStableTest { fn build_parcel_repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#repeatParcelable(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(&_arg_input)?; Ok(aidl_data) } fn read_response_repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#repeatEnum(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#repeatUnion(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_callMyCallback(&self, _arg_cb: &binder::Strong) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_cb)?; Ok(aidl_data) } fn read_response_callMyCallback(&self, _arg_cb: &binder::Strong, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#callMyCallback(_arg_cb); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } Ok(()) } fn build_parcel_getInterfaceVersion(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_getInterfaceVersion(&self, _aidl_reply: std::result::Result) -> binder::Result { let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: i32 = _aidl_reply.read()?; self.cached_version.store(_aidl_return, std::sync::atomic::Ordering::Relaxed); Ok(_aidl_return) } fn build_parcel_getInterfaceHash(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_getInterfaceHash(&self, _aidl_reply: std::result::Result) -> binder::Result { let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: String = _aidl_reply.read()?; *self.cached_hash.lock().unwrap() = Some(_aidl_return.clone()); Ok(_aidl_return) } } impl ITrunkStableTest for BpTrunkStableTest { fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { let _aidl_data = self.build_parcel_repeatParcelable(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#repeatParcelable, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_repeatParcelable(_arg_input, _aidl_reply) } fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { let _aidl_data = self.build_parcel_repeatEnum(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#repeatEnum, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_repeatEnum(_arg_input, _aidl_reply) } fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { let _aidl_data = self.build_parcel_repeatUnion(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#repeatUnion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_repeatUnion(_arg_input, _aidl_reply) } fn r#callMyCallback(&self, _arg_cb: &binder::Strong) -> binder::Result<()> { let _aidl_data = self.build_parcel_callMyCallback(_arg_cb)?; let _aidl_reply = self.binder.submit_transact(transactions::r#callMyCallback, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_callMyCallback(_arg_cb, _aidl_reply) } fn r#getInterfaceVersion(&self) -> binder::Result { let _aidl_version = self.cached_version.load(std::sync::atomic::Ordering::Relaxed); if _aidl_version != -1 { return Ok(_aidl_version); } let _aidl_data = self.build_parcel_getInterfaceVersion()?; let _aidl_reply = self.binder.submit_transact(transactions::r#getInterfaceVersion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_getInterfaceVersion(_aidl_reply) } fn r#getInterfaceHash(&self) -> binder::Result { { let _aidl_hash_lock = self.cached_hash.lock().unwrap(); if let Some(ref _aidl_hash) = *_aidl_hash_lock { return Ok(_aidl_hash.clone()); } } let _aidl_data = self.build_parcel_getInterfaceHash()?; let _aidl_reply = self.binder.submit_transact(transactions::r#getInterfaceHash, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_getInterfaceHash(_aidl_reply) } } impl ITrunkStableTestAsync

for BpTrunkStableTest { fn r#repeatParcelable<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_repeatParcelable(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#repeatParcelable, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_repeatParcelable(_arg_input, _aidl_reply) } ) } fn r#repeatEnum<'a>(&'a self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_repeatEnum(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#repeatEnum, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_repeatEnum(_arg_input, _aidl_reply) } ) } fn r#repeatUnion<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_repeatUnion(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#repeatUnion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_repeatUnion(_arg_input, _aidl_reply) } ) } fn r#callMyCallback<'a>(&'a self, _arg_cb: &'a binder::Strong) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_callMyCallback(_arg_cb) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#callMyCallback, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_callMyCallback(_arg_cb, _aidl_reply) } ) } fn r#getInterfaceVersion<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { let _aidl_version = self.cached_version.load(std::sync::atomic::Ordering::Relaxed); if _aidl_version != -1 { return Box::pin(std::future::ready(Ok(_aidl_version))); } let _aidl_data = match self.build_parcel_getInterfaceVersion() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#getInterfaceVersion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_getInterfaceVersion(_aidl_reply) } ) } fn r#getInterfaceHash<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { { let _aidl_hash_lock = self.cached_hash.lock().unwrap(); if let Some(ref _aidl_hash) = *_aidl_hash_lock { return Box::pin(std::future::ready(Ok(_aidl_hash.clone()))); } } let _aidl_data = match self.build_parcel_getInterfaceHash() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#getInterfaceHash, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_getInterfaceHash(_aidl_reply) } ) } } impl ITrunkStableTest for binder::binder_impl::Binder { fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { self.0.r#repeatParcelable(_arg_input) } fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { self.0.r#repeatEnum(_arg_input) } fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { self.0.r#repeatUnion(_arg_input) } fn r#callMyCallback(&self, _arg_cb: &binder::Strong) -> binder::Result<()> { self.0.r#callMyCallback(_arg_cb) } fn r#getInterfaceVersion(&self) -> binder::Result { self.0.r#getInterfaceVersion() } fn r#getInterfaceHash(&self) -> binder::Result { self.0.r#getInterfaceHash() } } fn on_transact(_aidl_service: &dyn ITrunkStableTest, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#repeatParcelable => { let _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable = _aidl_data.read()?; let _aidl_return = _aidl_service.r#repeatParcelable(&_arg_input); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#repeatEnum => { let _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum = _aidl_data.read()?; let _aidl_return = _aidl_service.r#repeatEnum(_arg_input); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#repeatUnion => { let _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion = _aidl_data.read()?; let _aidl_return = _aidl_service.r#repeatUnion(&_arg_input); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#callMyCallback => { let _arg_cb: binder::Strong = _aidl_data.read()?; let _aidl_return = _aidl_service.r#callMyCallback(&_arg_cb); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#getInterfaceVersion => { let _aidl_return = _aidl_service.r#getInterfaceVersion(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#getInterfaceHash => { let _aidl_return = _aidl_service.r#getInterfaceHash(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } pub mod r#MyParcelable { #[derive(Debug)] pub struct r#MyParcelable { pub r#a: i32, pub r#b: i32, } impl Default for r#MyParcelable { fn default() -> Self { Self { r#a: 0, r#b: 0, } } } impl binder::Parcelable for r#MyParcelable { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#a)?; subparcel.write(&self.r#b)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#a = subparcel.read()?; } if subparcel.has_more_data() { self.r#b = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#MyParcelable); binder::impl_deserialize_for_parcelable!(r#MyParcelable); impl binder::binder_impl::ParcelableMetadata for r#MyParcelable { fn get_descriptor() -> &'static str { "android.aidl.test.trunk.ITrunkStableTest.MyParcelable" } } } pub mod r#MyEnum { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#MyEnum : [i8; 3] { r#ZERO = 0, r#ONE = 1, r#TWO = 2, } } } pub mod r#MyUnion { #[derive(Debug)] pub enum r#MyUnion { A(i32), B(i32), } impl Default for r#MyUnion { fn default() -> Self { Self::A(0) } } impl binder::Parcelable for r#MyUnion { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { match self { Self::A(v) => { parcel.write(&0i32)?; parcel.write(v) } Self::B(v) => { parcel.write(&1i32)?; parcel.write(v) } } } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { let tag: i32 = parcel.read()?; match tag { 0 => { let value: i32 = parcel.read()?; *self = Self::A(value); Ok(()) } 1 => { let value: i32 = parcel.read()?; *self = Self::B(value); Ok(()) } _ => { Err(binder::StatusCode::BAD_VALUE) } } } } binder::impl_serialize_for_parcelable!(r#MyUnion); binder::impl_deserialize_for_parcelable!(r#MyUnion); impl binder::binder_impl::ParcelableMetadata for r#MyUnion { fn get_descriptor() -> &'static str { "android.aidl.test.trunk.ITrunkStableTest.MyUnion" } } pub mod r#Tag { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#Tag : [i32; 2] { r#a = 0, r#b = 1, } } } } pub mod r#IMyCallback { #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { IMyCallback["android.aidl.test.trunk.ITrunkStableTest.IMyCallback"] { native: BnMyCallback(on_transact), proxy: BpMyCallback { cached_version: std::sync::atomic::AtomicI32 = std::sync::atomic::AtomicI32::new(-1), cached_hash: std::sync::Mutex> = std::sync::Mutex::new(None) }, async: IMyCallbackAsync, } } pub trait IMyCallback: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.test.trunk.ITrunkStableTest.IMyCallback" } fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result; fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result; fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result; fn r#getInterfaceVersion(&self) -> binder::Result { Ok(VERSION) } fn r#getInterfaceHash(&self) -> binder::Result { Ok(HASH.into()) } fn getDefaultImpl() -> IMyCallbackDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: IMyCallbackDefaultRef) -> IMyCallbackDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait IMyCallbackAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.test.trunk.ITrunkStableTest.IMyCallback" } fn r#repeatParcelable<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::BoxFuture<'a, binder::Result>; fn r#repeatEnum<'a>(&'a self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::BoxFuture<'a, binder::Result>; fn r#repeatUnion<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::BoxFuture<'a, binder::Result>; fn r#getInterfaceVersion<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { Box::pin(async move { Ok(VERSION) }) } fn r#getInterfaceHash<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { Box::pin(async move { Ok(HASH.into()) }) } } #[::async_trait::async_trait] pub trait IMyCallbackAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.test.trunk.ITrunkStableTest.IMyCallback" } async fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result; async fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result; async fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result; } impl BnMyCallback { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: IMyCallbackAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl IMyCallback for Wrapper where T: IMyCallbackAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { self._rt.block_on(self._inner.r#repeatParcelable(_arg_input)) } fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { self._rt.block_on(self._inner.r#repeatEnum(_arg_input)) } fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { self._rt.block_on(self._inner.r#repeatUnion(_arg_input)) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait IMyCallbackDefault: Send + Sync { fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#repeatParcelable: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; pub const r#repeatEnum: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 1; pub const r#repeatUnion: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 2; pub const r#getInterfaceVersion: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 16777214; pub const r#getInterfaceHash: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 16777213; } pub type IMyCallbackDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); pub const VERSION: i32 = 1; pub const HASH: &str = "88311b9118fb6fe9eff4a2ca19121de0587f6d5f"; impl BpMyCallback { fn build_parcel_repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#repeatParcelable(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(&_arg_input)?; Ok(aidl_data) } fn read_response_repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#repeatEnum(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#repeatUnion(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_getInterfaceVersion(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_getInterfaceVersion(&self, _aidl_reply: std::result::Result) -> binder::Result { let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: i32 = _aidl_reply.read()?; self.cached_version.store(_aidl_return, std::sync::atomic::Ordering::Relaxed); Ok(_aidl_return) } fn build_parcel_getInterfaceHash(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_getInterfaceHash(&self, _aidl_reply: std::result::Result) -> binder::Result { let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: String = _aidl_reply.read()?; *self.cached_hash.lock().unwrap() = Some(_aidl_return.clone()); Ok(_aidl_return) } } impl IMyCallback for BpMyCallback { fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { let _aidl_data = self.build_parcel_repeatParcelable(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#repeatParcelable, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_repeatParcelable(_arg_input, _aidl_reply) } fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { let _aidl_data = self.build_parcel_repeatEnum(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#repeatEnum, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_repeatEnum(_arg_input, _aidl_reply) } fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { let _aidl_data = self.build_parcel_repeatUnion(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#repeatUnion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_repeatUnion(_arg_input, _aidl_reply) } fn r#getInterfaceVersion(&self) -> binder::Result { let _aidl_version = self.cached_version.load(std::sync::atomic::Ordering::Relaxed); if _aidl_version != -1 { return Ok(_aidl_version); } let _aidl_data = self.build_parcel_getInterfaceVersion()?; let _aidl_reply = self.binder.submit_transact(transactions::r#getInterfaceVersion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_getInterfaceVersion(_aidl_reply) } fn r#getInterfaceHash(&self) -> binder::Result { { let _aidl_hash_lock = self.cached_hash.lock().unwrap(); if let Some(ref _aidl_hash) = *_aidl_hash_lock { return Ok(_aidl_hash.clone()); } } let _aidl_data = self.build_parcel_getInterfaceHash()?; let _aidl_reply = self.binder.submit_transact(transactions::r#getInterfaceHash, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_getInterfaceHash(_aidl_reply) } } impl IMyCallbackAsync

for BpMyCallback { fn r#repeatParcelable<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_repeatParcelable(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#repeatParcelable, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_repeatParcelable(_arg_input, _aidl_reply) } ) } fn r#repeatEnum<'a>(&'a self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_repeatEnum(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#repeatEnum, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_repeatEnum(_arg_input, _aidl_reply) } ) } fn r#repeatUnion<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_repeatUnion(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#repeatUnion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_repeatUnion(_arg_input, _aidl_reply) } ) } fn r#getInterfaceVersion<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { let _aidl_version = self.cached_version.load(std::sync::atomic::Ordering::Relaxed); if _aidl_version != -1 { return Box::pin(std::future::ready(Ok(_aidl_version))); } let _aidl_data = match self.build_parcel_getInterfaceVersion() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#getInterfaceVersion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_getInterfaceVersion(_aidl_reply) } ) } fn r#getInterfaceHash<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { { let _aidl_hash_lock = self.cached_hash.lock().unwrap(); if let Some(ref _aidl_hash) = *_aidl_hash_lock { return Box::pin(std::future::ready(Ok(_aidl_hash.clone()))); } } let _aidl_data = match self.build_parcel_getInterfaceHash() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#getInterfaceHash, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_getInterfaceHash(_aidl_reply) } ) } } impl IMyCallback for binder::binder_impl::Binder { fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { self.0.r#repeatParcelable(_arg_input) } fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { self.0.r#repeatEnum(_arg_input) } fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { self.0.r#repeatUnion(_arg_input) } fn r#getInterfaceVersion(&self) -> binder::Result { self.0.r#getInterfaceVersion() } fn r#getInterfaceHash(&self) -> binder::Result { self.0.r#getInterfaceHash() } } fn on_transact(_aidl_service: &dyn IMyCallback, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#repeatParcelable => { let _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable = _aidl_data.read()?; let _aidl_return = _aidl_service.r#repeatParcelable(&_arg_input); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#repeatEnum => { let _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum = _aidl_data.read()?; let _aidl_return = _aidl_service.r#repeatEnum(_arg_input); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#repeatUnion => { let _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion = _aidl_data.read()?; let _aidl_return = _aidl_service.r#repeatUnion(&_arg_input); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#getInterfaceVersion => { let _aidl_return = _aidl_service.r#getInterfaceVersion(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#getInterfaceHash => { let _aidl_return = _aidl_service.r#getInterfaceHash(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } } pub(crate) mod mangled { pub use super::r#ITrunkStableTest as _7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest; pub use super::r#MyParcelable::r#MyParcelable as _7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable; pub use super::r#MyEnum::r#MyEnum as _7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum; pub use super::r#MyUnion::r#MyUnion as _7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion; pub use super::r#MyUnion::r#Tag::r#Tag as _7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion_3_Tag; pub use super::r#IMyCallback::r#IMyCallback as _7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_11_IMyCallback; } ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-rust-source_g0100644 0000000 0000000 00000000252 15172120304 033204 xustar000000000 0000000 142 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/gen/android/aidl/test/trunk/ITrunkStableTest.rs.d 28 mtime=1776853188.7570000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/gen/android/aidl/0100644 0000000 0000000 00000000433 15172120304 033061 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/gen/android/aidl/test/trunk/ITrunkStableTest.rs : \ system/tools/aidl/tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/android/aidl/test/trunk/ITrunkStableTest.aidl ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V1-rust-source_g0100644 0000000 0000000 00000000034 15172120304 033202 xustar000000000 0000000 28 mtime=1776853188.7570000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 032442 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-cpp-source_0100644 0000000 0000000 00000000034 15172120304 032621 xustar000000000 0000000 28 mtime=1776853188.7570000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/0040755 0000000 0000000 00000000000 15172120304 027546 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-cpp-source_ge0100644 0000000 0000000 00000000034 15172120304 033135 xustar000000000 0000000 28 mtime=1776853188.7570000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/0040755 0000000 0000000 00000000000 15172120304 030317 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-cpp-source_ge0100644 0000000 0000000 00000000034 15172120304 033135 xustar000000000 0000000 28 mtime=1776853188.7570000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 031737 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-cpp-source_ge0100644 0000000 0000000 00000000034 15172120304 033135 xustar000000000 0000000 28 mtime=1776853188.7570000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 032650 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-cpp-source_ge0100644 0000000 0000000 00000000216 15172120304 033137 xustar000000000 0000000 114 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/android/aidl/test/ 28 mtime=1776853188.7570000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/android/aidl/t0040755 0000000 0000000 00000000000 15172120304 033034 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-cpp-source_ge0100644 0000000 0000000 00000000224 15172120304 033136 xustar000000000 0000000 120 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/android/aidl/test/trunk/ 28 mtime=1776853188.7570000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/android/aidl/t0040755 0000000 0000000 00000000000 15172120304 033034 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-cpp-source_ge0100644 0000000 0000000 00000000250 15172120304 033135 xustar000000000 0000000 140 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/android/aidl/test/trunk/ITrunkStableTest.cpp 28 mtime=1776853188.7570000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/android/aidl/t0100644 0000000 0000000 00000171532 15172120304 033044 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror --structured --version 2 --hash notfrozen -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/staging/android/aidl/test/trunk/ITrunkStableTest.cpp.d -h out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/staging -Nsystem/tools/aidl/tests/trunk_stable_test system/tools/aidl/tests/trunk_stable_test/android/aidl/test/trunk/ITrunkStableTest.aidl */ #include #include namespace android { namespace aidl { namespace test { namespace trunk { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE(TrunkStableTest, "android.aidl.test.trunk.ITrunkStableTest") } // namespace trunk } // namespace test } // namespace aidl } // namespace android #include #include #include #include #include namespace android { namespace aidl { namespace test { namespace trunk { BpTrunkStableTest::BpTrunkStableTest(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } std::function BpTrunkStableTest::logFunc; ::android::binder::Status BpTrunkStableTest::repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::repeatParcelable::cppClient"); BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("input", ::android::internal::ToString(input)); } auto _log_start = std::chrono::steady_clock::now(); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTrunkStableTest::TRANSACTION_repeatParcelable, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) [[unlikely]] { return ITrunkStableTest::getDefaultImpl()->repeatParcelable(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatParcelable"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::android::binder::Status BpTrunkStableTest::repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum input, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::repeatEnum::cppClient"); BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("input", ::android::internal::ToString(input)); } auto _log_start = std::chrono::steady_clock::now(); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeByte(static_cast(input)); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTrunkStableTest::TRANSACTION_repeatEnum, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) [[unlikely]] { return ITrunkStableTest::getDefaultImpl()->repeatEnum(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readByte(reinterpret_cast(_aidl_return)); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatEnum"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::android::binder::Status BpTrunkStableTest::repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& input, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::repeatUnion::cppClient"); BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("input", ::android::internal::ToString(input)); } auto _log_start = std::chrono::steady_clock::now(); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTrunkStableTest::TRANSACTION_repeatUnion, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) [[unlikely]] { return ITrunkStableTest::getDefaultImpl()->repeatUnion(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatUnion"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::android::binder::Status BpTrunkStableTest::callMyCallback(const ::android::sp<::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& cb) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::callMyCallback::cppClient"); BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("cb", ::android::internal::ToString(cb)); } auto _log_start = std::chrono::steady_clock::now(); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeStrongBinder(cb); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTrunkStableTest::TRANSACTION_callMyCallback, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) [[unlikely]] { return ITrunkStableTest::getDefaultImpl()->callMyCallback(cb); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "callMyCallback"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::android::binder::Status BpTrunkStableTest::repeatOtherParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::repeatOtherParcelable::cppClient"); BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("input", ::android::internal::ToString(input)); } auto _log_start = std::chrono::steady_clock::now(); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(BnTrunkStableTest::TRANSACTION_repeatOtherParcelable, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) [[unlikely]] { return ITrunkStableTest::getDefaultImpl()->repeatOtherParcelable(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatOtherParcelable"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } int32_t BpTrunkStableTest::getInterfaceVersion() { if (cached_version_ == -1) { ::android::Parcel data; ::android::Parcel reply; data.writeInterfaceToken(getInterfaceDescriptor()); ::android::status_t err = remote()->transact(BnTrunkStableTest::TRANSACTION_getInterfaceVersion, data, &reply); if (err == ::android::OK) { ::android::binder::Status _aidl_status; err = _aidl_status.readFromParcel(reply); if (err == ::android::OK && _aidl_status.isOk()) { cached_version_ = reply.readInt32(); } } } return cached_version_; } std::string BpTrunkStableTest::getInterfaceHash() { std::lock_guard lockGuard(cached_hash_mutex_); if (cached_hash_ == "-1") { ::android::Parcel data; ::android::Parcel reply; data.writeInterfaceToken(getInterfaceDescriptor()); ::android::status_t err = remote()->transact(BnTrunkStableTest::TRANSACTION_getInterfaceHash, data, &reply); if (err == ::android::OK) { ::android::binder::Status _aidl_status; err = _aidl_status.readFromParcel(reply); if (err == ::android::OK && _aidl_status.isOk()) { reply.readUtf8FromUtf16(&cached_hash_); } } } return cached_hash_; } } // namespace trunk } // namespace test } // namespace aidl } // namespace android #include #include #include #include #include namespace android { namespace aidl { namespace test { namespace trunk { BnTrunkStableTest::BnTrunkStableTest() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t BnTrunkStableTest::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnTrunkStableTest::TRANSACTION_repeatParcelable: { ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable in_input; ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::repeatParcelable::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(repeatParcelable(in_input, &_aidl_return)); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatParcelable"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTrunkStableTest::TRANSACTION_repeatEnum: { ::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input; ::android::aidl::test::trunk::ITrunkStableTest::MyEnum _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::repeatEnum::cppServer"); _aidl_ret_status = _aidl_data.readByte(reinterpret_cast(&in_input)); if (((_aidl_ret_status) != (::android::OK))) { break; } BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(repeatEnum(in_input, &_aidl_return)); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatEnum"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeByte(static_cast(_aidl_return)); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTrunkStableTest::TRANSACTION_repeatUnion: { ::android::aidl::test::trunk::ITrunkStableTest::MyUnion in_input; ::android::aidl::test::trunk::ITrunkStableTest::MyUnion _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::repeatUnion::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(repeatUnion(in_input, &_aidl_return)); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatUnion"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTrunkStableTest::TRANSACTION_callMyCallback: { ::android::sp<::android::aidl::test::trunk::ITrunkStableTest::IMyCallback> in_cb; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::callMyCallback::cppServer"); _aidl_ret_status = _aidl_data.readStrongBinder(&in_cb); if (((_aidl_ret_status) != (::android::OK))) { break; } BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_cb", ::android::internal::ToString(in_cb)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(callMyCallback(in_cb)); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "callMyCallback"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } } break; case BnTrunkStableTest::TRANSACTION_repeatOtherParcelable: { ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable in_input; ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::ITrunkStableTest::repeatOtherParcelable::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(repeatOtherParcelable(in_input, &_aidl_return)); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatOtherParcelable"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnTrunkStableTest::TRANSACTION_getInterfaceVersion: { _aidl_data.checkInterface(this); _aidl_reply->writeNoException(); _aidl_reply->writeInt32(ITrunkStableTest::VERSION); } break; case BnTrunkStableTest::TRANSACTION_getInterfaceHash: { _aidl_data.checkInterface(this); _aidl_reply->writeNoException(); _aidl_reply->writeUtf8AsUtf16(ITrunkStableTest::HASH); } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } int32_t BnTrunkStableTest::getInterfaceVersion() { return ITrunkStableTest::VERSION; } std::string BnTrunkStableTest::getInterfaceHash() { return ITrunkStableTest::HASH; } std::function BnTrunkStableTest::logFunc; } // namespace trunk } // namespace test } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace test { namespace trunk { ::android::status_t ITrunkStableTest::MyParcelable::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&a); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&b); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&c); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t ITrunkStableTest::MyParcelable::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeInt32(a); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(b); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(c); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace trunk } // namespace test } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace test { namespace trunk { ::android::status_t ITrunkStableTest::MyUnion::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_tag)) != ::android::OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case a: { int32_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case b: { int32_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } case c: { int32_t _aidl_value; if ((_aidl_ret_status = _aidl_parcel->readInt32(&_aidl_value)) != ::android::OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return ::android::OK; } } return ::android::BAD_VALUE; } ::android::status_t ITrunkStableTest::MyUnion::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = _aidl_parcel->writeInt32(static_cast(getTag())); if (_aidl_ret_status != ::android::OK) return _aidl_ret_status; switch (getTag()) { case a: return _aidl_parcel->writeInt32(get()); case b: return _aidl_parcel->writeInt32(get()); case c: return _aidl_parcel->writeInt32(get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace trunk } // namespace test } // namespace aidl } // namespace android #include #include namespace android { namespace aidl { namespace test { namespace trunk { DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_NESTED_INTERFACE(ITrunkStableTest, MyCallback, "android.aidl.test.trunk.ITrunkStableTest.IMyCallback") } // namespace trunk } // namespace test } // namespace aidl } // namespace android #include #include #include #include #include namespace android { namespace aidl { namespace test { namespace trunk { ITrunkStableTest::BpMyCallback::BpMyCallback(const ::android::sp<::android::IBinder>& _aidl_impl) : BpInterface(_aidl_impl){ } std::function ITrunkStableTest::BpMyCallback::logFunc; ::android::binder::Status ITrunkStableTest::BpMyCallback::repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyCallback::repeatParcelable::cppClient"); ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("input", ::android::internal::ToString(input)); } auto _log_start = std::chrono::steady_clock::now(); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(ITrunkStableTest::BnMyCallback::TRANSACTION_repeatParcelable, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) [[unlikely]] { return IMyCallback::getDefaultImpl()->repeatParcelable(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatParcelable"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } ::android::binder::Status ITrunkStableTest::BpMyCallback::repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum input, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyCallback::repeatEnum::cppClient"); ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("input", ::android::internal::ToString(input)); } auto _log_start = std::chrono::steady_clock::now(); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeByte(static_cast(input)); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(ITrunkStableTest::BnMyCallback::TRANSACTION_repeatEnum, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) [[unlikely]] { return IMyCallback::getDefaultImpl()->repeatEnum(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readByte(reinterpret_cast(_aidl_return)); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatEnum"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } ::android::binder::Status ITrunkStableTest::BpMyCallback::repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& input, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyCallback::repeatUnion::cppClient"); ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("input", ::android::internal::ToString(input)); } auto _log_start = std::chrono::steady_clock::now(); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(ITrunkStableTest::BnMyCallback::TRANSACTION_repeatUnion, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) [[unlikely]] { return IMyCallback::getDefaultImpl()->repeatUnion(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatUnion"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } ::android::binder::Status ITrunkStableTest::BpMyCallback::repeatOtherParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) { ::android::Parcel _aidl_data; _aidl_data.markForBinder(remoteStrong()); ::android::Parcel _aidl_reply; ::android::status_t _aidl_ret_status = ::android::OK; ::android::binder::Status _aidl_status; ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyCallback::repeatOtherParcelable::cppClient"); ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("input", ::android::internal::ToString(input)); } auto _log_start = std::chrono::steady_clock::now(); _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_data.writeParcelable(input); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = remote()->transact(ITrunkStableTest::BnMyCallback::TRANSACTION_repeatOtherParcelable, _aidl_data, &_aidl_reply, 0); if (_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) [[unlikely]] { return IMyCallback::getDefaultImpl()->repeatOtherParcelable(input, _aidl_return); } if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } if (!_aidl_status.isOk()) { return _aidl_status; } _aidl_ret_status = _aidl_reply.readParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { goto _aidl_error; } _aidl_error: _aidl_status.setFromStatusT(_aidl_ret_status); if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatOtherParcelable"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } int32_t ITrunkStableTest::BpMyCallback::getInterfaceVersion() { if (cached_version_ == -1) { ::android::Parcel data; ::android::Parcel reply; data.writeInterfaceToken(getInterfaceDescriptor()); ::android::status_t err = remote()->transact(ITrunkStableTest::BnMyCallback::TRANSACTION_getInterfaceVersion, data, &reply); if (err == ::android::OK) { ::android::binder::Status _aidl_status; err = _aidl_status.readFromParcel(reply); if (err == ::android::OK && _aidl_status.isOk()) { cached_version_ = reply.readInt32(); } } } return cached_version_; } std::string ITrunkStableTest::BpMyCallback::getInterfaceHash() { std::lock_guard lockGuard(cached_hash_mutex_); if (cached_hash_ == "-1") { ::android::Parcel data; ::android::Parcel reply; data.writeInterfaceToken(getInterfaceDescriptor()); ::android::status_t err = remote()->transact(ITrunkStableTest::BnMyCallback::TRANSACTION_getInterfaceHash, data, &reply); if (err == ::android::OK) { ::android::binder::Status _aidl_status; err = _aidl_status.readFromParcel(reply); if (err == ::android::OK && _aidl_status.isOk()) { reply.readUtf8FromUtf16(&cached_hash_); } } } return cached_hash_; } } // namespace trunk } // namespace test } // namespace aidl } // namespace android #include #include #include #include #include namespace android { namespace aidl { namespace test { namespace trunk { ITrunkStableTest::BnMyCallback::BnMyCallback() { ::android::internal::Stability::markCompilationUnit(this); } ::android::status_t ITrunkStableTest::BnMyCallback::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { ::android::status_t _aidl_ret_status = ::android::OK; switch (_aidl_code) { case BnMyCallback::TRANSACTION_repeatParcelable: { ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable in_input; ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyCallback::repeatParcelable::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(repeatParcelable(in_input, &_aidl_return)); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatParcelable"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnMyCallback::TRANSACTION_repeatEnum: { ::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input; ::android::aidl::test::trunk::ITrunkStableTest::MyEnum _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyCallback::repeatEnum::cppServer"); _aidl_ret_status = _aidl_data.readByte(reinterpret_cast(&in_input)); if (((_aidl_ret_status) != (::android::OK))) { break; } ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(repeatEnum(in_input, &_aidl_return)); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatEnum"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeByte(static_cast(_aidl_return)); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnMyCallback::TRANSACTION_repeatUnion: { ::android::aidl::test::trunk::ITrunkStableTest::MyUnion in_input; ::android::aidl::test::trunk::ITrunkStableTest::MyUnion _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyCallback::repeatUnion::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(repeatUnion(in_input, &_aidl_return)); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatUnion"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnMyCallback::TRANSACTION_repeatOtherParcelable: { ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable in_input; ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable _aidl_return; if (!(_aidl_data.checkInterface(this))) { _aidl_ret_status = ::android::BAD_TYPE; break; } ::android::binder::ScopedTrace _aidl_trace(ATRACE_TAG_AIDL, "AIDL::cpp::IMyCallback::repeatOtherParcelable::cppServer"); _aidl_ret_status = _aidl_data.readParcelable(&in_input); if (((_aidl_ret_status) != (::android::OK))) { break; } ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); if (auto st = _aidl_data.enforceNoDataAvail(); !st.isOk()) { _aidl_ret_status = st.writeToParcel(_aidl_reply); break; } ::android::binder::Status _aidl_status(repeatOtherParcelable(in_input, &_aidl_return)); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatOtherParcelable"; _transaction_log.stub_address = static_cast(this); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = _aidl_status.exceptionCode(); _transaction_log.exception_message = _aidl_status.exceptionMessage(); _transaction_log.transaction_error = _aidl_status.transactionError(); _transaction_log.service_specific_error_code = _aidl_status.serviceSpecificErrorCode(); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); if (((_aidl_ret_status) != (::android::OK))) { break; } if (!_aidl_status.isOk()) { break; } _aidl_ret_status = _aidl_reply->writeParcelable(_aidl_return); if (((_aidl_ret_status) != (::android::OK))) { break; } } break; case BnMyCallback::TRANSACTION_getInterfaceVersion: { _aidl_data.checkInterface(this); _aidl_reply->writeNoException(); _aidl_reply->writeInt32(IMyCallback::VERSION); } break; case BnMyCallback::TRANSACTION_getInterfaceHash: { _aidl_data.checkInterface(this); _aidl_reply->writeNoException(); _aidl_reply->writeUtf8AsUtf16(IMyCallback::HASH); } break; default: { _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); } break; } if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeOverParcel(_aidl_reply); } return _aidl_ret_status; } int32_t ITrunkStableTest::BnMyCallback::getInterfaceVersion() { return IMyCallback::VERSION; } std::string ITrunkStableTest::BnMyCallback::getInterfaceHash() { return IMyCallback::HASH; } std::function ITrunkStableTest::BnMyCallback::logFunc; } // namespace trunk } // namespace test } // namespace aidl } // namespace android #include namespace android { namespace aidl { namespace test { namespace trunk { ::android::status_t ITrunkStableTest::MyOtherParcelable::readFromParcel(const ::android::Parcel* _aidl_parcel) { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); int32_t _aidl_parcelable_raw_size = 0; _aidl_ret_status = _aidl_parcel->readInt32(&_aidl_parcelable_raw_size); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcelable_raw_size < 4) return ::android::BAD_VALUE; size_t _aidl_parcelable_size = static_cast(_aidl_parcelable_raw_size); if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return ::android::BAD_VALUE; if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&a); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } if (_aidl_parcel->dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) { _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->readInt32(&b); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_parcel->setDataPosition(_aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } ::android::status_t ITrunkStableTest::MyOtherParcelable::writeToParcel(::android::Parcel* _aidl_parcel) const { ::android::status_t _aidl_ret_status = ::android::OK; size_t _aidl_start_pos = _aidl_parcel->dataPosition(); _aidl_parcel->writeInt32(0); _aidl_ret_status = _aidl_parcel->writeInt32(a); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } _aidl_ret_status = _aidl_parcel->writeInt32(b); if (((_aidl_ret_status) != (::android::OK))) { return _aidl_ret_status; } size_t _aidl_end_pos = _aidl_parcel->dataPosition(); _aidl_parcel->setDataPosition(_aidl_start_pos); _aidl_parcel->writeInt32(static_cast(_aidl_end_pos - _aidl_start_pos)); _aidl_parcel->setDataPosition(_aidl_end_pos); return _aidl_ret_status; } } // namespace trunk } // namespace test } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-cpp-source_ge0100644 0000000 0000000 00000000252 15172120304 033137 xustar000000000 0000000 142 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/android/aidl/test/trunk/ITrunkStableTest.cpp.d 28 mtime=1776853188.7580000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/android/aidl/t0100644 0000000 0000000 00000000370 15172120304 033033 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/android/aidl/test/trunk/ITrunkStableTest.cpp : \ system/tools/aidl/tests/trunk_stable_test/android/aidl/test/trunk/ITrunkStableTest.aidl ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-cpp-source_ge0100644 0000000 0000000 00000000034 15172120304 033135 xustar000000000 0000000 28 mtime=1776853188.7580000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include/0040755 0000000 0000000 00000000000 15172120304 031742 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-cpp-source_ge0100644 0000000 0000000 00000000214 15172120304 033135 xustar000000000 0000000 112 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include/android/ 28 mtime=1776853188.7580000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include/androi0040755 0000000 0000000 00000000000 15172120304 033137 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-cpp-source_ge0100644 0000000 0000000 00000000221 15172120304 033133 xustar000000000 0000000 117 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include/android/aidl/ 28 mtime=1776853188.7580000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include/androi0040755 0000000 0000000 00000000000 15172120304 033137 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-cpp-source_ge0100644 0000000 0000000 00000000226 15172120304 033140 xustar000000000 0000000 122 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include/android/aidl/test/ 28 mtime=1776853188.7580000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include/androi0040755 0000000 0000000 00000000000 15172120304 033137 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-cpp-source_ge0100644 0000000 0000000 00000000234 15172120304 033137 xustar000000000 0000000 128 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include/android/aidl/test/trunk/ 28 mtime=1776853188.7580000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include/androi0040755 0000000 0000000 00000000000 15172120304 033137 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-cpp-source_ge0100644 0000000 0000000 00000000257 15172120304 033144 xustar000000000 0000000 147 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include/android/aidl/test/trunk/BnTrunkStableTest.h 28 mtime=1776853188.7580000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include/androi0100644 0000000 0000000 00000011751 15172120304 033143 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror --structured --version 2 --hash notfrozen -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/staging/android/aidl/test/trunk/ITrunkStableTest.cpp.d -h out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/staging -Nsystem/tools/aidl/tests/trunk_stable_test system/tools/aidl/tests/trunk_stable_test/android/aidl/test/trunk/ITrunkStableTest.aidl */ #pragma once #include #include #include #include #include #include #include namespace android { namespace aidl { namespace test { namespace trunk { class BnTrunkStableTest : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_repeatParcelable = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_repeatEnum = ::android::IBinder::FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_repeatUnion = ::android::IBinder::FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_callMyCallback = ::android::IBinder::FIRST_CALL_TRANSACTION + 3; static constexpr uint32_t TRANSACTION_repeatOtherParcelable = ::android::IBinder::FIRST_CALL_TRANSACTION + 4; static constexpr uint32_t TRANSACTION_getInterfaceVersion = ::android::IBinder::FIRST_CALL_TRANSACTION + 16777214; static constexpr uint32_t TRANSACTION_getInterfaceHash = ::android::IBinder::FIRST_CALL_TRANSACTION + 16777213; explicit BnTrunkStableTest(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; int32_t getInterfaceVersion(); std::string getInterfaceHash(); struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; }; // class BnTrunkStableTest class ITrunkStableTestDelegator : public BnTrunkStableTest { public: explicit ITrunkStableTestDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override { return _aidl_delegate->repeatParcelable(input, _aidl_return); } ::android::binder::Status repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum input, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override { return _aidl_delegate->repeatEnum(input, _aidl_return); } ::android::binder::Status repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& input, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override { return _aidl_delegate->repeatUnion(input, _aidl_return); } ::android::binder::Status callMyCallback(const ::android::sp<::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& cb) override { ::android::sp<::android::aidl::test::trunk::ITrunkStableTest::IMyCallbackDelegator> _cb; if (cb) { _cb = ::android::sp<::android::aidl::test::trunk::ITrunkStableTest::IMyCallbackDelegator>::cast(delegate(cb)); } return _aidl_delegate->callMyCallback(_cb); } ::android::binder::Status repeatOtherParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) override { return _aidl_delegate->repeatOtherParcelable(input, _aidl_return); } int32_t getInterfaceVersion() override { int32_t _delegator_ver = BnTrunkStableTest::getInterfaceVersion(); int32_t _impl_ver = _aidl_delegate->getInterfaceVersion(); return _delegator_ver < _impl_ver ? _delegator_ver : _impl_ver; } std::string getInterfaceHash() override { return _aidl_delegate->getInterfaceHash(); } private: ::android::sp _aidl_delegate; }; // class ITrunkStableTestDelegator } // namespace trunk } // namespace test } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-cpp-source_ge0100644 0000000 0000000 00000000257 15172120304 033144 xustar000000000 0000000 147 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include/android/aidl/test/trunk/BpTrunkStableTest.h 28 mtime=1776853188.7590000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include/androi0100644 0000000 0000000 00000005772 15172120304 033151 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror --structured --version 2 --hash notfrozen -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/staging/android/aidl/test/trunk/ITrunkStableTest.cpp.d -h out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/staging -Nsystem/tools/aidl/tests/trunk_stable_test system/tools/aidl/tests/trunk_stable_test/android/aidl/test/trunk/ITrunkStableTest.aidl */ #pragma once #include #include #include #include #include #include namespace android { namespace aidl { namespace test { namespace trunk { class BpTrunkStableTest : public ::android::BpInterface { public: explicit BpTrunkStableTest(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpTrunkStableTest() = default; ::android::binder::Status repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override; ::android::binder::Status repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum input, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override; ::android::binder::Status repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& input, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override; ::android::binder::Status callMyCallback(const ::android::sp<::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& cb) override; ::android::binder::Status repeatOtherParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) override; int32_t getInterfaceVersion() override; std::string getInterfaceHash() override; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; private: int32_t cached_version_ = -1; std::string cached_hash_ = "-1"; std::mutex cached_hash_mutex_; }; // class BpTrunkStableTest } // namespace trunk } // namespace test } // namespace aidl } // namespace android ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-cpp-source_ge0100644 0000000 0000000 00000000256 15172120304 033143 xustar000000000 0000000 146 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include/android/aidl/test/trunk/ITrunkStableTest.h 28 mtime=1776853188.7590000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include/androi0100644 0000000 0000000 00000051650 15172120304 033145 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=cpp -Weverything -Wno-missing-permission-annotation -Werror --structured --version 2 --hash notfrozen -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/staging/android/aidl/test/trunk/ITrunkStableTest.cpp.d -h out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/staging -Nsystem/tools/aidl/tests/trunk_stable_test system/tools/aidl/tests/trunk_stable_test/android/aidl/test/trunk/ITrunkStableTest.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace android { namespace aidl { namespace test { namespace trunk { class ITrunkStableTestDelegator; class ITrunkStableTest : public ::android::IInterface { public: typedef ITrunkStableTestDelegator DefaultDelegator; DECLARE_META_INTERFACE(TrunkStableTest) static inline const int32_t VERSION = 2; static inline const std::string HASH = "notfrozen"; class MyParcelable : public ::android::Parcelable { public: int32_t a = 0; int32_t b = 0; int32_t c = 0; inline bool operator==(const MyParcelable& _rhs) const { return std::tie(a, b, c) == std::tie(_rhs.a, _rhs.b, _rhs.c); } inline bool operator<(const MyParcelable& _rhs) const { return std::tie(a, b, c) < std::tie(_rhs.a, _rhs.b, _rhs.c); } inline bool operator!=(const MyParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyParcelable& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.test.trunk.ITrunkStableTest.MyParcelable"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "MyParcelable{"; _aidl_os << "a: " << ::android::internal::ToString(a); _aidl_os << ", b: " << ::android::internal::ToString(b); _aidl_os << ", c: " << ::android::internal::ToString(c); _aidl_os << "}"; return _aidl_os.str(); } }; // class MyParcelable enum class MyEnum : int8_t { ZERO = 0, ONE = 1, TWO = 2, THREE = 3, }; class MyUnion : public ::android::Parcelable { public: enum class Tag : int32_t { a = 0, b = 1, c = 2, }; // Expose tag symbols for legacy code static const inline Tag a = Tag::a; static const inline Tag b = Tag::b; static const inline Tag c = Tag::c; template static constexpr bool _not_self = !std::is_same_v>, MyUnion>; MyUnion() : _value(std::in_place_index(a)>, int32_t(0)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr MyUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit MyUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static MyUnion make(_Tp&&... _args) { return MyUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static MyUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return MyUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } inline bool operator==(const MyUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const MyUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const MyUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyUnion& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.test.trunk.ITrunkStableTest.MyUnion"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream os; os << "MyUnion{"; switch (getTag()) { case a: os << "a: " << ::android::internal::ToString(get()); break; case b: os << "b: " << ::android::internal::ToString(get()); break; case c: os << "c: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant _value; }; // class MyUnion class MyOtherParcelable : public ::android::Parcelable { public: int32_t a = 0; int32_t b = 0; inline bool operator==(const MyOtherParcelable& _rhs) const { return std::tie(a, b) == std::tie(_rhs.a, _rhs.b); } inline bool operator<(const MyOtherParcelable& _rhs) const { return std::tie(a, b) < std::tie(_rhs.a, _rhs.b); } inline bool operator!=(const MyOtherParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyOtherParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyOtherParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyOtherParcelable& _rhs) const { return !(_rhs < *this); } ::android::status_t readFromParcel(const ::android::Parcel* _aidl_parcel) final; ::android::status_t writeToParcel(::android::Parcel* _aidl_parcel) const final; static const ::android::String16& getParcelableDescriptor() { static const ::android::StaticString16 DESCRIPTOR (u"android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable"); return DESCRIPTOR; } inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "MyOtherParcelable{"; _aidl_os << "a: " << ::android::internal::ToString(a); _aidl_os << ", b: " << ::android::internal::ToString(b); _aidl_os << "}"; return _aidl_os.str(); } }; // class MyOtherParcelable class IMyCallbackDelegator; class IMyCallback : public ::android::IInterface { public: typedef IMyCallbackDelegator DefaultDelegator; DECLARE_META_INTERFACE(MyCallback) static inline const int32_t VERSION = 2; static inline const std::string HASH = "notfrozen"; virtual ::android::binder::Status repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) = 0; virtual ::android::binder::Status repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum input, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) = 0; virtual ::android::binder::Status repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& input, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) = 0; virtual ::android::binder::Status repeatOtherParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) = 0; virtual int32_t getInterfaceVersion() = 0; virtual std::string getInterfaceHash() = 0; }; // class IMyCallback class IMyCallbackDefault : public IMyCallback { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& /*input*/, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum /*input*/, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& /*input*/, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status repeatOtherParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& /*input*/, ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } int32_t getInterfaceVersion() override { return 0; } std::string getInterfaceHash() override { return ""; } }; // class IMyCallbackDefault class BpMyCallback : public ::android::BpInterface { public: explicit BpMyCallback(const ::android::sp<::android::IBinder>& _aidl_impl); virtual ~BpMyCallback() = default; ::android::binder::Status repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override; ::android::binder::Status repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum input, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override; ::android::binder::Status repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& input, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override; ::android::binder::Status repeatOtherParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) override; int32_t getInterfaceVersion() override; std::string getInterfaceHash() override; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; private: int32_t cached_version_ = -1; std::string cached_hash_ = "-1"; std::mutex cached_hash_mutex_; }; // class BpMyCallback class BnMyCallback : public ::android::BnInterface { public: static constexpr uint32_t TRANSACTION_repeatParcelable = ::android::IBinder::FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_repeatEnum = ::android::IBinder::FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_repeatUnion = ::android::IBinder::FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_repeatOtherParcelable = ::android::IBinder::FIRST_CALL_TRANSACTION + 3; static constexpr uint32_t TRANSACTION_getInterfaceVersion = ::android::IBinder::FIRST_CALL_TRANSACTION + 16777214; static constexpr uint32_t TRANSACTION_getInterfaceHash = ::android::IBinder::FIRST_CALL_TRANSACTION + 16777213; explicit BnMyCallback(); ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; int32_t getInterfaceVersion(); std::string getInterfaceHash(); struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; }; // class BnMyCallback class IMyCallbackDelegator : public BnMyCallback { public: explicit IMyCallbackDelegator(const ::android::sp &impl) : _aidl_delegate(impl) {} ::android::sp getImpl() { return _aidl_delegate; } ::android::binder::Status repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override { return _aidl_delegate->repeatParcelable(input, _aidl_return); } ::android::binder::Status repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum input, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override { return _aidl_delegate->repeatEnum(input, _aidl_return); } ::android::binder::Status repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& input, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override { return _aidl_delegate->repeatUnion(input, _aidl_return); } ::android::binder::Status repeatOtherParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) override { return _aidl_delegate->repeatOtherParcelable(input, _aidl_return); } int32_t getInterfaceVersion() override { int32_t _delegator_ver = BnMyCallback::getInterfaceVersion(); int32_t _impl_ver = _aidl_delegate->getInterfaceVersion(); return _delegator_ver < _impl_ver ? _delegator_ver : _impl_ver; } std::string getInterfaceHash() override { return _aidl_delegate->getInterfaceHash(); } private: ::android::sp _aidl_delegate; }; // class IMyCallbackDelegator virtual ::android::binder::Status repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) = 0; virtual ::android::binder::Status repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum input, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) = 0; virtual ::android::binder::Status repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& input, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) = 0; virtual ::android::binder::Status callMyCallback(const ::android::sp<::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& cb) = 0; virtual ::android::binder::Status repeatOtherParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& input, ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) = 0; virtual int32_t getInterfaceVersion() = 0; virtual std::string getInterfaceHash() = 0; }; // class ITrunkStableTest class ITrunkStableTestDefault : public ITrunkStableTest { public: ::android::IBinder* onAsBinder() override { return nullptr; } ::android::binder::Status repeatParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& /*input*/, ::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status repeatEnum(::android::aidl::test::trunk::ITrunkStableTest::MyEnum /*input*/, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status repeatUnion(const ::android::aidl::test::trunk::ITrunkStableTest::MyUnion& /*input*/, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status callMyCallback(const ::android::sp<::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& /*cb*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } ::android::binder::Status repeatOtherParcelable(const ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& /*input*/, ::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* /*_aidl_return*/) override { return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); } int32_t getInterfaceVersion() override { return 0; } std::string getInterfaceHash() override { return ""; } }; // class ITrunkStableTestDefault } // namespace trunk } // namespace test } // namespace aidl } // namespace android namespace android { namespace aidl { namespace test { namespace trunk { [[nodiscard]] static inline std::string toString(ITrunkStableTest::MyEnum val) { switch(val) { case ITrunkStableTest::MyEnum::ZERO: return "ZERO"; case ITrunkStableTest::MyEnum::ONE: return "ONE"; case ITrunkStableTest::MyEnum::TWO: return "TWO"; case ITrunkStableTest::MyEnum::THREE: return "THREE"; default: return std::to_string(static_cast(val)); } } } // namespace trunk } // namespace test } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::test::trunk::ITrunkStableTest::MyEnum, 4> enum_values<::android::aidl::test::trunk::ITrunkStableTest::MyEnum> = { ::android::aidl::test::trunk::ITrunkStableTest::MyEnum::ZERO, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum::ONE, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum::TWO, ::android::aidl::test::trunk::ITrunkStableTest::MyEnum::THREE, }; #pragma clang diagnostic pop } // namespace internal } // namespace android namespace android { namespace aidl { namespace test { namespace trunk { [[nodiscard]] static inline std::string toString(ITrunkStableTest::MyUnion::Tag val) { switch(val) { case ITrunkStableTest::MyUnion::Tag::a: return "a"; case ITrunkStableTest::MyUnion::Tag::b: return "b"; case ITrunkStableTest::MyUnion::Tag::c: return "c"; default: return std::to_string(static_cast(val)); } } } // namespace trunk } // namespace test } // namespace aidl } // namespace android namespace android { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array<::android::aidl::test::trunk::ITrunkStableTest::MyUnion::Tag, 3> enum_values<::android::aidl::test::trunk::ITrunkStableTest::MyUnion::Tag> = { ::android::aidl::test::trunk::ITrunkStableTest::MyUnion::Tag::a, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion::Tag::b, ::android::aidl::test::trunk::ITrunkStableTest::MyUnion::Tag::c, }; #pragma clang diagnostic pop } // namespace internal } // namespace android ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-cpp-source_ge0100644 0000000 0000000 00000000034 15172120304 033135 xustar000000000 0000000 28 mtime=1776853188.7590000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 032230 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-java-source_0100644 0000000 0000000 00000000034 15172120304 032760 xustar000000000 0000000 28 mtime=1776853188.7590000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/0040755 0000000 0000000 00000000000 15172120304 027705 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-java-source_g0100644 0000000 0000000 00000000034 15172120304 033127 xustar000000000 0000000 28 mtime=1776853188.7590000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/gen/0040755 0000000 0000000 00000000000 15172120304 030456 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-java-source_g0100644 0000000 0000000 00000000034 15172120304 033127 xustar000000000 0000000 28 mtime=1776853188.7590000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 032076 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-java-source_g0100644 0000000 0000000 00000000212 15172120304 033125 xustar000000000 0000000 110 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/gen/android/aidl/ 28 mtime=1776853188.7590000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 033007 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-java-source_g0100644 0000000 0000000 00000000217 15172120304 033132 xustar000000000 0000000 115 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/gen/android/aidl/test/ 28 mtime=1776853188.7590000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 033007 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-java-source_g0100644 0000000 0000000 00000000225 15172120304 033131 xustar000000000 0000000 121 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/gen/android/aidl/test/trunk/ 28 mtime=1776853188.7590000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 033007 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-java-source_g0100644 0000000 0000000 00000000252 15172120304 033131 xustar000000000 0000000 142 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/gen/android/aidl/test/trunk/ITrunkStableTest.java 28 mtime=1776853188.7590000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/gen/android/aidl/0100644 0000000 0000000 00000113030 15172120304 033004 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=java -Weverything -Wno-missing-permission-annotation -Werror --structured --version 2 --hash notfrozen -t --min_sdk_version platform_apis --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/gen/android/aidl/test/trunk/ITrunkStableTest.java.d -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/gen -Nsystem/tools/aidl/tests/trunk_stable_test system/tools/aidl/tests/trunk_stable_test/android/aidl/test/trunk/ITrunkStableTest.aidl */ package android.aidl.test.trunk; public interface ITrunkStableTest extends android.os.IInterface { /** * The version of this interface that the caller is built against. * This might be different from what {@link #getInterfaceVersion() * getInterfaceVersion} returns as that is the version of the interface * that the remote object is implementing. */ public static final int VERSION = 2; public static final String HASH = "notfrozen"; /** Default implementation for ITrunkStableTest. */ public static class Default implements android.aidl.test.trunk.ITrunkStableTest { @Override public android.aidl.test.trunk.ITrunkStableTest.MyParcelable repeatParcelable(android.aidl.test.trunk.ITrunkStableTest.MyParcelable input) throws android.os.RemoteException { return null; } @Override public byte repeatEnum(byte input) throws android.os.RemoteException { return 0; } @Override public android.aidl.test.trunk.ITrunkStableTest.MyUnion repeatUnion(android.aidl.test.trunk.ITrunkStableTest.MyUnion input) throws android.os.RemoteException { return null; } @Override public void callMyCallback(android.aidl.test.trunk.ITrunkStableTest.IMyCallback cb) throws android.os.RemoteException { } @Override public android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable repeatOtherParcelable(android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable input) throws android.os.RemoteException { return null; } @Override public int getInterfaceVersion() { return 0; } @Override public String getInterfaceHash() { return ""; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.test.trunk.ITrunkStableTest { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.test.trunk.ITrunkStableTest interface, * generating a proxy if needed. */ public static android.aidl.test.trunk.ITrunkStableTest asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.test.trunk.ITrunkStableTest))) { return ((android.aidl.test.trunk.ITrunkStableTest)iin); } return new android.aidl.test.trunk.ITrunkStableTest.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_repeatParcelable: { return "repeatParcelable"; } case TRANSACTION_repeatEnum: { return "repeatEnum"; } case TRANSACTION_repeatUnion: { return "repeatUnion"; } case TRANSACTION_callMyCallback: { return "callMyCallback"; } case TRANSACTION_repeatOtherParcelable: { return "repeatOtherParcelable"; } case TRANSACTION_getInterfaceVersion: { return "getInterfaceVersion"; } case TRANSACTION_getInterfaceHash: { return "getInterfaceHash"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } else if (code == TRANSACTION_getInterfaceVersion) { reply.writeNoException(); reply.writeInt(getInterfaceVersion()); return true; } else if (code == TRANSACTION_getInterfaceHash) { reply.writeNoException(); reply.writeString(getInterfaceHash()); return true; } switch (code) { case TRANSACTION_repeatParcelable: { android.aidl.test.trunk.ITrunkStableTest.MyParcelable _arg0; _arg0 = data.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyParcelable.CREATOR); data.enforceNoDataAvail(); android.aidl.test.trunk.ITrunkStableTest.MyParcelable _result = this.repeatParcelable(_arg0); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_repeatEnum: { byte _arg0; _arg0 = data.readByte(); data.enforceNoDataAvail(); byte _result = this.repeatEnum(_arg0); reply.writeNoException(); reply.writeByte(_result); break; } case TRANSACTION_repeatUnion: { android.aidl.test.trunk.ITrunkStableTest.MyUnion _arg0; _arg0 = data.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyUnion.CREATOR); data.enforceNoDataAvail(); android.aidl.test.trunk.ITrunkStableTest.MyUnion _result = this.repeatUnion(_arg0); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_callMyCallback: { android.aidl.test.trunk.ITrunkStableTest.IMyCallback _arg0; _arg0 = android.aidl.test.trunk.ITrunkStableTest.IMyCallback.Stub.asInterface(data.readStrongBinder()); data.enforceNoDataAvail(); this.callMyCallback(_arg0); reply.writeNoException(); break; } case TRANSACTION_repeatOtherParcelable: { android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable _arg0; _arg0 = data.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable.CREATOR); data.enforceNoDataAvail(); android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable _result = this.repeatOtherParcelable(_arg0); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.test.trunk.ITrunkStableTest { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } private int mCachedVersion = -1; private String mCachedHash = "-1"; @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public android.aidl.test.trunk.ITrunkStableTest.MyParcelable repeatParcelable(android.aidl.test.trunk.ITrunkStableTest.MyParcelable input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.test.trunk.ITrunkStableTest.MyParcelable _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_repeatParcelable, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method repeatParcelable is unimplemented."); } _reply.readException(); _result = _reply.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyParcelable.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public byte repeatEnum(byte input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); byte _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeByte(input); boolean _status = mRemote.transact(Stub.TRANSACTION_repeatEnum, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method repeatEnum is unimplemented."); } _reply.readException(); _result = _reply.readByte(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.test.trunk.ITrunkStableTest.MyUnion repeatUnion(android.aidl.test.trunk.ITrunkStableTest.MyUnion input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.test.trunk.ITrunkStableTest.MyUnion _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_repeatUnion, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method repeatUnion is unimplemented."); } _reply.readException(); _result = _reply.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyUnion.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public void callMyCallback(android.aidl.test.trunk.ITrunkStableTest.IMyCallback cb) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeStrongInterface(cb); boolean _status = mRemote.transact(Stub.TRANSACTION_callMyCallback, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method callMyCallback is unimplemented."); } _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } @Override public android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable repeatOtherParcelable(android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_repeatOtherParcelable, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method repeatOtherParcelable is unimplemented."); } _reply.readException(); _result = _reply.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int getInterfaceVersion() throws android.os.RemoteException { if (mCachedVersion == -1) { android.os.Parcel data = android.os.Parcel.obtain(asBinder()); android.os.Parcel reply = android.os.Parcel.obtain(); try { data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getInterfaceVersion, data, reply, 0); reply.readException(); mCachedVersion = reply.readInt(); } finally { reply.recycle(); data.recycle(); } } return mCachedVersion; } @Override public synchronized String getInterfaceHash() throws android.os.RemoteException { if ("-1".equals(mCachedHash)) { android.os.Parcel data = android.os.Parcel.obtain(asBinder()); android.os.Parcel reply = android.os.Parcel.obtain(); try { data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getInterfaceHash, data, reply, 0); reply.readException(); mCachedHash = reply.readString(); } finally { reply.recycle(); data.recycle(); } } return mCachedHash; } } static final int TRANSACTION_repeatParcelable = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); static final int TRANSACTION_repeatEnum = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1); static final int TRANSACTION_repeatUnion = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2); static final int TRANSACTION_callMyCallback = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3); static final int TRANSACTION_repeatOtherParcelable = (android.os.IBinder.FIRST_CALL_TRANSACTION + 4); static final int TRANSACTION_getInterfaceVersion = (android.os.IBinder.FIRST_CALL_TRANSACTION + 16777214); static final int TRANSACTION_getInterfaceHash = (android.os.IBinder.FIRST_CALL_TRANSACTION + 16777213); /** @hide */ public int getMaxTransactionId() { return 16777214; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android$aidl$test$trunk$ITrunkStableTest".replace('$', '.'); public android.aidl.test.trunk.ITrunkStableTest.MyParcelable repeatParcelable(android.aidl.test.trunk.ITrunkStableTest.MyParcelable input) throws android.os.RemoteException; public byte repeatEnum(byte input) throws android.os.RemoteException; public android.aidl.test.trunk.ITrunkStableTest.MyUnion repeatUnion(android.aidl.test.trunk.ITrunkStableTest.MyUnion input) throws android.os.RemoteException; public void callMyCallback(android.aidl.test.trunk.ITrunkStableTest.IMyCallback cb) throws android.os.RemoteException; public android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable repeatOtherParcelable(android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable input) throws android.os.RemoteException; public int getInterfaceVersion() throws android.os.RemoteException; public String getInterfaceHash() throws android.os.RemoteException; public static class MyParcelable implements android.os.Parcelable { public int a = 0; public int b = 0; // New in V2 public int c = 0; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public MyParcelable createFromParcel(android.os.Parcel _aidl_source) { MyParcelable _aidl_out = new MyParcelable(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public MyParcelable[] newArray(int _aidl_size) { return new MyParcelable[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(a); _aidl_parcel.writeInt(b); _aidl_parcel.writeInt(c); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; a = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; b = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; c = _aidl_parcel.readInt(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } } public static @interface MyEnum { public static final byte ZERO = 0; public static final byte ONE = 1; public static final byte TWO = 2; // New in V2 public static final byte THREE = 3; } public static final class MyUnion implements android.os.Parcelable { // tags for union fields public final static int a = 0; // int a; public final static int b = 1; // int b; public final static int c = 2; // int c; private int _tag; private Object _value; public MyUnion() { int _value = 0; this._tag = a; this._value = _value; } private MyUnion(android.os.Parcel _aidl_parcel) { readFromParcel(_aidl_parcel); } private MyUnion(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public int getTag() { return _tag; } // int a; public static MyUnion a(int _value) { return new MyUnion(a, _value); } public int getA() { _assertTag(a); return (int) _value; } public void setA(int _value) { _set(a, _value); } // int b; public static MyUnion b(int _value) { return new MyUnion(b, _value); } public int getB() { _assertTag(b); return (int) _value; } public void setB(int _value) { _set(b, _value); } // int c; // New in V3 public static MyUnion c(int _value) { return new MyUnion(c, _value); } public int getC() { _assertTag(c); return (int) _value; } public void setC(int _value) { _set(c, _value); } public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public MyUnion createFromParcel(android.os.Parcel _aidl_source) { return new MyUnion(_aidl_source); } @Override public MyUnion[] newArray(int _aidl_size) { return new MyUnion[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { _aidl_parcel.writeInt(_tag); switch (_tag) { case a: _aidl_parcel.writeInt(getA()); break; case b: _aidl_parcel.writeInt(getB()); break; case c: _aidl_parcel.writeInt(getC()); break; } } public void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_tag; _aidl_tag = _aidl_parcel.readInt(); switch (_aidl_tag) { case a: { int _aidl_value; _aidl_value = _aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } case b: { int _aidl_value; _aidl_value = _aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } case c: { int _aidl_value; _aidl_value = _aidl_parcel.readInt(); _set(_aidl_tag, _aidl_value); return; } } throw new IllegalArgumentException("union: unknown tag: " + _aidl_tag); } @Override public int describeContents() { int _mask = 0; switch (getTag()) { } return _mask; } private void _assertTag(int tag) { if (getTag() != tag) { throw new IllegalStateException("bad access: " + _tagString(tag) + ", " + _tagString(getTag()) + " is available."); } } private String _tagString(int _tag) { switch (_tag) { case a: return "a"; case b: return "b"; case c: return "c"; } throw new IllegalStateException("unknown field: " + _tag); } private void _set(int _tag, Object _value) { this._tag = _tag; this._value = _value; } public static @interface Tag { public static final int a = 0; public static final int b = 1; // New in V3 public static final int c = 2; } } public interface IMyCallback extends android.os.IInterface { /** * The version of this interface that the caller is built against. * This might be different from what {@link #getInterfaceVersion() * getInterfaceVersion} returns as that is the version of the interface * that the remote object is implementing. */ public static final int VERSION = 2; public static final String HASH = "notfrozen"; /** Default implementation for IMyCallback. */ public static class Default implements android.aidl.test.trunk.ITrunkStableTest.IMyCallback { @Override public android.aidl.test.trunk.ITrunkStableTest.MyParcelable repeatParcelable(android.aidl.test.trunk.ITrunkStableTest.MyParcelable input) throws android.os.RemoteException { return null; } @Override public byte repeatEnum(byte input) throws android.os.RemoteException { return 0; } @Override public android.aidl.test.trunk.ITrunkStableTest.MyUnion repeatUnion(android.aidl.test.trunk.ITrunkStableTest.MyUnion input) throws android.os.RemoteException { return null; } @Override public android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable repeatOtherParcelable(android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable input) throws android.os.RemoteException { return null; } @Override public int getInterfaceVersion() { return 0; } @Override public String getInterfaceHash() { return ""; } @Override public android.os.IBinder asBinder() { return null; } } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements android.aidl.test.trunk.ITrunkStableTest.IMyCallback { /** Construct the stub at attach it to the interface. */ @SuppressWarnings("this-escape") public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an android.aidl.test.trunk.ITrunkStableTest.IMyCallback interface, * generating a proxy if needed. */ public static android.aidl.test.trunk.ITrunkStableTest.IMyCallback asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof android.aidl.test.trunk.ITrunkStableTest.IMyCallback))) { return ((android.aidl.test.trunk.ITrunkStableTest.IMyCallback)iin); } return new android.aidl.test.trunk.ITrunkStableTest.IMyCallback.Stub.Proxy(obj); } @Override public android.os.IBinder asBinder() { return this; } /** @hide */ public static java.lang.String getDefaultTransactionName(int transactionCode) { switch (transactionCode) { case TRANSACTION_repeatParcelable: { return "repeatParcelable"; } case TRANSACTION_repeatEnum: { return "repeatEnum"; } case TRANSACTION_repeatUnion: { return "repeatUnion"; } case TRANSACTION_repeatOtherParcelable: { return "repeatOtherParcelable"; } case TRANSACTION_getInterfaceVersion: { return "getInterfaceVersion"; } case TRANSACTION_getInterfaceHash: { return "getInterfaceHash"; } default: { return null; } } } /** @hide */ public java.lang.String getTransactionName(int transactionCode) { return this.getDefaultTransactionName(transactionCode); } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) { data.enforceInterface(descriptor); } if (code == INTERFACE_TRANSACTION) { reply.writeString(descriptor); return true; } else if (code == TRANSACTION_getInterfaceVersion) { reply.writeNoException(); reply.writeInt(getInterfaceVersion()); return true; } else if (code == TRANSACTION_getInterfaceHash) { reply.writeNoException(); reply.writeString(getInterfaceHash()); return true; } switch (code) { case TRANSACTION_repeatParcelable: { android.aidl.test.trunk.ITrunkStableTest.MyParcelable _arg0; _arg0 = data.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyParcelable.CREATOR); data.enforceNoDataAvail(); android.aidl.test.trunk.ITrunkStableTest.MyParcelable _result = this.repeatParcelable(_arg0); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_repeatEnum: { byte _arg0; _arg0 = data.readByte(); data.enforceNoDataAvail(); byte _result = this.repeatEnum(_arg0); reply.writeNoException(); reply.writeByte(_result); break; } case TRANSACTION_repeatUnion: { android.aidl.test.trunk.ITrunkStableTest.MyUnion _arg0; _arg0 = data.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyUnion.CREATOR); data.enforceNoDataAvail(); android.aidl.test.trunk.ITrunkStableTest.MyUnion _result = this.repeatUnion(_arg0); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } case TRANSACTION_repeatOtherParcelable: { android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable _arg0; _arg0 = data.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable.CREATOR); data.enforceNoDataAvail(); android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable _result = this.repeatOtherParcelable(_arg0); reply.writeNoException(); reply.writeTypedObject(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE); break; } default: { return super.onTransact(code, data, reply, flags); } } return true; } private static class Proxy implements android.aidl.test.trunk.ITrunkStableTest.IMyCallback { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } private int mCachedVersion = -1; private String mCachedHash = "-1"; @Override public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public android.aidl.test.trunk.ITrunkStableTest.MyParcelable repeatParcelable(android.aidl.test.trunk.ITrunkStableTest.MyParcelable input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.test.trunk.ITrunkStableTest.MyParcelable _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_repeatParcelable, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method repeatParcelable is unimplemented."); } _reply.readException(); _result = _reply.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyParcelable.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public byte repeatEnum(byte input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); byte _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeByte(input); boolean _status = mRemote.transact(Stub.TRANSACTION_repeatEnum, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method repeatEnum is unimplemented."); } _reply.readException(); _result = _reply.readByte(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.test.trunk.ITrunkStableTest.MyUnion repeatUnion(android.aidl.test.trunk.ITrunkStableTest.MyUnion input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.test.trunk.ITrunkStableTest.MyUnion _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_repeatUnion, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method repeatUnion is unimplemented."); } _reply.readException(); _result = _reply.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyUnion.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable repeatOtherParcelable(android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable input) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(asBinder()); android.os.Parcel _reply = android.os.Parcel.obtain(); android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeTypedObject(input, 0); boolean _status = mRemote.transact(Stub.TRANSACTION_repeatOtherParcelable, _data, _reply, 0); if (!_status) { throw new android.os.RemoteException("Method repeatOtherParcelable is unimplemented."); } _reply.readException(); _result = _reply.readTypedObject(android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int getInterfaceVersion() throws android.os.RemoteException { if (mCachedVersion == -1) { android.os.Parcel data = android.os.Parcel.obtain(asBinder()); android.os.Parcel reply = android.os.Parcel.obtain(); try { data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getInterfaceVersion, data, reply, 0); reply.readException(); mCachedVersion = reply.readInt(); } finally { reply.recycle(); data.recycle(); } } return mCachedVersion; } @Override public synchronized String getInterfaceHash() throws android.os.RemoteException { if ("-1".equals(mCachedHash)) { android.os.Parcel data = android.os.Parcel.obtain(asBinder()); android.os.Parcel reply = android.os.Parcel.obtain(); try { data.writeInterfaceToken(DESCRIPTOR); boolean _status = mRemote.transact(Stub.TRANSACTION_getInterfaceHash, data, reply, 0); reply.readException(); mCachedHash = reply.readString(); } finally { reply.recycle(); data.recycle(); } } return mCachedHash; } } static final int TRANSACTION_repeatParcelable = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); static final int TRANSACTION_repeatEnum = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1); static final int TRANSACTION_repeatUnion = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2); static final int TRANSACTION_repeatOtherParcelable = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3); static final int TRANSACTION_getInterfaceVersion = (android.os.IBinder.FIRST_CALL_TRANSACTION + 16777214); static final int TRANSACTION_getInterfaceHash = (android.os.IBinder.FIRST_CALL_TRANSACTION + 16777213); /** @hide */ public int getMaxTransactionId() { return 16777214; } } /** @hide */ public static final java.lang.String DESCRIPTOR = "android$aidl$test$trunk$ITrunkStableTest$IMyCallback".replace('$', '.'); public android.aidl.test.trunk.ITrunkStableTest.MyParcelable repeatParcelable(android.aidl.test.trunk.ITrunkStableTest.MyParcelable input) throws android.os.RemoteException; public byte repeatEnum(byte input) throws android.os.RemoteException; public android.aidl.test.trunk.ITrunkStableTest.MyUnion repeatUnion(android.aidl.test.trunk.ITrunkStableTest.MyUnion input) throws android.os.RemoteException; public android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable repeatOtherParcelable(android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable input) throws android.os.RemoteException; public int getInterfaceVersion() throws android.os.RemoteException; public String getInterfaceHash() throws android.os.RemoteException; } // New in V2 public static class MyOtherParcelable implements android.os.Parcelable { public int a = 0; public int b = 0; public static final android.os.Parcelable.Creator CREATOR = new android.os.Parcelable.Creator() { @Override public MyOtherParcelable createFromParcel(android.os.Parcel _aidl_source) { MyOtherParcelable _aidl_out = new MyOtherParcelable(); _aidl_out.readFromParcel(_aidl_source); return _aidl_out; } @Override public MyOtherParcelable[] newArray(int _aidl_size) { return new MyOtherParcelable[_aidl_size]; } }; @Override public final void writeToParcel(android.os.Parcel _aidl_parcel, int _aidl_flag) { int _aidl_start_pos = _aidl_parcel.dataPosition(); _aidl_parcel.writeInt(0); _aidl_parcel.writeInt(a); _aidl_parcel.writeInt(b); int _aidl_end_pos = _aidl_parcel.dataPosition(); _aidl_parcel.setDataPosition(_aidl_start_pos); _aidl_parcel.writeInt(_aidl_end_pos - _aidl_start_pos); _aidl_parcel.setDataPosition(_aidl_end_pos); } public final void readFromParcel(android.os.Parcel _aidl_parcel) { int _aidl_start_pos = _aidl_parcel.dataPosition(); int _aidl_parcelable_size = _aidl_parcel.readInt(); try { if (_aidl_parcelable_size < 4) throw new android.os.BadParcelableException("Parcelable too small");; if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; a = _aidl_parcel.readInt(); if (_aidl_parcel.dataPosition() - _aidl_start_pos >= _aidl_parcelable_size) return; b = _aidl_parcel.readInt(); } finally { if (_aidl_start_pos > (Integer.MAX_VALUE - _aidl_parcelable_size)) { throw new android.os.BadParcelableException("Overflow in the size of parcelable"); } _aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size); } } @Override public int describeContents() { int _mask = 0; return _mask; } } } ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-java-source_g0100644 0000000 0000000 00000000254 15172120304 033133 xustar000000000 0000000 144 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/gen/android/aidl/test/trunk/ITrunkStableTest.java.d 28 mtime=1776853188.7610000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/gen/android/aidl/0100644 0000000 0000000 00000000372 15172120304 033010 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/gen/android/aidl/test/trunk/ITrunkStableTest.java : \ system/tools/aidl/tests/trunk_stable_test/android/aidl/test/trunk/ITrunkStableTest.aidl ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-java-source_g0100644 0000000 0000000 00000000034 15172120304 033127 xustar000000000 0000000 28 mtime=1776853188.7610000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 032367 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-source_0100644 0000000 0000000 00000000034 15172120304 032613 xustar000000000 0000000 28 mtime=1776853188.7610000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/0040755 0000000 0000000 00000000000 15172120304 027540 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-source_ge0100644 0000000 0000000 00000000034 15172120304 033127 xustar000000000 0000000 28 mtime=1776853188.7610000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/0040755 0000000 0000000 00000000000 15172120304 030311 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-source_ge0100644 0000000 0000000 00000000034 15172120304 033127 xustar000000000 0000000 28 mtime=1776853188.7610000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 031731 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-source_ge0100644 0000000 0000000 00000000034 15172120304 033127 xustar000000000 0000000 28 mtime=1776853188.7610000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 032642 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-source_ge0100644 0000000 0000000 00000000216 15172120304 033131 xustar000000000 0000000 114 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/android/aidl/test/ 28 mtime=1776853188.7610000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/android/aidl/t0040755 0000000 0000000 00000000000 15172120304 033026 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-source_ge0100644 0000000 0000000 00000000224 15172120304 033130 xustar000000000 0000000 120 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/android/aidl/test/trunk/ 28 mtime=1776853188.7610000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/android/aidl/t0040755 0000000 0000000 00000000000 15172120304 033026 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-source_ge0100644 0000000 0000000 00000000250 15172120304 033127 xustar000000000 0000000 140 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/android/aidl/test/trunk/ITrunkStableTest.cpp 28 mtime=1776853188.7620000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/android/aidl/t0100644 0000000 0000000 00000247412 15172120304 033037 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --structured --version 2 --hash notfrozen -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/staging/android/aidl/test/trunk/ITrunkStableTest.cpp.d -h out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/staging -Nsystem/tools/aidl/tests/trunk_stable_test system/tools/aidl/tests/trunk_stable_test/android/aidl/test/trunk/ITrunkStableTest.aidl */ #include "aidl/android/aidl/test/trunk/ITrunkStableTest.h" #include #include #include #include namespace { struct ScopedTrace { inline explicit ScopedTrace(const char* name) { ATrace_beginSection(name); } inline ~ScopedTrace() { ATrace_endSection(); } }; } // namespace namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { static binder_status_t _aidl_android_aidl_test_trunk_ITrunkStableTest_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*repeatParcelable*/): { ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable in_input; ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::repeatParcelable::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->repeatParcelable(in_input, &_aidl_return); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatParcelable"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 1 /*repeatEnum*/): { ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input; ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::repeatEnum::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->repeatEnum(in_input, &_aidl_return); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatEnum"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 2 /*repeatUnion*/): { ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion in_input; ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::repeatUnion::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->repeatUnion(in_input, &_aidl_return); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatUnion"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 3 /*callMyCallback*/): { std::shared_ptr<::aidl::android::aidl::test::trunk::ITrunkStableTest::IMyCallback> in_cb; ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::callMyCallback::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_cb); if (_aidl_ret_status != STATUS_OK) break; BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_cb", ::android::internal::ToString(in_cb)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->callMyCallback(in_cb); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "callMyCallback"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; break; } case (FIRST_CALL_TRANSACTION + 4 /*repeatOtherParcelable*/): { ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable in_input; ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::repeatOtherParcelable::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->repeatOtherParcelable(in_input, &_aidl_return); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatOtherParcelable"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 16777214 /*getInterfaceVersion*/): { int32_t _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::getInterfaceVersion::server"); BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->getInterfaceVersion(&_aidl_return); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "getInterfaceVersion"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 16777213 /*getInterfaceHash*/): { std::string _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::getInterfaceHash::server"); BnTrunkStableTest::TransactionLog _transaction_log; if (BnTrunkStableTest::logFunc != nullptr) { } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->getInterfaceHash(&_aidl_return); if (BnTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "getInterfaceHash"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); BnTrunkStableTest::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_test_trunk_ITrunkStableTest_clazz = ::ndk::ICInterface::defineClass(ITrunkStableTest::descriptor, _aidl_android_aidl_test_trunk_ITrunkStableTest_onTransact); BpTrunkStableTest::BpTrunkStableTest(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} BpTrunkStableTest::~BpTrunkStableTest() {} std::function BpTrunkStableTest::logFunc; ::ndk::ScopedAStatus BpTrunkStableTest::repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::repeatParcelable::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*repeatParcelable*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) { _aidl_status = ITrunkStableTest::getDefaultImpl()->repeatParcelable(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatParcelable"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus BpTrunkStableTest::repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::repeatEnum::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 1 /*repeatEnum*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) { _aidl_status = ITrunkStableTest::getDefaultImpl()->repeatEnum(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatEnum"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus BpTrunkStableTest::repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::repeatUnion::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 2 /*repeatUnion*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) { _aidl_status = ITrunkStableTest::getDefaultImpl()->repeatUnion(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatUnion"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus BpTrunkStableTest::callMyCallback(const std::shared_ptr<::aidl::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& in_cb) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_cb", ::android::internal::ToString(in_cb)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::callMyCallback::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_cb); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 3 /*callMyCallback*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) { _aidl_status = ITrunkStableTest::getDefaultImpl()->callMyCallback(in_cb); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "callMyCallback"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus BpTrunkStableTest::repeatOtherParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::repeatOtherParcelable::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 4 /*repeatOtherParcelable*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) { _aidl_status = ITrunkStableTest::getDefaultImpl()->repeatOtherParcelable(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "repeatOtherParcelable"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus BpTrunkStableTest::getInterfaceVersion(int32_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; if (_aidl_cached_version != -1) { *_aidl_return = _aidl_cached_version; _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); return _aidl_status; } ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::getInterfaceVersion::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 16777214 /*getInterfaceVersion*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) { _aidl_status = ITrunkStableTest::getDefaultImpl()->getInterfaceVersion(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_cached_version = *_aidl_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "getInterfaceVersion"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus BpTrunkStableTest::getInterfaceHash(std::string* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; const std::lock_guard lock(_aidl_cached_hash_mutex); if (_aidl_cached_hash != "-1") { *_aidl_return = _aidl_cached_hash; _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); return _aidl_status; } ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; BpTrunkStableTest::TransactionLog _transaction_log; if (BpTrunkStableTest::logFunc != nullptr) { } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::ITrunkStableTest::getInterfaceHash::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 16777213 /*getInterfaceHash*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && ITrunkStableTest::getDefaultImpl()) { _aidl_status = ITrunkStableTest::getDefaultImpl()->getInterfaceHash(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_cached_hash = *_aidl_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (BpTrunkStableTest::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest"; _transaction_log.method_name = "getInterfaceHash"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); BpTrunkStableTest::logFunc(_transaction_log); } return _aidl_status; } // Source for BnTrunkStableTest BnTrunkStableTest::BnTrunkStableTest() {} BnTrunkStableTest::~BnTrunkStableTest() {} std::function BnTrunkStableTest::logFunc; ::ndk::SpAIBinder BnTrunkStableTest::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_test_trunk_ITrunkStableTest_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } ::ndk::ScopedAStatus BnTrunkStableTest::getInterfaceVersion(int32_t* _aidl_return) { *_aidl_return = ITrunkStableTest::version; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::ScopedAStatus BnTrunkStableTest::getInterfaceHash(std::string* _aidl_return) { *_aidl_return = ITrunkStableTest::hash; return ::ndk::ScopedAStatus(AStatus_newOk()); } // Source for ITrunkStableTest const char* ITrunkStableTest::descriptor = "android.aidl.test.trunk.ITrunkStableTest"; ITrunkStableTest::ITrunkStableTest() {} ITrunkStableTest::~ITrunkStableTest() {} std::shared_ptr ITrunkStableTest::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_test_trunk_ITrunkStableTest_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t ITrunkStableTest::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t ITrunkStableTest::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = ITrunkStableTest::fromBinder(binder); return STATUS_OK; } bool ITrunkStableTest::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!ITrunkStableTest::default_impl); if (impl) { ITrunkStableTest::default_impl = impl; return true; } return false; } const std::shared_ptr& ITrunkStableTest::getDefaultImpl() { return ITrunkStableTest::default_impl; } std::shared_ptr ITrunkStableTest::default_impl = nullptr; ::ndk::ScopedAStatus ITrunkStableTestDefault::repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& /*in_input*/, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTestDefault::repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum /*in_input*/, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTestDefault::repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& /*in_input*/, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTestDefault::callMyCallback(const std::shared_ptr<::aidl::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& /*in_cb*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTestDefault::repeatOtherParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& /*in_input*/, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTestDefault::getInterfaceVersion(int32_t* _aidl_return) { *_aidl_return = 0; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::ScopedAStatus ITrunkStableTestDefault::getInterfaceHash(std::string* _aidl_return) { *_aidl_return = ""; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::SpAIBinder ITrunkStableTestDefault::asBinder() { return ::ndk::SpAIBinder(); } bool ITrunkStableTestDefault::isRemote() { return false; } } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { const char* ITrunkStableTest::MyParcelable::descriptor = "android.aidl.test.trunk.ITrunkStableTest.MyParcelable"; binder_status_t ITrunkStableTest::MyParcelable::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &a); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &b); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &c); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t ITrunkStableTest::MyParcelable::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, a); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, b); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, c); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { const char* ITrunkStableTest::MyUnion::descriptor = "android.aidl.test.trunk.ITrunkStableTest.MyUnion"; binder_status_t ITrunkStableTest::MyUnion::readFromParcel(const AParcel* _parcel) { binder_status_t _aidl_ret_status; int32_t _aidl_tag; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_tag)) != STATUS_OK) return _aidl_ret_status; switch (static_cast(_aidl_tag)) { case a: { int32_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case b: { int32_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } case c: { int32_t _aidl_value; if ((_aidl_ret_status = ::ndk::AParcel_readData(_parcel, &_aidl_value)) != STATUS_OK) return _aidl_ret_status; if constexpr (std::is_trivially_copyable_v) { set(_aidl_value); } else { // NOLINTNEXTLINE(performance-move-const-arg) set(std::move(_aidl_value)); } return STATUS_OK; } } return STATUS_BAD_VALUE; } binder_status_t ITrunkStableTest::MyUnion::writeToParcel(AParcel* _parcel) const { binder_status_t _aidl_ret_status = ::ndk::AParcel_writeData(_parcel, static_cast(getTag())); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; switch (getTag()) { case a: return ::ndk::AParcel_writeData(_parcel, get()); case b: return ::ndk::AParcel_writeData(_parcel, get()); case c: return ::ndk::AParcel_writeData(_parcel, get()); } __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "can't reach here"); } } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { static binder_status_t _aidl_android_aidl_test_trunk_ITrunkStableTest_IMyCallback_onTransact(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, AParcel* _aidl_out) { (void)_aidl_in; (void)_aidl_out; binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION; std::shared_ptr _aidl_impl = std::static_pointer_cast(::ndk::ICInterface::asInterface(_aidl_binder)); switch (_aidl_code) { case (FIRST_CALL_TRANSACTION + 0 /*repeatParcelable*/): { ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable in_input; ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::repeatParcelable::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->repeatParcelable(in_input, &_aidl_return); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatParcelable"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 1 /*repeatEnum*/): { ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input; ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::repeatEnum::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->repeatEnum(in_input, &_aidl_return); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatEnum"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 2 /*repeatUnion*/): { ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion in_input; ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::repeatUnion::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->repeatUnion(in_input, &_aidl_return); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatUnion"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 3 /*repeatOtherParcelable*/): { ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable in_input; ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::repeatOtherParcelable::server"); _aidl_ret_status = ::ndk::AParcel_readData(_aidl_in, &in_input); if (_aidl_ret_status != STATUS_OK) break; ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->repeatOtherParcelable(in_input, &_aidl_return); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatOtherParcelable"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 16777214 /*getInterfaceVersion*/): { int32_t _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::getInterfaceVersion::server"); ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->getInterfaceVersion(&_aidl_return); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "getInterfaceVersion"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } case (FIRST_CALL_TRANSACTION + 16777213 /*getInterfaceHash*/): { std::string _aidl_return; ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::getInterfaceHash::server"); ITrunkStableTest::BnMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { } auto _log_start = std::chrono::steady_clock::now(); ::ndk::ScopedAStatus _aidl_status = _aidl_impl->getInterfaceHash(&_aidl_return); if (ITrunkStableTest::BnMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "getInterfaceHash"; _transaction_log.stub_address = _aidl_impl.get(); _transaction_log.proxy_address = nullptr; _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(_aidl_return); ITrunkStableTest::BnMyCallback::logFunc(_transaction_log); } _aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get()); if (_aidl_ret_status != STATUS_OK) break; if (!AStatus_isOk(_aidl_status.get())) break; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_out, _aidl_return); if (_aidl_ret_status != STATUS_OK) break; break; } } return _aidl_ret_status; } static AIBinder_Class* _g_aidl_android_aidl_test_trunk_ITrunkStableTest_IMyCallback_clazz = ::ndk::ICInterface::defineClass(ITrunkStableTest::IMyCallback::descriptor, _aidl_android_aidl_test_trunk_ITrunkStableTest_IMyCallback_onTransact); ITrunkStableTest::BpMyCallback::BpMyCallback(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {} ITrunkStableTest::BpMyCallback::~BpMyCallback() {} std::function ITrunkStableTest::BpMyCallback::logFunc; ::ndk::ScopedAStatus ITrunkStableTest::BpMyCallback::repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::repeatParcelable::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 0 /*repeatParcelable*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) { _aidl_status = IMyCallback::getDefaultImpl()->repeatParcelable(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatParcelable"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTest::BpMyCallback::repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::repeatEnum::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 1 /*repeatEnum*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) { _aidl_status = IMyCallback::getDefaultImpl()->repeatEnum(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatEnum"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTest::BpMyCallback::repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::repeatUnion::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 2 /*repeatUnion*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) { _aidl_status = IMyCallback::getDefaultImpl()->repeatUnion(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatUnion"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTest::BpMyCallback::repeatOtherParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { _transaction_log.input_args.emplace_back("in_input", ::android::internal::ToString(in_input)); } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::repeatOtherParcelable::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_in.get(), in_input); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 3 /*repeatOtherParcelable*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) { _aidl_status = IMyCallback::getDefaultImpl()->repeatOtherParcelable(in_input, _aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "repeatOtherParcelable"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTest::BpMyCallback::getInterfaceVersion(int32_t* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; if (_aidl_cached_version != -1) { *_aidl_return = _aidl_cached_version; _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); return _aidl_status; } ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::getInterfaceVersion::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 16777214 /*getInterfaceVersion*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) { _aidl_status = IMyCallback::getDefaultImpl()->getInterfaceVersion(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_cached_version = *_aidl_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "getInterfaceVersion"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTest::BpMyCallback::getInterfaceHash(std::string* _aidl_return) { binder_status_t _aidl_ret_status = STATUS_OK; ::ndk::ScopedAStatus _aidl_status; const std::lock_guard lock(_aidl_cached_hash_mutex); if (_aidl_cached_hash != "-1") { *_aidl_return = _aidl_cached_hash; _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); return _aidl_status; } ::ndk::ScopedAParcel _aidl_in; ::ndk::ScopedAParcel _aidl_out; ITrunkStableTest::BpMyCallback::TransactionLog _transaction_log; if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { } auto _log_start = std::chrono::steady_clock::now(); ScopedTrace _aidl_trace("AIDL::ndk::IMyCallback::getInterfaceHash::client"); _aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AIBinder_transact( asBinder().get(), (FIRST_CALL_TRANSACTION + 16777213 /*getInterfaceHash*/), _aidl_in.getR(), _aidl_out.getR(), 0 #ifdef BINDER_STABILITY_SUPPORT | FLAG_PRIVATE_LOCAL #endif // BINDER_STABILITY_SUPPORT ); if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && IMyCallback::getDefaultImpl()) { _aidl_status = IMyCallback::getDefaultImpl()->getInterfaceHash(_aidl_return); goto _aidl_status_return; } if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR()); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; if (!AStatus_isOk(_aidl_status.get())) goto _aidl_status_return; _aidl_ret_status = ::ndk::AParcel_readData(_aidl_out.get(), _aidl_return); if (_aidl_ret_status != STATUS_OK) goto _aidl_error; _aidl_cached_hash = *_aidl_return; _aidl_error: _aidl_status.set(AStatus_fromStatus(_aidl_ret_status)); _aidl_status_return: if (ITrunkStableTest::BpMyCallback::logFunc != nullptr) { auto _log_end = std::chrono::steady_clock::now(); _transaction_log.duration_ms = std::chrono::duration(_log_end - _log_start).count(); _transaction_log.interface_name = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; _transaction_log.method_name = "getInterfaceHash"; _transaction_log.stub_address = nullptr; _transaction_log.proxy_address = static_cast(this); _transaction_log.exception_code = AStatus_getExceptionCode(_aidl_status.get()); _transaction_log.exception_message = AStatus_getMessage(_aidl_status.get()); _transaction_log.transaction_error = AStatus_getStatus(_aidl_status.get()); _transaction_log.service_specific_error_code = AStatus_getServiceSpecificError(_aidl_status.get()); _transaction_log.result = ::android::internal::ToString(*_aidl_return); ITrunkStableTest::BpMyCallback::logFunc(_transaction_log); } return _aidl_status; } // Source for BnMyCallback ITrunkStableTest::BnMyCallback::BnMyCallback() {} ITrunkStableTest::BnMyCallback::~BnMyCallback() {} std::function ITrunkStableTest::BnMyCallback::logFunc; ::ndk::SpAIBinder ITrunkStableTest::BnMyCallback::createBinder() { AIBinder* binder = AIBinder_new(_g_aidl_android_aidl_test_trunk_ITrunkStableTest_IMyCallback_clazz, static_cast(this)); #ifdef BINDER_STABILITY_SUPPORT AIBinder_markCompilationUnitStability(binder); #endif // BINDER_STABILITY_SUPPORT return ::ndk::SpAIBinder(binder); } ::ndk::ScopedAStatus ITrunkStableTest::BnMyCallback::getInterfaceVersion(int32_t* _aidl_return) { *_aidl_return = IMyCallback::version; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::ScopedAStatus ITrunkStableTest::BnMyCallback::getInterfaceHash(std::string* _aidl_return) { *_aidl_return = IMyCallback::hash; return ::ndk::ScopedAStatus(AStatus_newOk()); } // Source for IMyCallback const char* ITrunkStableTest::IMyCallback::descriptor = "android.aidl.test.trunk.ITrunkStableTest.IMyCallback"; ITrunkStableTest::IMyCallback::IMyCallback() {} ITrunkStableTest::IMyCallback::~IMyCallback() {} std::shared_ptr ITrunkStableTest::IMyCallback::fromBinder(const ::ndk::SpAIBinder& binder) { if (!AIBinder_associateClass(binder.get(), _g_aidl_android_aidl_test_trunk_ITrunkStableTest_IMyCallback_clazz)) { #if __ANDROID_API__ >= 31 const AIBinder_Class* originalClass = AIBinder_getClass(binder.get()); if (originalClass == nullptr) return nullptr; if (0 == strcmp(AIBinder_Class_getDescriptor(originalClass), descriptor)) { return ::ndk::SharedRefBase::make(binder); } #endif return nullptr; } std::shared_ptr<::ndk::ICInterface> interface = ::ndk::ICInterface::asInterface(binder.get()); if (interface) { return std::static_pointer_cast(interface); } return ::ndk::SharedRefBase::make(binder); } binder_status_t ITrunkStableTest::IMyCallback::writeToParcel(AParcel* parcel, const std::shared_ptr& instance) { return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : nullptr); } binder_status_t ITrunkStableTest::IMyCallback::readFromParcel(const AParcel* parcel, std::shared_ptr* instance) { ::ndk::SpAIBinder binder; binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR()); if (status != STATUS_OK) return status; *instance = IMyCallback::fromBinder(binder); return STATUS_OK; } bool ITrunkStableTest::IMyCallback::setDefaultImpl(const std::shared_ptr& impl) { // Only one user of this interface can use this function // at a time. This is a heuristic to detect if two different // users in the same process use this function. assert(!IMyCallback::default_impl); if (impl) { IMyCallback::default_impl = impl; return true; } return false; } const std::shared_ptr& ITrunkStableTest::IMyCallback::getDefaultImpl() { return IMyCallback::default_impl; } std::shared_ptr ITrunkStableTest::IMyCallback::default_impl = nullptr; ::ndk::ScopedAStatus ITrunkStableTest::IMyCallbackDefault::repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& /*in_input*/, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTest::IMyCallbackDefault::repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum /*in_input*/, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTest::IMyCallbackDefault::repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& /*in_input*/, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTest::IMyCallbackDefault::repeatOtherParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& /*in_input*/, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* /*_aidl_return*/) { ::ndk::ScopedAStatus _aidl_status; _aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION)); return _aidl_status; } ::ndk::ScopedAStatus ITrunkStableTest::IMyCallbackDefault::getInterfaceVersion(int32_t* _aidl_return) { *_aidl_return = 0; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::ScopedAStatus ITrunkStableTest::IMyCallbackDefault::getInterfaceHash(std::string* _aidl_return) { *_aidl_return = ""; return ::ndk::ScopedAStatus(AStatus_newOk()); } ::ndk::SpAIBinder ITrunkStableTest::IMyCallbackDefault::asBinder() { return ::ndk::SpAIBinder(); } bool ITrunkStableTest::IMyCallbackDefault::isRemote() { return false; } } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { const char* ITrunkStableTest::MyOtherParcelable::descriptor = "android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable"; binder_status_t ITrunkStableTest::MyOtherParcelable::readFromParcel(const AParcel* _aidl_parcel) { binder_status_t _aidl_ret_status = STATUS_OK; int32_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); int32_t _aidl_parcelable_size = 0; _aidl_ret_status = AParcel_readInt32(_aidl_parcel, &_aidl_parcelable_size); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (_aidl_parcelable_size < 4) return STATUS_BAD_VALUE; if (_aidl_start_pos > INT32_MAX - _aidl_parcelable_size) return STATUS_BAD_VALUE; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &a); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; if (AParcel_getDataPosition(_aidl_parcel) - _aidl_start_pos >= _aidl_parcelable_size) { AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } _aidl_ret_status = ::ndk::AParcel_readData(_aidl_parcel, &b); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos + _aidl_parcelable_size); return _aidl_ret_status; } binder_status_t ITrunkStableTest::MyOtherParcelable::writeToParcel(AParcel* _aidl_parcel) const { binder_status_t _aidl_ret_status; size_t _aidl_start_pos = AParcel_getDataPosition(_aidl_parcel); _aidl_ret_status = AParcel_writeInt32(_aidl_parcel, 0); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, a); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; _aidl_ret_status = ::ndk::AParcel_writeData(_aidl_parcel, b); if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status; size_t _aidl_end_pos = AParcel_getDataPosition(_aidl_parcel); AParcel_setDataPosition(_aidl_parcel, _aidl_start_pos); AParcel_writeInt32(_aidl_parcel, _aidl_end_pos - _aidl_start_pos); AParcel_setDataPosition(_aidl_parcel, _aidl_end_pos); return _aidl_ret_status; } } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-source_ge0100644 0000000 0000000 00000000252 15172120304 033131 xustar000000000 0000000 142 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/android/aidl/test/trunk/ITrunkStableTest.cpp.d 28 mtime=1776853188.7630000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/android/aidl/t0100644 0000000 0000000 00000000370 15172120304 033025 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/android/aidl/test/trunk/ITrunkStableTest.cpp : \ system/tools/aidl/tests/trunk_stable_test/android/aidl/test/trunk/ITrunkStableTest.aidl ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-source_ge0100644 0000000 0000000 00000000034 15172120304 033127 xustar000000000 0000000 28 mtime=1776853188.7630000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include/0040755 0000000 0000000 00000000000 15172120304 031734 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-source_ge0100644 0000000 0000000 00000000034 15172120304 033127 xustar000000000 0000000 28 mtime=1776853188.7630000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include/aidl/0040755 0000000 0000000 00000000000 15172120304 032645 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-source_ge0100644 0000000 0000000 00000000221 15172120304 033125 xustar000000000 0000000 117 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include/aidl/android/ 28 mtime=1776853188.7630000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include/aidl/a0040755 0000000 0000000 00000000000 15172120304 033006 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-source_ge0100644 0000000 0000000 00000000226 15172120304 033132 xustar000000000 0000000 122 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include/aidl/android/aidl/ 28 mtime=1776853188.7630000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include/aidl/a0040755 0000000 0000000 00000000000 15172120304 033006 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-source_ge0100644 0000000 0000000 00000000233 15172120304 033130 xustar000000000 0000000 127 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include/aidl/android/aidl/test/ 28 mtime=1776853188.7630000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include/aidl/a0040755 0000000 0000000 00000000000 15172120304 033006 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-source_ge0100644 0000000 0000000 00000000241 15172120304 033127 xustar000000000 0000000 133 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include/aidl/android/aidl/test/trunk/ 28 mtime=1776853188.7630000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include/aidl/a0040755 0000000 0000000 00000000000 15172120304 033006 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-source_ge0100644 0000000 0000000 00000000264 15172120304 033134 xustar000000000 0000000 152 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include/aidl/android/aidl/test/trunk/BnTrunkStableTest.h 28 mtime=1776853188.7640000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include/aidl/a0100644 0000000 0000000 00000007656 15172120304 033023 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --structured --version 2 --hash notfrozen -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/staging/android/aidl/test/trunk/ITrunkStableTest.cpp.d -h out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/staging -Nsystem/tools/aidl/tests/trunk_stable_test system/tools/aidl/tests/trunk_stable_test/android/aidl/test/trunk/ITrunkStableTest.aidl */ #pragma once #include "aidl/android/aidl/test/trunk/ITrunkStableTest.h" #include #include #ifndef __BIONIC__ #ifndef __assert2 #define __assert2(a,b,c,d) ((void)0) #endif #endif namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { class BnTrunkStableTest : public ::ndk::BnCInterface { public: BnTrunkStableTest(); virtual ~BnTrunkStableTest(); ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) final; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) final; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; protected: ::ndk::SpAIBinder createBinder() override; private: }; class ITrunkStableTestDelegator : public BnTrunkStableTest { public: explicit ITrunkStableTestDelegator(const std::shared_ptr &impl) : _impl(impl) { int32_t _impl_ver = 0; if (!impl->getInterfaceVersion(&_impl_ver).isOk()) {; __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Delegator failed to get version of the implementation."); } if (_impl_ver != ITrunkStableTest::version) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Mismatched versions of delegator and implementation is not allowed."); } } ::ndk::ScopedAStatus repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override { return _impl->repeatParcelable(in_input, _aidl_return); } ::ndk::ScopedAStatus repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override { return _impl->repeatEnum(in_input, _aidl_return); } ::ndk::ScopedAStatus repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override { return _impl->repeatUnion(in_input, _aidl_return); } ::ndk::ScopedAStatus callMyCallback(const std::shared_ptr<::aidl::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& in_cb) override { return _impl->callMyCallback(in_cb); } ::ndk::ScopedAStatus repeatOtherParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) override { return _impl->repeatOtherParcelable(in_input, _aidl_return); } protected: private: std::shared_ptr _impl; }; } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-source_ge0100644 0000000 0000000 00000000264 15172120304 033134 xustar000000000 0000000 152 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include/aidl/android/aidl/test/trunk/BpTrunkStableTest.h 28 mtime=1776853188.7640000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include/aidl/a0100644 0000000 0000000 00000006113 15172120304 033006 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --structured --version 2 --hash notfrozen -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/staging/android/aidl/test/trunk/ITrunkStableTest.cpp.d -h out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/staging -Nsystem/tools/aidl/tests/trunk_stable_test system/tools/aidl/tests/trunk_stable_test/android/aidl/test/trunk/ITrunkStableTest.aidl */ #pragma once #include "aidl/android/aidl/test/trunk/ITrunkStableTest.h" #include #include #include #include #include namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { class BpTrunkStableTest : public ::ndk::BpCInterface { public: explicit BpTrunkStableTest(const ::ndk::SpAIBinder& binder); virtual ~BpTrunkStableTest(); ::ndk::ScopedAStatus repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override; ::ndk::ScopedAStatus repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override; ::ndk::ScopedAStatus repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override; ::ndk::ScopedAStatus callMyCallback(const std::shared_ptr<::aidl::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& in_cb) override; ::ndk::ScopedAStatus repeatOtherParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) override; int32_t _aidl_cached_version = -1; std::string _aidl_cached_hash = "-1"; std::mutex _aidl_cached_hash_mutex; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; }; } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-source_ge0100644 0000000 0000000 00000000263 15172120304 033133 xustar000000000 0000000 151 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include/aidl/android/aidl/test/trunk/ITrunkStableTest.h 28 mtime=1776853188.7640000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include/aidl/a0100644 0000000 0000000 00000047136 15172120304 033020 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=ndk -Weverything -Wno-missing-permission-annotation -Werror --structured --version 2 --hash notfrozen -t --min_sdk_version current --log --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/staging/android/aidl/test/trunk/ITrunkStableTest.cpp.d -h out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/include/staging -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/staging -Nsystem/tools/aidl/tests/trunk_stable_test system/tools/aidl/tests/trunk_stable_test/android/aidl/test/trunk/ITrunkStableTest.aidl */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BINDER_STABILITY_SUPPORT #include #endif // BINDER_STABILITY_SUPPORT #ifndef __BIONIC__ #define __assert2(a,b,c,d) ((void)0) #endif namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { class ITrunkStableTestDelegator; class ITrunkStableTest : public ::ndk::ICInterface { public: typedef ITrunkStableTestDelegator DefaultDelegator; static const char* descriptor; ITrunkStableTest(); virtual ~ITrunkStableTest(); class MyParcelable { public: typedef std::false_type fixed_size; static const char* descriptor; int32_t a = 0; int32_t b = 0; int32_t c = 0; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const MyParcelable& _rhs) const { return std::tie(a, b, c) == std::tie(_rhs.a, _rhs.b, _rhs.c); } inline bool operator<(const MyParcelable& _rhs) const { return std::tie(a, b, c) < std::tie(_rhs.a, _rhs.b, _rhs.c); } inline bool operator!=(const MyParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyParcelable& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "MyParcelable{"; _aidl_os << "a: " << ::android::internal::ToString(a); _aidl_os << ", b: " << ::android::internal::ToString(b); _aidl_os << ", c: " << ::android::internal::ToString(c); _aidl_os << "}"; return _aidl_os.str(); } }; enum class MyEnum : int8_t { ZERO = 0, ONE = 1, TWO = 2, THREE = 3, }; class MyUnion { public: typedef std::false_type fixed_size; static const char* descriptor; enum class Tag : int32_t { a = 0, b = 1, c = 2, }; // Expose tag symbols for legacy code static const inline Tag a = Tag::a; static const inline Tag b = Tag::b; static const inline Tag c = Tag::c; template static constexpr bool _not_self = !std::is_same_v>, MyUnion>; MyUnion() : _value(std::in_place_index(a)>, int32_t(0)) { } template >> // NOLINTNEXTLINE(google-explicit-constructor) constexpr MyUnion(_Tp&& _arg) : _value(std::forward<_Tp>(_arg)) {} template constexpr explicit MyUnion(std::in_place_index_t<_Np>, _Tp&&... _args) : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {} template static MyUnion make(_Tp&&... _args) { return MyUnion(std::in_place_index(_tag)>, std::forward<_Tp>(_args)...); } template static MyUnion make(std::initializer_list<_Tp> _il, _Up&&... _args) { return MyUnion(std::in_place_index(_tag)>, std::move(_il), std::forward<_Up>(_args)...); } Tag getTag() const { return static_cast(_value.index()); } template const auto& get() const { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template auto& get() { if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); } return std::get(_tag)>(_value); } template void set(_Tp&&... _args) { _value.emplace(_tag)>(std::forward<_Tp>(_args)...); } binder_status_t readFromParcel(const AParcel* _parcel); binder_status_t writeToParcel(AParcel* _parcel) const; inline bool operator==(const MyUnion& _rhs) const { return _value == _rhs._value; } inline bool operator<(const MyUnion& _rhs) const { return _value < _rhs._value; } inline bool operator!=(const MyUnion& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyUnion& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyUnion& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyUnion& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream os; os << "MyUnion{"; switch (getTag()) { case a: os << "a: " << ::android::internal::ToString(get()); break; case b: os << "b: " << ::android::internal::ToString(get()); break; case c: os << "c: " << ::android::internal::ToString(get()); break; } os << "}"; return os.str(); } private: std::variant _value; }; class MyOtherParcelable { public: typedef std::false_type fixed_size; static const char* descriptor; int32_t a = 0; int32_t b = 0; binder_status_t readFromParcel(const AParcel* parcel); binder_status_t writeToParcel(AParcel* parcel) const; inline bool operator==(const MyOtherParcelable& _rhs) const { return std::tie(a, b) == std::tie(_rhs.a, _rhs.b); } inline bool operator<(const MyOtherParcelable& _rhs) const { return std::tie(a, b) < std::tie(_rhs.a, _rhs.b); } inline bool operator!=(const MyOtherParcelable& _rhs) const { return !(*this == _rhs); } inline bool operator>(const MyOtherParcelable& _rhs) const { return _rhs < *this; } inline bool operator>=(const MyOtherParcelable& _rhs) const { return !(*this < _rhs); } inline bool operator<=(const MyOtherParcelable& _rhs) const { return !(_rhs < *this); } static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_LOCAL; inline std::string toString() const { std::ostringstream _aidl_os; _aidl_os << "MyOtherParcelable{"; _aidl_os << "a: " << ::android::internal::ToString(a); _aidl_os << ", b: " << ::android::internal::ToString(b); _aidl_os << "}"; return _aidl_os.str(); } }; class IMyCallbackDelegator; class IMyCallback : public ::ndk::ICInterface { public: typedef IMyCallbackDelegator DefaultDelegator; static const char* descriptor; IMyCallback(); virtual ~IMyCallback(); static inline const int32_t version = 2; static inline const std::string hash = "notfrozen"; static constexpr uint32_t TRANSACTION_repeatParcelable = FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_repeatEnum = FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_repeatUnion = FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_repeatOtherParcelable = FIRST_CALL_TRANSACTION + 3; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) = 0; virtual ::ndk::ScopedAStatus repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) = 0; virtual ::ndk::ScopedAStatus repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) = 0; virtual ::ndk::ScopedAStatus repeatOtherParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) = 0; virtual ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) = 0; private: static std::shared_ptr default_impl; }; class IMyCallbackDefault : public IMyCallback { public: ::ndk::ScopedAStatus repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override; ::ndk::ScopedAStatus repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override; ::ndk::ScopedAStatus repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override; ::ndk::ScopedAStatus repeatOtherParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; class BpMyCallback : public ::ndk::BpCInterface { public: explicit BpMyCallback(const ::ndk::SpAIBinder& binder); virtual ~BpMyCallback(); ::ndk::ScopedAStatus repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override; ::ndk::ScopedAStatus repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override; ::ndk::ScopedAStatus repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override; ::ndk::ScopedAStatus repeatOtherParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) override; int32_t _aidl_cached_version = -1; std::string _aidl_cached_hash = "-1"; std::mutex _aidl_cached_hash_mutex; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; }; class BnMyCallback : public ::ndk::BnCInterface { public: BnMyCallback(); virtual ~BnMyCallback(); ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) final; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) final; struct TransactionLog { double duration_ms; std::string interface_name; std::string method_name; const void* proxy_address; const void* stub_address; std::vector> input_args; std::vector> output_args; std::string result; std::string exception_message; int32_t exception_code; int32_t transaction_error; int32_t service_specific_error_code; }; static std::function logFunc; protected: ::ndk::SpAIBinder createBinder() override; private: }; static inline const int32_t version = 2; static inline const std::string hash = "notfrozen"; static constexpr uint32_t TRANSACTION_repeatParcelable = FIRST_CALL_TRANSACTION + 0; static constexpr uint32_t TRANSACTION_repeatEnum = FIRST_CALL_TRANSACTION + 1; static constexpr uint32_t TRANSACTION_repeatUnion = FIRST_CALL_TRANSACTION + 2; static constexpr uint32_t TRANSACTION_callMyCallback = FIRST_CALL_TRANSACTION + 3; static constexpr uint32_t TRANSACTION_repeatOtherParcelable = FIRST_CALL_TRANSACTION + 4; static std::shared_ptr fromBinder(const ::ndk::SpAIBinder& binder); static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr& instance); static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr* instance); static bool setDefaultImpl(const std::shared_ptr& impl); static const std::shared_ptr& getDefaultImpl(); virtual ::ndk::ScopedAStatus repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) = 0; virtual ::ndk::ScopedAStatus repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) = 0; virtual ::ndk::ScopedAStatus repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) = 0; virtual ::ndk::ScopedAStatus callMyCallback(const std::shared_ptr<::aidl::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& in_cb) = 0; virtual ::ndk::ScopedAStatus repeatOtherParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) = 0; virtual ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) = 0; virtual ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) = 0; private: static std::shared_ptr default_impl; }; class ITrunkStableTestDefault : public ITrunkStableTest { public: ::ndk::ScopedAStatus repeatParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyParcelable* _aidl_return) override; ::ndk::ScopedAStatus repeatEnum(::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum* _aidl_return) override; ::ndk::ScopedAStatus repeatUnion(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion* _aidl_return) override; ::ndk::ScopedAStatus callMyCallback(const std::shared_ptr<::aidl::android::aidl::test::trunk::ITrunkStableTest::IMyCallback>& in_cb) override; ::ndk::ScopedAStatus repeatOtherParcelable(const ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable& in_input, ::aidl::android::aidl::test::trunk::ITrunkStableTest::MyOtherParcelable* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceVersion(int32_t* _aidl_return) override; ::ndk::ScopedAStatus getInterfaceHash(std::string* _aidl_return) override; ::ndk::SpAIBinder asBinder() override; bool isRemote() override; }; } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { [[nodiscard]] static inline std::string toString(ITrunkStableTest::MyEnum val) { switch(val) { case ITrunkStableTest::MyEnum::ZERO: return "ZERO"; case ITrunkStableTest::MyEnum::ONE: return "ONE"; case ITrunkStableTest::MyEnum::TWO: return "TWO"; case ITrunkStableTest::MyEnum::THREE: return "THREE"; default: return std::to_string(static_cast(val)); } } } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum::ZERO, aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum::ONE, aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum::TWO, aidl::android::aidl::test::trunk::ITrunkStableTest::MyEnum::THREE, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk namespace aidl { namespace android { namespace aidl { namespace test { namespace trunk { [[nodiscard]] static inline std::string toString(ITrunkStableTest::MyUnion::Tag val) { switch(val) { case ITrunkStableTest::MyUnion::Tag::a: return "a"; case ITrunkStableTest::MyUnion::Tag::b: return "b"; case ITrunkStableTest::MyUnion::Tag::c: return "c"; default: return std::to_string(static_cast(val)); } } } // namespace trunk } // namespace test } // namespace aidl } // namespace android } // namespace aidl namespace ndk { namespace internal { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++17-extensions" template <> constexpr inline std::array enum_values = { aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion::Tag::a, aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion::Tag::b, aidl::android::aidl::test::trunk::ITrunkStableTest::MyUnion::Tag::c, }; #pragma clang diagnostic pop } // namespace internal } // namespace ndk ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-ndk-source_ge0100644 0000000 0000000 00000000034 15172120304 033127 xustar000000000 0000000 28 mtime=1776853188.7640000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 032222 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-rust-source_0100644 0000000 0000000 00000000034 15172120304 033034 xustar000000000 0000000 28 mtime=1776853188.7640000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/0040755 0000000 0000000 00000000000 15172120304 027761 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-rust-source_g0100644 0000000 0000000 00000000034 15172120304 033203 xustar000000000 0000000 28 mtime=1776853188.7640000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/gen/0040755 0000000 0000000 00000000000 15172120304 030532 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-rust-source_g0100644 0000000 0000000 00000000034 15172120304 033203 xustar000000000 0000000 28 mtime=1776853188.7640000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/gen/android/0040755 0000000 0000000 00000000000 15172120304 032152 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-rust-source_g0100644 0000000 0000000 00000000212 15172120304 033201 xustar000000000 0000000 110 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/gen/android/aidl/ 28 mtime=1776853188.7650000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 033063 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-rust-source_g0100644 0000000 0000000 00000000217 15172120304 033206 xustar000000000 0000000 115 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/gen/android/aidl/test/ 28 mtime=1776853188.7650000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 033063 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-rust-source_g0100644 0000000 0000000 00000000225 15172120304 033205 xustar000000000 0000000 121 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/gen/android/aidl/test/trunk/ 28 mtime=1776853188.7650000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/gen/android/aidl/0040755 0000000 0000000 00000000000 15172120304 033063 5ustar000000000 0000000 ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-rust-source_g0100644 0000000 0000000 00000000250 15172120304 033203 xustar000000000 0000000 140 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/gen/android/aidl/test/trunk/ITrunkStableTest.rs 28 mtime=1776853188.7650000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/gen/android/aidl/0100644 0000000 0000000 00000177650 15172120304 033102 0ustar000000000 0000000 /* * This file is auto-generated. DO NOT MODIFY. * Using: out/host/linux-x86/bin/aidl --lang=rust -Weverything -Wno-missing-permission-annotation -Werror --structured --version 2 --hash notfrozen --min_sdk_version current --ninja -d out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/gen/android/aidl/test/trunk/ITrunkStableTest.rs.d -o out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/gen -Nsystem/tools/aidl/tests/trunk_stable_test system/tools/aidl/tests/trunk_stable_test/android/aidl/test/trunk/ITrunkStableTest.aidl */ #![forbid(unsafe_code)] #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { ITrunkStableTest["android.aidl.test.trunk.ITrunkStableTest"] { native: BnTrunkStableTest(on_transact), proxy: BpTrunkStableTest { cached_version: std::sync::atomic::AtomicI32 = std::sync::atomic::AtomicI32::new(-1), cached_hash: std::sync::Mutex> = std::sync::Mutex::new(None) }, async: ITrunkStableTestAsync, } } pub trait ITrunkStableTest: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.test.trunk.ITrunkStableTest" } fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result; fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result; fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result; fn r#callMyCallback(&self, _arg_cb: &binder::Strong) -> binder::Result<()>; fn r#repeatOtherParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::Result; fn r#getInterfaceVersion(&self) -> binder::Result { Ok(VERSION) } fn r#getInterfaceHash(&self) -> binder::Result { Ok(HASH.into()) } fn getDefaultImpl() -> ITrunkStableTestDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: ITrunkStableTestDefaultRef) -> ITrunkStableTestDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait ITrunkStableTestAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.test.trunk.ITrunkStableTest" } fn r#repeatParcelable<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::BoxFuture<'a, binder::Result>; fn r#repeatEnum<'a>(&'a self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::BoxFuture<'a, binder::Result>; fn r#repeatUnion<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::BoxFuture<'a, binder::Result>; fn r#callMyCallback<'a>(&'a self, _arg_cb: &'a binder::Strong) -> binder::BoxFuture<'a, binder::Result<()>>; fn r#repeatOtherParcelable<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::BoxFuture<'a, binder::Result>; fn r#getInterfaceVersion<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { Box::pin(async move { Ok(VERSION) }) } fn r#getInterfaceHash<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { Box::pin(async move { Ok(HASH.into()) }) } } #[::async_trait::async_trait] pub trait ITrunkStableTestAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.test.trunk.ITrunkStableTest" } async fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result; async fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result; async fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result; async fn r#callMyCallback(&self, _arg_cb: &binder::Strong) -> binder::Result<()>; async fn r#repeatOtherParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::Result; } impl BnTrunkStableTest { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: ITrunkStableTestAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl ITrunkStableTest for Wrapper where T: ITrunkStableTestAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { self._rt.block_on(self._inner.r#repeatParcelable(_arg_input)) } fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { self._rt.block_on(self._inner.r#repeatEnum(_arg_input)) } fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { self._rt.block_on(self._inner.r#repeatUnion(_arg_input)) } fn r#callMyCallback(&self, _arg_cb: &binder::Strong) -> binder::Result<()> { self._rt.block_on(self._inner.r#callMyCallback(_arg_cb)) } fn r#repeatOtherParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::Result { self._rt.block_on(self._inner.r#repeatOtherParcelable(_arg_input)) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait ITrunkStableTestDefault: Send + Sync { fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#callMyCallback(&self, _arg_cb: &binder::Strong) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#repeatOtherParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#repeatParcelable: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; pub const r#repeatEnum: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 1; pub const r#repeatUnion: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 2; pub const r#callMyCallback: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 3; pub const r#repeatOtherParcelable: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 4; pub const r#getInterfaceVersion: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 16777214; pub const r#getInterfaceHash: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 16777213; } pub type ITrunkStableTestDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); pub const VERSION: i32 = 2; pub const HASH: &str = "notfrozen"; impl BpTrunkStableTest { fn build_parcel_repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#repeatParcelable(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(&_arg_input)?; Ok(aidl_data) } fn read_response_repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#repeatEnum(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#repeatUnion(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_callMyCallback(&self, _arg_cb: &binder::Strong) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_cb)?; Ok(aidl_data) } fn read_response_callMyCallback(&self, _arg_cb: &binder::Strong, _aidl_reply: std::result::Result) -> binder::Result<()> { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#callMyCallback(_arg_cb); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } Ok(()) } fn build_parcel_repeatOtherParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_repeatOtherParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#repeatOtherParcelable(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_getInterfaceVersion(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_getInterfaceVersion(&self, _aidl_reply: std::result::Result) -> binder::Result { let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: i32 = _aidl_reply.read()?; self.cached_version.store(_aidl_return, std::sync::atomic::Ordering::Relaxed); Ok(_aidl_return) } fn build_parcel_getInterfaceHash(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_getInterfaceHash(&self, _aidl_reply: std::result::Result) -> binder::Result { let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: String = _aidl_reply.read()?; *self.cached_hash.lock().unwrap() = Some(_aidl_return.clone()); Ok(_aidl_return) } } impl ITrunkStableTest for BpTrunkStableTest { fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { let _aidl_data = self.build_parcel_repeatParcelable(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#repeatParcelable, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_repeatParcelable(_arg_input, _aidl_reply) } fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { let _aidl_data = self.build_parcel_repeatEnum(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#repeatEnum, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_repeatEnum(_arg_input, _aidl_reply) } fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { let _aidl_data = self.build_parcel_repeatUnion(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#repeatUnion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_repeatUnion(_arg_input, _aidl_reply) } fn r#callMyCallback(&self, _arg_cb: &binder::Strong) -> binder::Result<()> { let _aidl_data = self.build_parcel_callMyCallback(_arg_cb)?; let _aidl_reply = self.binder.submit_transact(transactions::r#callMyCallback, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_callMyCallback(_arg_cb, _aidl_reply) } fn r#repeatOtherParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::Result { let _aidl_data = self.build_parcel_repeatOtherParcelable(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#repeatOtherParcelable, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_repeatOtherParcelable(_arg_input, _aidl_reply) } fn r#getInterfaceVersion(&self) -> binder::Result { let _aidl_version = self.cached_version.load(std::sync::atomic::Ordering::Relaxed); if _aidl_version != -1 { return Ok(_aidl_version); } let _aidl_data = self.build_parcel_getInterfaceVersion()?; let _aidl_reply = self.binder.submit_transact(transactions::r#getInterfaceVersion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_getInterfaceVersion(_aidl_reply) } fn r#getInterfaceHash(&self) -> binder::Result { { let _aidl_hash_lock = self.cached_hash.lock().unwrap(); if let Some(ref _aidl_hash) = *_aidl_hash_lock { return Ok(_aidl_hash.clone()); } } let _aidl_data = self.build_parcel_getInterfaceHash()?; let _aidl_reply = self.binder.submit_transact(transactions::r#getInterfaceHash, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_getInterfaceHash(_aidl_reply) } } impl ITrunkStableTestAsync

for BpTrunkStableTest { fn r#repeatParcelable<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_repeatParcelable(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#repeatParcelable, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_repeatParcelable(_arg_input, _aidl_reply) } ) } fn r#repeatEnum<'a>(&'a self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_repeatEnum(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#repeatEnum, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_repeatEnum(_arg_input, _aidl_reply) } ) } fn r#repeatUnion<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_repeatUnion(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#repeatUnion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_repeatUnion(_arg_input, _aidl_reply) } ) } fn r#callMyCallback<'a>(&'a self, _arg_cb: &'a binder::Strong) -> binder::BoxFuture<'a, binder::Result<()>> { let _aidl_data = match self.build_parcel_callMyCallback(_arg_cb) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#callMyCallback, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_callMyCallback(_arg_cb, _aidl_reply) } ) } fn r#repeatOtherParcelable<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_repeatOtherParcelable(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#repeatOtherParcelable, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_repeatOtherParcelable(_arg_input, _aidl_reply) } ) } fn r#getInterfaceVersion<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { let _aidl_version = self.cached_version.load(std::sync::atomic::Ordering::Relaxed); if _aidl_version != -1 { return Box::pin(std::future::ready(Ok(_aidl_version))); } let _aidl_data = match self.build_parcel_getInterfaceVersion() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#getInterfaceVersion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_getInterfaceVersion(_aidl_reply) } ) } fn r#getInterfaceHash<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { { let _aidl_hash_lock = self.cached_hash.lock().unwrap(); if let Some(ref _aidl_hash) = *_aidl_hash_lock { return Box::pin(std::future::ready(Ok(_aidl_hash.clone()))); } } let _aidl_data = match self.build_parcel_getInterfaceHash() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#getInterfaceHash, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_getInterfaceHash(_aidl_reply) } ) } } impl ITrunkStableTest for binder::binder_impl::Binder { fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { self.0.r#repeatParcelable(_arg_input) } fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { self.0.r#repeatEnum(_arg_input) } fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { self.0.r#repeatUnion(_arg_input) } fn r#callMyCallback(&self, _arg_cb: &binder::Strong) -> binder::Result<()> { self.0.r#callMyCallback(_arg_cb) } fn r#repeatOtherParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::Result { self.0.r#repeatOtherParcelable(_arg_input) } fn r#getInterfaceVersion(&self) -> binder::Result { self.0.r#getInterfaceVersion() } fn r#getInterfaceHash(&self) -> binder::Result { self.0.r#getInterfaceHash() } } fn on_transact(_aidl_service: &dyn ITrunkStableTest, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#repeatParcelable => { let _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable = _aidl_data.read()?; let _aidl_return = _aidl_service.r#repeatParcelable(&_arg_input); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#repeatEnum => { let _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum = _aidl_data.read()?; let _aidl_return = _aidl_service.r#repeatEnum(_arg_input); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#repeatUnion => { let _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion = _aidl_data.read()?; let _aidl_return = _aidl_service.r#repeatUnion(&_arg_input); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#callMyCallback => { let _arg_cb: binder::Strong = _aidl_data.read()?; let _aidl_return = _aidl_service.r#callMyCallback(&_arg_cb); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#repeatOtherParcelable => { let _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable = _aidl_data.read()?; let _aidl_return = _aidl_service.r#repeatOtherParcelable(&_arg_input); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#getInterfaceVersion => { let _aidl_return = _aidl_service.r#getInterfaceVersion(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#getInterfaceHash => { let _aidl_return = _aidl_service.r#getInterfaceHash(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } pub mod r#MyParcelable { #[derive(Debug)] pub struct r#MyParcelable { pub r#a: i32, pub r#b: i32, pub r#c: i32, } impl Default for r#MyParcelable { fn default() -> Self { Self { r#a: 0, r#b: 0, r#c: 0, } } } impl binder::Parcelable for r#MyParcelable { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#a)?; subparcel.write(&self.r#b)?; subparcel.write(&self.r#c)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#a = subparcel.read()?; } if subparcel.has_more_data() { self.r#b = subparcel.read()?; } if subparcel.has_more_data() { self.r#c = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#MyParcelable); binder::impl_deserialize_for_parcelable!(r#MyParcelable); impl binder::binder_impl::ParcelableMetadata for r#MyParcelable { fn get_descriptor() -> &'static str { "android.aidl.test.trunk.ITrunkStableTest.MyParcelable" } } } pub mod r#MyEnum { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#MyEnum : [i8; 4] { r#ZERO = 0, r#ONE = 1, r#TWO = 2, r#THREE = 3, } } } pub mod r#MyUnion { #[derive(Debug)] pub enum r#MyUnion { A(i32), B(i32), C(i32), } impl Default for r#MyUnion { fn default() -> Self { Self::A(0) } } impl binder::Parcelable for r#MyUnion { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { match self { Self::A(v) => { parcel.write(&0i32)?; parcel.write(v) } Self::B(v) => { parcel.write(&1i32)?; parcel.write(v) } Self::C(v) => { parcel.write(&2i32)?; parcel.write(v) } } } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { let tag: i32 = parcel.read()?; match tag { 0 => { let value: i32 = parcel.read()?; *self = Self::A(value); Ok(()) } 1 => { let value: i32 = parcel.read()?; *self = Self::B(value); Ok(()) } 2 => { let value: i32 = parcel.read()?; *self = Self::C(value); Ok(()) } _ => { Err(binder::StatusCode::BAD_VALUE) } } } } binder::impl_serialize_for_parcelable!(r#MyUnion); binder::impl_deserialize_for_parcelable!(r#MyUnion); impl binder::binder_impl::ParcelableMetadata for r#MyUnion { fn get_descriptor() -> &'static str { "android.aidl.test.trunk.ITrunkStableTest.MyUnion" } } pub mod r#Tag { #![allow(non_upper_case_globals)] use binder::declare_binder_enum; declare_binder_enum! { r#Tag : [i32; 3] { r#a = 0, r#b = 1, r#c = 2, } } } } pub mod r#IMyCallback { #![allow(non_upper_case_globals)] #![allow(non_snake_case)] #[allow(unused_imports)] use binder::binder_impl::IBinderInternal; use binder::declare_binder_interface; declare_binder_interface! { IMyCallback["android.aidl.test.trunk.ITrunkStableTest.IMyCallback"] { native: BnMyCallback(on_transact), proxy: BpMyCallback { cached_version: std::sync::atomic::AtomicI32 = std::sync::atomic::AtomicI32::new(-1), cached_hash: std::sync::Mutex> = std::sync::Mutex::new(None) }, async: IMyCallbackAsync, } } pub trait IMyCallback: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.test.trunk.ITrunkStableTest.IMyCallback" } fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result; fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result; fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result; fn r#repeatOtherParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::Result; fn r#getInterfaceVersion(&self) -> binder::Result { Ok(VERSION) } fn r#getInterfaceHash(&self) -> binder::Result { Ok(HASH.into()) } fn getDefaultImpl() -> IMyCallbackDefaultRef where Self: Sized { DEFAULT_IMPL.lock().unwrap().clone() } fn setDefaultImpl(d: IMyCallbackDefaultRef) -> IMyCallbackDefaultRef where Self: Sized { std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d) } } pub trait IMyCallbackAsync

: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.test.trunk.ITrunkStableTest.IMyCallback" } fn r#repeatParcelable<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::BoxFuture<'a, binder::Result>; fn r#repeatEnum<'a>(&'a self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::BoxFuture<'a, binder::Result>; fn r#repeatUnion<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::BoxFuture<'a, binder::Result>; fn r#repeatOtherParcelable<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::BoxFuture<'a, binder::Result>; fn r#getInterfaceVersion<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { Box::pin(async move { Ok(VERSION) }) } fn r#getInterfaceHash<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { Box::pin(async move { Ok(HASH.into()) }) } } #[::async_trait::async_trait] pub trait IMyCallbackAsyncServer: binder::Interface + Send { fn get_descriptor() -> &'static str where Self: Sized { "android.aidl.test.trunk.ITrunkStableTest.IMyCallback" } async fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result; async fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result; async fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result; async fn r#repeatOtherParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::Result; } impl BnMyCallback { /// Create a new async binder service. pub fn new_async_binder(inner: T, rt: R, features: binder::BinderFeatures) -> binder::Strong where T: IMyCallbackAsyncServer + binder::Interface + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { struct Wrapper { _inner: T, _rt: R, } impl binder::Interface for Wrapper where T: binder::Interface, R: Send + Sync + 'static { fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() } fn dump(&self, _writer: &mut dyn std::io::Write, _args: &[&std::ffi::CStr]) -> std::result::Result<(), binder::StatusCode> { self._inner.dump(_writer, _args) } } impl IMyCallback for Wrapper where T: IMyCallbackAsyncServer + Send + Sync + 'static, R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static, { fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { self._rt.block_on(self._inner.r#repeatParcelable(_arg_input)) } fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { self._rt.block_on(self._inner.r#repeatEnum(_arg_input)) } fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { self._rt.block_on(self._inner.r#repeatUnion(_arg_input)) } fn r#repeatOtherParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::Result { self._rt.block_on(self._inner.r#repeatOtherParcelable(_arg_input)) } } let wrapped = Wrapper { _inner: inner, _rt: rt }; Self::new_binder(wrapped, features) } } pub trait IMyCallbackDefault: Send + Sync { fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn r#repeatOtherParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::Result { Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } } pub mod transactions { pub const r#repeatParcelable: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 0; pub const r#repeatEnum: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 1; pub const r#repeatUnion: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 2; pub const r#repeatOtherParcelable: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 3; pub const r#getInterfaceVersion: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 16777214; pub const r#getInterfaceHash: binder::binder_impl::TransactionCode = binder::binder_impl::FIRST_CALL_TRANSACTION + 16777213; } pub type IMyCallbackDefaultRef = Option>; static DEFAULT_IMPL: std::sync::Mutex = std::sync::Mutex::new(None); pub const VERSION: i32 = 2; pub const HASH: &str = "notfrozen"; impl BpMyCallback { fn build_parcel_repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#repeatParcelable(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(&_arg_input)?; Ok(aidl_data) } fn read_response_repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#repeatEnum(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#repeatUnion(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_repeatOtherParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; aidl_data.write(_arg_input)?; Ok(aidl_data) } fn read_response_repeatOtherParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable, _aidl_reply: std::result::Result) -> binder::Result { if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply { if let Some(_aidl_default_impl) = ::getDefaultImpl() { return _aidl_default_impl.r#repeatOtherParcelable(_arg_input); } } let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable = _aidl_reply.read()?; Ok(_aidl_return) } fn build_parcel_getInterfaceVersion(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_getInterfaceVersion(&self, _aidl_reply: std::result::Result) -> binder::Result { let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: i32 = _aidl_reply.read()?; self.cached_version.store(_aidl_return, std::sync::atomic::Ordering::Relaxed); Ok(_aidl_return) } fn build_parcel_getInterfaceHash(&self) -> binder::Result { let mut aidl_data = self.binder.prepare_transact()?; Ok(aidl_data) } fn read_response_getInterfaceHash(&self, _aidl_reply: std::result::Result) -> binder::Result { let _aidl_reply = _aidl_reply?; let _aidl_status: binder::Status = _aidl_reply.read()?; if !_aidl_status.is_ok() { return Err(_aidl_status); } let _aidl_return: String = _aidl_reply.read()?; *self.cached_hash.lock().unwrap() = Some(_aidl_return.clone()); Ok(_aidl_return) } } impl IMyCallback for BpMyCallback { fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { let _aidl_data = self.build_parcel_repeatParcelable(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#repeatParcelable, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_repeatParcelable(_arg_input, _aidl_reply) } fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { let _aidl_data = self.build_parcel_repeatEnum(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#repeatEnum, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_repeatEnum(_arg_input, _aidl_reply) } fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { let _aidl_data = self.build_parcel_repeatUnion(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#repeatUnion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_repeatUnion(_arg_input, _aidl_reply) } fn r#repeatOtherParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::Result { let _aidl_data = self.build_parcel_repeatOtherParcelable(_arg_input)?; let _aidl_reply = self.binder.submit_transact(transactions::r#repeatOtherParcelable, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_repeatOtherParcelable(_arg_input, _aidl_reply) } fn r#getInterfaceVersion(&self) -> binder::Result { let _aidl_version = self.cached_version.load(std::sync::atomic::Ordering::Relaxed); if _aidl_version != -1 { return Ok(_aidl_version); } let _aidl_data = self.build_parcel_getInterfaceVersion()?; let _aidl_reply = self.binder.submit_transact(transactions::r#getInterfaceVersion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_getInterfaceVersion(_aidl_reply) } fn r#getInterfaceHash(&self) -> binder::Result { { let _aidl_hash_lock = self.cached_hash.lock().unwrap(); if let Some(ref _aidl_hash) = *_aidl_hash_lock { return Ok(_aidl_hash.clone()); } } let _aidl_data = self.build_parcel_getInterfaceHash()?; let _aidl_reply = self.binder.submit_transact(transactions::r#getInterfaceHash, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL); self.read_response_getInterfaceHash(_aidl_reply) } } impl IMyCallbackAsync

for BpMyCallback { fn r#repeatParcelable<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_repeatParcelable(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#repeatParcelable, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_repeatParcelable(_arg_input, _aidl_reply) } ) } fn r#repeatEnum<'a>(&'a self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_repeatEnum(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#repeatEnum, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_repeatEnum(_arg_input, _aidl_reply) } ) } fn r#repeatUnion<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_repeatUnion(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#repeatUnion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_repeatUnion(_arg_input, _aidl_reply) } ) } fn r#repeatOtherParcelable<'a>(&'a self, _arg_input: &'a crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::BoxFuture<'a, binder::Result> { let _aidl_data = match self.build_parcel_repeatOtherParcelable(_arg_input) { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#repeatOtherParcelable, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_repeatOtherParcelable(_arg_input, _aidl_reply) } ) } fn r#getInterfaceVersion<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { let _aidl_version = self.cached_version.load(std::sync::atomic::Ordering::Relaxed); if _aidl_version != -1 { return Box::pin(std::future::ready(Ok(_aidl_version))); } let _aidl_data = match self.build_parcel_getInterfaceVersion() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#getInterfaceVersion, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_getInterfaceVersion(_aidl_reply) } ) } fn r#getInterfaceHash<'a>(&'a self) -> binder::BoxFuture<'a, binder::Result> { { let _aidl_hash_lock = self.cached_hash.lock().unwrap(); if let Some(ref _aidl_hash) = *_aidl_hash_lock { return Box::pin(std::future::ready(Ok(_aidl_hash.clone()))); } } let _aidl_data = match self.build_parcel_getInterfaceHash() { Ok(_aidl_data) => _aidl_data, Err(err) => return Box::pin(std::future::ready(Err(err))), }; let binder = self.binder.clone(); P::spawn( move || binder.submit_transact(transactions::r#getInterfaceHash, _aidl_data, binder::binder_impl::FLAG_PRIVATE_LOCAL), move |_aidl_reply| async move { self.read_response_getInterfaceHash(_aidl_reply) } ) } } impl IMyCallback for binder::binder_impl::Binder { fn r#repeatParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable) -> binder::Result { self.0.r#repeatParcelable(_arg_input) } fn r#repeatEnum(&self, _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum) -> binder::Result { self.0.r#repeatEnum(_arg_input) } fn r#repeatUnion(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion) -> binder::Result { self.0.r#repeatUnion(_arg_input) } fn r#repeatOtherParcelable(&self, _arg_input: &crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable) -> binder::Result { self.0.r#repeatOtherParcelable(_arg_input) } fn r#getInterfaceVersion(&self) -> binder::Result { self.0.r#getInterfaceVersion() } fn r#getInterfaceHash(&self) -> binder::Result { self.0.r#getInterfaceHash() } } fn on_transact(_aidl_service: &dyn IMyCallback, _aidl_code: binder::binder_impl::TransactionCode, _aidl_data: &binder::binder_impl::BorrowedParcel<'_>, _aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), binder::StatusCode> { match _aidl_code { transactions::r#repeatParcelable => { let _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable = _aidl_data.read()?; let _aidl_return = _aidl_service.r#repeatParcelable(&_arg_input); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#repeatEnum => { let _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum = _aidl_data.read()?; let _aidl_return = _aidl_service.r#repeatEnum(_arg_input); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#repeatUnion => { let _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion = _aidl_data.read()?; let _aidl_return = _aidl_service.r#repeatUnion(&_arg_input); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#repeatOtherParcelable => { let _arg_input: crate::mangled::_7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable = _aidl_data.read()?; let _aidl_return = _aidl_service.r#repeatOtherParcelable(&_arg_input); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#getInterfaceVersion => { let _aidl_return = _aidl_service.r#getInterfaceVersion(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } transactions::r#getInterfaceHash => { let _aidl_return = _aidl_service.r#getInterfaceHash(); match &_aidl_return { Ok(_aidl_return) => { _aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?; _aidl_reply.write(_aidl_return)?; } Err(_aidl_status) => _aidl_reply.write(_aidl_status)? } Ok(()) } _ => Err(binder::StatusCode::UNKNOWN_TRANSACTION) } } } pub mod r#MyOtherParcelable { #[derive(Debug)] pub struct r#MyOtherParcelable { pub r#a: i32, pub r#b: i32, } impl Default for r#MyOtherParcelable { fn default() -> Self { Self { r#a: 0, r#b: 0, } } } impl binder::Parcelable for r#MyOtherParcelable { fn write_to_parcel(&self, parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_write(|subparcel| { subparcel.write(&self.r#a)?; subparcel.write(&self.r#b)?; Ok(()) }) } fn read_from_parcel(&mut self, parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), binder::StatusCode> { parcel.sized_read(|subparcel| { if subparcel.has_more_data() { self.r#a = subparcel.read()?; } if subparcel.has_more_data() { self.r#b = subparcel.read()?; } Ok(()) }) } } binder::impl_serialize_for_parcelable!(r#MyOtherParcelable); binder::impl_deserialize_for_parcelable!(r#MyOtherParcelable); impl binder::binder_impl::ParcelableMetadata for r#MyOtherParcelable { fn get_descriptor() -> &'static str { "android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable" } } } pub(crate) mod mangled { pub use super::r#ITrunkStableTest as _7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest; pub use super::r#MyParcelable::r#MyParcelable as _7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_12_MyParcelable; pub use super::r#MyEnum::r#MyEnum as _7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_6_MyEnum; pub use super::r#MyUnion::r#MyUnion as _7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion; pub use super::r#MyUnion::r#Tag::r#Tag as _7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_7_MyUnion_3_Tag; pub use super::r#IMyCallback::r#IMyCallback as _7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_11_IMyCallback; pub use super::r#MyOtherParcelable::r#MyOtherParcelable as _7_android_4_aidl_4_test_5_trunk_16_ITrunkStableTest_17_MyOtherParcelable; } ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-rust-source_g0100644 0000000 0000000 00000000252 15172120304 033205 xustar000000000 0000000 142 path=tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/gen/android/aidl/test/trunk/ITrunkStableTest.rs.d 28 mtime=1776853188.7660000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/gen/android/aidl/0100644 0000000 0000000 00000000370 15172120304 033062 0ustar000000000 0000000 out/soong/.intermediates/system/tools/aidl/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/gen/android/aidl/test/trunk/ITrunkStableTest.rs : \ system/tools/aidl/tests/trunk_stable_test/android/aidl/test/trunk/ITrunkStableTest.aidl ./PaxHeaders.X/tests_golden_output_tests_trunk_stable_test_android.aidl.test.trunk-V2-rust-source_g0100644 0000000 0000000 00000000034 15172120304 033203 xustar000000000 0000000 28 mtime=1776853188.7660000 tests/golden_output/tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source/gen/timestamp0100644 0000000 0000000 00000000000 15172120304 032443 0ustar000000000 0000000 ./PaxHeaders.X/tests_golden_test.sh0100644 0000000 0000000 00000000034 15172120304 016361 xustar000000000 0000000 28 mtime=1776853188.7660000 tests/golden_test.sh0100755 0000000 0000000 00000013520 15172120304 013611 0ustar000000000 0000000 #!/usr/bin/env bash # 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. set -e if [ $# == 0 ]; then echo "Usage: golden_test.sh [check|update] " fi function _golden_test() { local update=0 case $1 in check) update=0 ;; update) update=1 ;; *) echo "Argument must be 'check' or 'update' but is $1" exit 1 ;; esac # warning: this list must be kept in sync with system/tools/aidl/Android.bp modules=( "aidl-test-interface-cpp-source" "aidl-test-interface-java-source" "aidl-test-interface-ndk-source" "aidl-test-interface-rust-source" "aidl-test-extras-java-source" "aidl-cpp-java-test-interface-cpp-source" "aidl-cpp-java-test-interface-java-source" "aidl-test-versioned-interface-V1-cpp-source" "aidl-test-versioned-interface-V1-java-source" "aidl-test-versioned-interface-V1-ndk-source" "aidl-test-versioned-interface-V1-rust-source" "aidl-test-versioned-interface-V2-cpp-source" "aidl-test-versioned-interface-V2-java-source" "aidl-test-versioned-interface-V2-ndk-source" "aidl-test-versioned-interface-V2-rust-source" "aidl-test-versioned-interface-V3-cpp-source" "aidl-test-versioned-interface-V3-java-source" "aidl-test-versioned-interface-V3-ndk-source" "aidl-test-versioned-interface-V3-rust-source" "aidl_test_loggable_interface-cpp-source" "aidl_test_loggable_interface-java-source" "aidl_test_loggable_interface-ndk-source" "aidl-test-interface-permission-java-source" "aidl-test-fixedsizearray-cpp-source" "aidl-test-fixedsizearray-java-source" "aidl-test-fixedsizearray-ndk-source" "aidl-test-fixedsizearray-rust-source" "aidl-test-interface-cpp-analyzer-source" "tests/trunk_stable_test/android.aidl.test.trunk-V1-cpp-source" "tests/trunk_stable_test/android.aidl.test.trunk-V2-cpp-source" "tests/trunk_stable_test/android.aidl.test.trunk-V1-ndk-source" "tests/trunk_stable_test/android.aidl.test.trunk-V2-ndk-source" "tests/trunk_stable_test/android.aidl.test.trunk-V1-java-source" "tests/trunk_stable_test/android.aidl.test.trunk-V2-java-source" "tests/trunk_stable_test/android.aidl.test.trunk-V1-rust-source" "tests/trunk_stable_test/android.aidl.test.trunk-V2-rust-source" ) local use_unfrozen="$3" # If override_unfrozen is true, we override the RELEASE_AIDL_USE_UNFROZEN build flag with an # environment variable. local override_unfrozen="$4" local root="$2" local input_files=$5 if [ "$update" = 1 ]; then if [ "$override_unfrozen" == true ]; then export AIDL_USE_UNFROZEN_OVERRIDE="$use_unfrozen" fi # clean up intermediates before building these modules for module in "${modules[@]}"; do rm -rf "$root/out/soong/.intermediates/system/tools/aidl/$module/gen" done "$root"/build/soong/soong_ui.bash --make-mode \ $(for i in "${modules[@]}"; do echo "out/soong/.intermediates/system/tools/aidl/$i/timestamp" done) ; export AIDL_USE_UNFROZEN_OVERRIDE= fi local e=0 if [ -z "$input_files" ]; then for module in "${modules[@]}"; do local built="$root/out/soong/.intermediates/system/tools/aidl/$module/" local module_path if [ "$use_unfrozen" == "true" ]; then module_path=$module else module_path="frozen/$module" fi local golden="$root/system/tools/aidl/tests/golden_output/$module_path/" if [ "$update" = 1 ]; then rm -rf "$golden" mkdir -p "$golden" cp -r "$built/gen" "$golden" else diff -rN "$built/gen" "$golden/gen" || e=1 fi done else for file in $input_files; do if [[ "$file" =~ ^system.* ]]; then continue fi name=$(echo "$file" | sed -e "s@^.*/system/tools/aidl/@@") if [ "$use_unfrozen" == "true" ]; then module_path="$name" else module_path="frozen/$name" fi golden_file="system/tools/aidl/tests/golden_output/$module_path" if [ "$update" = 1 ]; then # We don't get header files in the build hook's $in, and we want them in # the golden_output, so run this script manually. echo update does not support multiple files as arguments. exit 1 else diff -N --unified=0 "$file" "$golden_file" || e=1 fi done fi if [ "$e" = 1 ]; then echo "ERROR: The AIDL compiler is outputting files in an unknown way." echo "ERROR: to accept these changes, please run:" echo "ERROR: \$ANDROID_BUILD_TOP/system/tools/aidl/tests/golden_test.sh update" exit 1 else if [ "$update" = 1 ]; then echo "UPDATE GOLDEN TEST SUCCESS" fi fi } root="." if [ "$ANDROID_BUILD_TOP" != "" ]; then root="$ANDROID_BUILD_TOP" fi if [[ "$TARGET_RELEASE" == "next" ]]; then use_unfrozen=false else use_unfrozen=true fi action=$1 # we only want the input files in $@ shift if [ "$action" == "update" ]; then if [ "$use_unfrozen" == "true" ]; then # build update the opposite value first, so we leave the intermediates # in the state of the tree _golden_test "$action" "$root" "false" true _golden_test "$action" "$root" "true" false else _golden_test "$action" "$root" "true" true _golden_test "$action" "$root" "false" false fi else _golden_test "$action" "$root" "$use_unfrozen" false "$*" fi ./PaxHeaders.X/tests_java_0100644 0000000 0000000 00000000034 15172120304 014521 xustar000000000 0000000 28 mtime=1776853188.7660000 tests/java/0040755 0000000 0000000 00000000000 15172120304 011666 5ustar000000000 0000000 ./PaxHeaders.X/tests_java_src_0100644 0000000 0000000 00000000034 15172120304 015370 xustar000000000 0000000 28 mtime=1776853188.7660000 tests/java/src/0040755 0000000 0000000 00000000000 15172120304 012455 5ustar000000000 0000000 ./PaxHeaders.X/tests_java_src_android_0100644 0000000 0000000 00000000034 15172120304 017070 xustar000000000 0000000 28 mtime=1776853188.7660000 tests/java/src/android/0040755 0000000 0000000 00000000000 15172120304 014075 5ustar000000000 0000000 ./PaxHeaders.X/tests_java_src_android_aidl_0100644 0000000 0000000 00000000034 15172120304 020061 xustar000000000 0000000 28 mtime=1776853188.7660000 tests/java/src/android/aidl/0040755 0000000 0000000 00000000000 15172120304 015006 5ustar000000000 0000000 ./PaxHeaders.X/tests_java_src_android_aidl_permission_0100644 0000000 0000000 00000000034 15172120304 022331 xustar000000000 0000000 28 mtime=1776853188.7660000 tests/java/src/android/aidl/permission/0040755 0000000 0000000 00000000000 15172120304 017176 5ustar000000000 0000000 ./PaxHeaders.X/tests_java_src_android_aidl_permission_service_0100644 0000000 0000000 00000000034 15172120304 024051 xustar000000000 0000000 28 mtime=1776853188.7660000 tests/java/src/android/aidl/permission/service/0040755 0000000 0000000 00000000000 15172120304 020636 5ustar000000000 0000000 ./PaxHeaders.X/tests_java_src_android_aidl_permission_service_PermissionTestService.java0100644 0000000 0000000 00000000034 15172120304 031223 xustar000000000 0000000 28 mtime=1776853188.7660000 tests/java/src/android/aidl/permission/service/PermissionTestService.java0100644 0000000 0000000 00000004421 15172120304 026010 0ustar000000000 0000000 /* * Copyright (C) 2022, 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. */ package android.aidl.permission.service; import android.aidl.tests.permission.IProtected; import android.annotation.EnforcePermission; import android.os.Binder; import android.os.ServiceManager; import android.os.test.FakePermissionEnforcer; import java.util.List; public class PermissionTestService extends IProtected.Stub { private FakePermissionEnforcer mPermissionEnforcer; public static void main(String[] args) { PermissionTestService myServer = new PermissionTestService(new FakePermissionEnforcer()); ServiceManager.addService(IProtected.class.getName(), myServer); Binder.joinThreadPool(); } public PermissionTestService(FakePermissionEnforcer permissionEnforcer) { super(permissionEnforcer); mPermissionEnforcer = permissionEnforcer; } @Override @EnforcePermission("READ_PHONE_STATE") public void PermissionProtected() { PermissionProtected_enforcePermission(); } @Override @EnforcePermission(allOf = {"INTERNET", "VIBRATE"}) public void MultiplePermissionsAll() { MultiplePermissionsAll_enforcePermission(); } @Override @EnforcePermission(anyOf = {"INTERNET", "VIBRATE"}) public void MultiplePermissionsAny() { MultiplePermissionsAny_enforcePermission(); } @Override @EnforcePermission("android.permission.MAINLINE_NETWORK_STACK") public void NonManifestPermission() { NonManifestPermission_enforcePermission(); } @Override public void Grant(String permission) { mPermissionEnforcer.grant(permission); } @Override public void Revoke(String permission) { mPermissionEnforcer.revoke(permission); } @Override public void RevokeAll() { mPermissionEnforcer.revokeAll(); } } ./PaxHeaders.X/tests_java_src_android_aidl_permission_tests_0100644 0000000 0000000 00000000034 15172120304 023553 xustar000000000 0000000 28 mtime=1776853188.7670000 tests/java/src/android/aidl/permission/tests/0040755 0000000 0000000 00000000000 15172120304 020340 5ustar000000000 0000000 ./PaxHeaders.X/tests_java_src_android_aidl_permission_tests_PermissionTests.java0100644 0000000 0000000 00000000034 15172120304 027567 xustar000000000 0000000 28 mtime=1776853188.7670000 tests/java/src/android/aidl/permission/tests/PermissionTests.java0100644 0000000 0000000 00000006200 15172120304 024351 0ustar000000000 0000000 /* * Copyright (C) 2022, 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. */ package android.aidl.permission.tests; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertThrows; import android.aidl.tests.permission.IProtected; import android.os.IBinder; import android.os.RemoteException; import android.os.ServiceManager; import java.util.List; import org.junit.Before; import org.junit.Test; import org.junit.internal.TextListener; import org.junit.runner.JUnitCore; import org.junit.runner.Result; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; @RunWith(JUnit4.class) public abstract class PermissionTests { protected IProtected service; @Test public void testProtected() throws Exception { // Requires READ_PHONE_STATE. assertThrows(SecurityException.class, () -> service.PermissionProtected()); service.Grant("android.permission.READ_PHONE_STATE"); service.PermissionProtected(); } @Test public void testMultiplePermissionsAll() throws Exception { // Requires INTERNET and VIBRATE. assertThrows(SecurityException.class, () -> service.MultiplePermissionsAll()); service.Grant("android.permission.INTERNET"); assertThrows(SecurityException.class, () -> service.MultiplePermissionsAll()); service.RevokeAll(); service.Grant("android.permission.VIBRATE"); assertThrows(SecurityException.class, () -> service.MultiplePermissionsAll()); service.RevokeAll(); service.Grant("android.permission.INTERNET"); service.Grant("android.permission.VIBRATE"); service.MultiplePermissionsAll(); } @Test public void testMultiplePermissionsAny() throws Exception { // Requires INTERNET or VIBRATE. assertThrows(SecurityException.class, () -> service.MultiplePermissionsAny()); service.Grant("android.permission.INTERNET"); service.MultiplePermissionsAny(); service.RevokeAll(); service.Grant("android.permission.VIBRATE"); service.MultiplePermissionsAny(); } @Test public void testNonManifestPermission() throws Exception { // Requires android.net.NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK assertThrows(SecurityException.class, () -> service.NonManifestPermission()); service.Grant("android.permission.MAINLINE_NETWORK_STACK"); service.NonManifestPermission(); } public static void main(String[] args) { JUnitCore junit = new JUnitCore(); junit.addListener(new TextListener(System.out)); Result result = junit.run(PermissionTestsRemote.class, PermissionTestsLocal.class); System.out.println(result.wasSuccessful() ? "TEST SUCCESS" : "TEST FAILURE"); } } ./PaxHeaders.X/tests_java_src_android_aidl_permission_tests_PermissionTestsLocal.java0100644 0000000 0000000 00000000034 15172120304 030542 xustar000000000 0000000 28 mtime=1776853188.7670000 tests/java/src/android/aidl/permission/tests/PermissionTestsLocal.java0100644 0000000 0000000 00000002435 15172120304 025332 0ustar000000000 0000000 /* * Copyright (C) 2022, 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. */ package android.aidl.permission.tests; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertThrows; import android.aidl.permission.service.PermissionTestService; import android.aidl.tests.permission.IProtected; import android.os.RemoteException; import android.os.test.FakePermissionEnforcer; import org.junit.Before; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; @RunWith(JUnit4.class) public class PermissionTestsLocal extends PermissionTests { @Before public void setUp() throws RemoteException { service = new PermissionTestService(new FakePermissionEnforcer()); assertNotNull(service); service.RevokeAll(); } } ./PaxHeaders.X/tests_java_src_android_aidl_permission_tests_PermissionTestsRemote.java0100644 0000000 0000000 00000000034 15172120304 030743 xustar000000000 0000000 28 mtime=1776853188.7670000 tests/java/src/android/aidl/permission/tests/PermissionTestsRemote.java0100644 0000000 0000000 00000002504 15172120304 025530 0ustar000000000 0000000 /* * Copyright (C) 2022, 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. */ package android.aidl.permission.tests; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertThrows; import android.aidl.tests.permission.IProtected; import android.os.IBinder; import android.os.RemoteException; import android.os.ServiceManager; import org.junit.Before; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; @RunWith(JUnit4.class) public class PermissionTestsRemote extends PermissionTests { @Before public void setUp() throws RemoteException { IBinder binder = ServiceManager.waitForService(IProtected.class.getName()); assertNotNull(binder); service = IProtected.Stub.asInterface(binder); assertNotNull(service); service.RevokeAll(); } } ./PaxHeaders.X/tests_java_src_android_aidl_sdkversion_0100644 0000000 0000000 00000000034 15172120304 022330 xustar000000000 0000000 28 mtime=1776853188.7670000 tests/java/src/android/aidl/sdkversion/0040755 0000000 0000000 00000000000 15172120304 017175 5ustar000000000 0000000 ./PaxHeaders.X/tests_java_src_android_aidl_sdkversion_ITestService.aidl0100644 0000000 0000000 00000000034 15172120304 025532 xustar000000000 0000000 28 mtime=1776853188.7670000 tests/java/src/android/aidl/sdkversion/ITestService.aidl0100644 0000000 0000000 00000002232 15172120304 022375 0ustar000000000 0000000 /* * Copyright (C) 2021, 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. */ package android.aidl.sdkversion; interface ITestService { // Since sdk = 29, we have write/readBoolean boolean RepeatBoolean(boolean token); @JavaDerive(toString=true, equals=true) parcelable TypedObject { boolean b; } // Since sdk = 23, we have write/readTypedObject @nullable TypedObject RepeatTypedObject(in @nullable TypedObject token); // Since sdk = 33, we have write/readTypedList (with parcelableFlags) @nullable List RepeatTypedList( in @nullable List tokens); } ./PaxHeaders.X/tests_java_src_android_aidl_sdkversion_service_0100644 0000000 0000000 00000000034 15172120304 024050 xustar000000000 0000000 28 mtime=1776853188.7670000 tests/java/src/android/aidl/sdkversion/service/0040755 0000000 0000000 00000000000 15172120304 020635 5ustar000000000 0000000 ./PaxHeaders.X/tests_java_src_android_aidl_sdkversion_service_AidlJavaVersionTestService.java0100644 0000000 0000000 00000000034 15172120304 032113 xustar000000000 0000000 28 mtime=1776853188.7670000 tests/java/src/android/aidl/sdkversion/service/AidlJavaVersionTestService.java0100644 0000000 0000000 00000002676 15172120304 026712 0ustar000000000 0000000 /* * Copyright (C) 2021, 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. */ package android.aidl.sdkversion.service; import android.aidl.sdkversion.ITestService; import android.aidl.sdkversion.ITestService.TypedObject; import android.os.Binder; import android.os.ServiceManager; import java.util.List; public class AidlJavaVersionTestService { static class TestServiceServer extends ITestService.Stub { @Override public boolean RepeatBoolean(boolean token) { return token; } @Override public TypedObject RepeatTypedObject(TypedObject token) { return token; } @Override public List RepeatTypedList(List token) { return token; } } public static void main(String[] args) { TestServiceServer myServer = new TestServiceServer(); ServiceManager.addService(ITestService.class.getName(), myServer); Binder.joinThreadPool(); } } ./PaxHeaders.X/tests_java_src_android_aidl_sdkversion_tests_0100644 0000000 0000000 00000000034 15172120304 023552 xustar000000000 0000000 28 mtime=1776853188.7670000 tests/java/src/android/aidl/sdkversion/tests/0040755 0000000 0000000 00000000000 15172120304 020337 5ustar000000000 0000000 ./PaxHeaders.X/tests_java_src_android_aidl_sdkversion_tests_AidlJavaVersionTests.java0100644 0000000 0000000 00000000034 15172120304 030457 xustar000000000 0000000 28 mtime=1776853188.7670000 tests/java/src/android/aidl/sdkversion/tests/AidlJavaVersionTests.java0100644 0000000 0000000 00000004644 15172120304 025253 0ustar000000000 0000000 /* * Copyright (C) 2021, 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. */ package android.aidl.sdkversion.tests; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; import android.aidl.sdkversion.ITestService; import android.aidl.sdkversion.ITestService.TypedObject; import android.os.IBinder; import android.os.RemoteException; import android.os.ServiceManager; import java.util.ArrayList; import java.util.List; import org.junit.Before; import org.junit.Test; import org.junit.internal.TextListener; import org.junit.runner.JUnitCore; import org.junit.runner.Result; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; @RunWith(JUnit4.class) public class AidlJavaVersionTests { public static void main(String[] args) { JUnitCore junit = new JUnitCore(); junit.addListener(new TextListener(System.out)); Result result = junit.run(AidlJavaVersionTests.class); System.out.println(result.wasSuccessful() ? "TEST SUCCESS" : "TEST FAILURE"); } private ITestService mService; @Before public void setUp() { IBinder binder = ServiceManager.waitForService(ITestService.class.getName()); assertNotNull(binder); mService = ITestService.Stub.asInterface(binder); assertNotNull(mService); } @Test public void testBoolean() throws RemoteException { assertTrue(mService.RepeatBoolean(true)); assertFalse(mService.RepeatBoolean(false)); } @Test public void testTypedObject() throws RemoteException { TypedObject token = new TypedObject(); assertEquals(mService.RepeatTypedObject(token), token); assertNull(mService.RepeatTypedObject(null)); List list = new ArrayList<>(); list.add(token); assertEquals(mService.RepeatTypedList(list), list); } } ./PaxHeaders.X/tests_java_src_android_aidl_service_0100644 0000000 0000000 00000000034 15172120304 021601 xustar000000000 0000000 28 mtime=1776853188.7670000 tests/java/src/android/aidl/service/0040755 0000000 0000000 00000000000 15172120304 016446 5ustar000000000 0000000 ./PaxHeaders.X/tests_java_src_android_aidl_service_TestServiceServer.java0100644 0000000 0000000 00000000034 15172120304 026071 xustar000000000 0000000 28 mtime=1776853188.7670000 tests/java/src/android/aidl/service/TestServiceServer.java0100644 0000000 0000000 00000067130 15172120304 022744 0ustar000000000 0000000 /* * Copyright (C) 2021, 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. */ package android.aidl.service; import android.aidl.fixedsizearray.FixedSizeArrayExample.IRepeatFixedSizeArray; import android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable; import android.aidl.test.trunk.ITrunkStableTest; import android.aidl.test.trunk.ITrunkStableTest.IMyCallback; import android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable; import android.aidl.test.trunk.ITrunkStableTest.MyParcelable; import android.aidl.test.trunk.ITrunkStableTest.MyUnion; import android.aidl.tests.BackendType; import android.aidl.tests.BadParcelable; import android.aidl.tests.ByteEnum; import android.aidl.tests.CircularParcelable; import android.aidl.tests.ConstantExpressionEnum; import android.aidl.tests.GenericStructuredParcelable; import android.aidl.tests.ICircular; import android.aidl.tests.ICppJavaTests; import android.aidl.tests.INamedCallback; import android.aidl.tests.INewName; import android.aidl.tests.IOldName; import android.aidl.tests.ITestService; import android.aidl.tests.IntEnum; import android.aidl.tests.LongEnum; import android.aidl.tests.RecursiveList; import android.aidl.tests.SimpleParcelable; import android.aidl.tests.StructuredParcelable; import android.aidl.tests.Union; import android.aidl.tests.extension.ExtendableParcelable; import android.aidl.tests.extension.MyExt; import android.aidl.tests.nested.INestedService; import android.aidl.tests.nested.ParcelableWithNested; import android.aidl.versioned.tests.BazUnion; import android.aidl.versioned.tests.Foo; import android.aidl.versioned.tests.IFooInterface; import android.os.Binder; import android.os.IBinder; import android.os.Parcel; import android.os.ParcelFileDescriptor; import android.os.PersistableBundle; import android.os.RemoteException; import android.os.ServiceManager; import android.os.ServiceSpecificException; import android.util.Log; import java.io.FileDescriptor; import java.io.IOException; import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.List; public class TestServiceServer extends ITestService.Stub { public static void main(String[] args) { // b/235006086: test with debug stack trace parceling feature // which has been broken in the past. This does mean that we // lose Java coverage for when this is false, but we do have // other tests which cover this including CtsNdkBinderTestCases // and other language-specific exception/Status unit tests. Parcel.setStackTraceParceling(true); TestServiceServer myServer = new TestServiceServer(); ServiceManager.addService(ITestService.class.getName(), myServer); FooInterface foo = new FooInterface(); ServiceManager.addService(IFooInterface.class.getName(), foo); NestedService nested = new NestedService(); ServiceManager.addService(INestedService.class.getName(), nested); FixedSizeArrayService fixedSize = new FixedSizeArrayService(); ServiceManager.addService(IRepeatFixedSizeArray.DESCRIPTOR, fixedSize); TrunkStableService trunkStable = new TrunkStableService(); ServiceManager.addService(ITrunkStableTest.DESCRIPTOR, trunkStable); Binder.joinThreadPool(); } private static class FooInterface extends IFooInterface.Stub { @Override public void originalApi() {} @Override public String acceptUnionAndReturnString(BazUnion b) { if (b.getTag() == BazUnion.intNum) { return "" + b.getIntNum(); } throw new IllegalArgumentException(); } @Override public int returnsLengthOfFooArray(Foo[] foos) { return foos.length; } @Override public int ignoreParcelablesAndRepeatInt(Foo inFoo, Foo inoutFoo, Foo outFoo, int value) { return value; } @Override public final int getInterfaceVersion() { return super.VERSION; } @Override public final String getInterfaceHash() { return super.HASH; } } private static class NestedService extends INestedService.Stub { @Override public final Result flipStatus(ParcelableWithNested p) { Result result = new Result(); if (p.status == ParcelableWithNested.Status.OK) { result.status = ParcelableWithNested.Status.NOT_OK; } else { result.status = ParcelableWithNested.Status.OK; } return result; } @Override public final void flipStatusWithCallback(byte st, ICallback cb) throws RemoteException { if (st == ParcelableWithNested.Status.OK) { cb.done(ParcelableWithNested.Status.NOT_OK); } else { cb.done(ParcelableWithNested.Status.OK); } } } @Override public boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException { // UnimplementedMethod if (code == 1) return false; return super.onTransact(code, data, reply, flags); } @Override public int UnimplementedMethod(int arg) throws RemoteException { throw new UnsupportedOperationException(); } @Override public void TestOneway() throws RemoteException { throw new RemoteException(); } @Override public void Deprecated() throws RemoteException {} @Override public boolean RepeatBoolean(boolean token) throws RemoteException { return token; } @Override public byte RepeatByte(byte token) throws RemoteException { return token; } @Override public char RepeatChar(char token) throws RemoteException { return token; } @Override public int RepeatInt(int token) throws RemoteException { return token; } @Override public long RepeatLong(long token) throws RemoteException { return token; } @Override public float RepeatFloat(float token) throws RemoteException { return token; } @Override public double RepeatDouble(double token) throws RemoteException { return token; } @Override public String RepeatString(String token) throws RemoteException { return token; } @Override public byte RepeatByteEnum(byte token) throws RemoteException { return token; } @Override public int RepeatIntEnum(int token) throws RemoteException { return token; } @Override public long RepeatLongEnum(long token) throws RemoteException { return token; } @Override public boolean[] ReverseBoolean(boolean[] input, boolean[] repeated) throws RemoteException { boolean[] reversed = new boolean[input.length]; for (int i = 0; i < input.length; i++) { repeated[i] = input[i]; reversed[i] = input[input.length - i - 1]; } return reversed; } @Override public byte[] ReverseByte(byte[] input, byte[] repeated) throws RemoteException { byte[] reversed = new byte[input.length]; for (int i = 0; i < input.length; i++) { repeated[i] = input[i]; reversed[i] = input[input.length - i - 1]; } return reversed; } @Override public char[] ReverseChar(char[] input, char[] repeated) throws RemoteException { char[] reversed = new char[input.length]; for (int i = 0; i < input.length; i++) { repeated[i] = input[i]; reversed[i] = input[input.length - i - 1]; } return reversed; } @Override public int[] ReverseInt(int[] input, int[] repeated) throws RemoteException { int[] reversed = new int[input.length]; for (int i = 0; i < input.length; i++) { repeated[i] = input[i]; reversed[i] = input[input.length - i - 1]; } return reversed; } @Override public long[] ReverseLong(long[] input, long[] repeated) throws RemoteException { long[] reversed = new long[input.length]; for (int i = 0; i < input.length; i++) { repeated[i] = input[i]; reversed[i] = input[input.length - i - 1]; } return reversed; } @Override public float[] ReverseFloat(float[] input, float[] repeated) throws RemoteException { float[] reversed = new float[input.length]; for (int i = 0; i < input.length; i++) { repeated[i] = input[i]; reversed[i] = input[input.length - i - 1]; } return reversed; } @Override public double[] ReverseDouble(double[] input, double[] repeated) throws RemoteException { double[] reversed = new double[input.length]; for (int i = 0; i < input.length; i++) { repeated[i] = input[i]; reversed[i] = input[input.length - i - 1]; } return reversed; } @Override public String[] ReverseString(String[] input, String[] repeated) throws RemoteException { String[] reversed = new String[input.length]; for (int i = 0; i < input.length; i++) { repeated[i] = input[i]; reversed[i] = input[input.length - i - 1]; } return reversed; } @Override public byte[] ReverseByteEnum(byte[] input, byte[] repeated) throws RemoteException { byte[] reversed = new byte[input.length]; for (int i = 0; i < input.length; i++) { repeated[i] = input[i]; reversed[i] = input[input.length - i - 1]; } return reversed; } @Override public int[] ReverseIntEnum(int[] input, int[] repeated) throws RemoteException { int[] reversed = new int[input.length]; for (int i = 0; i < input.length; i++) { repeated[i] = input[i]; reversed[i] = input[input.length - i - 1]; } return reversed; } @Override public long[] ReverseLongEnum(long[] input, long[] repeated) throws RemoteException { long[] reversed = new long[input.length]; for (int i = 0; i < input.length; i++) { repeated[i] = input[i]; reversed[i] = input[input.length - i - 1]; } return reversed; } private static class MyNamedCallback extends INamedCallback.Stub { public MyNamedCallback(String name) { mName = name; } @Override public String GetName() { return mName; } private String mName; } private HashMap mNamedCallbacks = new HashMap<>(); @Override public INamedCallback GetOtherTestService(String name) throws RemoteException { synchronized (mNamedCallbacks) { if (!mNamedCallbacks.containsKey(name)) { mNamedCallbacks.put(name, new MyNamedCallback(name)); } return mNamedCallbacks.get(name); } } @Override public boolean SetOtherTestService(String name, INamedCallback service) throws RemoteException { synchronized (mNamedCallbacks) { if (mNamedCallbacks.containsKey(name) && mNamedCallbacks.get(name) == service) { return true; } try { // This restricts the client to only setting services that it gets from this server. mNamedCallbacks.put(name, (MyNamedCallback) service); } catch (Exception e) { Log.i("TestServiceServer", "Failed to cast service"); } return false; } } @Override public boolean VerifyName(INamedCallback service, String name) throws RemoteException { return name.equals(service.GetName()); } @Override public INamedCallback[] GetInterfaceArray(String[] names) throws RemoteException { return GetNullableInterfaceArray(names); } @Override public boolean VerifyNamesWithInterfaceArray(INamedCallback[] services, String[] names) throws RemoteException { return VerifyNamesWithNullableInterfaceArray(services, names); } @Override public INamedCallback[] GetNullableInterfaceArray(String[] names) throws RemoteException { if (names == null) return null; INamedCallback[] services = new INamedCallback[names.length]; for (int i = 0; i < names.length; i++) { if (names[i] == null) { services[i] = null; } else { services[i] = GetOtherTestService(names[i]); } } return services; } @Override public boolean VerifyNamesWithNullableInterfaceArray(INamedCallback[] services, String[] names) throws RemoteException { if (services != null && names != null) { for (int i = 0; i < names.length; i++) { if (services[i] != null && names[i] != null) { if (!VerifyName(services[i], names[i])) { return false; } } else if (services[i] != null || names[i] != null) { return false; } } return true; } else if (services != null || names != null) { return false; } else { return true; } } @Override public List GetInterfaceList(String[] names) throws RemoteException { INamedCallback[] services = GetNullableInterfaceArray(names); return services == null ? null : Arrays.asList(services); } @Override public boolean VerifyNamesWithInterfaceList(List services, String[] names) throws RemoteException { return VerifyNamesWithNullableInterfaceArray( services == null ? null : services.toArray(new INamedCallback[0]), names); } @Override public List ReverseStringList(List input, List repeated) throws RemoteException { ArrayList reversed = new ArrayList(); for (String a : input) { repeated.add(a); reversed.add(0, a); } return reversed; } @Override public ParcelFileDescriptor RepeatParcelFileDescriptor(ParcelFileDescriptor read) throws RemoteException { return read; } @Override public ParcelFileDescriptor[] ReverseParcelFileDescriptorArray( ParcelFileDescriptor[] input, ParcelFileDescriptor[] repeated) throws RemoteException { ParcelFileDescriptor[] reversed = new ParcelFileDescriptor[input.length]; for (int i = 0; i < input.length; i++) { repeated[i] = input[i]; try { // extra dup, because of PARCELABLE_WRITE_RETURN_VALUE reversed[i] = input[input.length - i - 1].dup(); } catch (IOException e) { throw new RuntimeException(e); } } return reversed; } @Override public void ThrowServiceException(int code) throws RemoteException { Log.i("TestServiceServer", "Throwing service specific exception " + code); throw new ServiceSpecificException(code); } @Override public int[] RepeatNullableIntArray(int[] input) throws RemoteException { return input; } @Override public byte[] RepeatNullableByteEnumArray(byte[] input) throws RemoteException { return input; } @Override public int[] RepeatNullableIntEnumArray(int[] input) throws RemoteException { return input; } @Override public long[] RepeatNullableLongEnumArray(long[] input) throws RemoteException { return input; } @Override public String RepeatNullableString(String input) throws RemoteException { return input; } @Override public List RepeatNullableStringList(List input) throws RemoteException { return input; } @Override public ITestService.Empty RepeatNullableParcelable(ITestService.Empty input) throws RemoteException { return input; } @Override public List RepeatNullableParcelableList(List input) throws RemoteException { return input; } @Override public ITestService.Empty[] RepeatNullableParcelableArray(ITestService.Empty[] input) throws RemoteException { return input; } @Override public void TakesAnIBinder(IBinder input) throws RemoteException { // do nothing } @Override public void TakesANullableIBinder(IBinder input) throws RemoteException { // do nothing } @Override public void TakesAnIBinderList(List input) throws RemoteException { // do nothing } @Override public void TakesANullableIBinderList(List input) throws RemoteException { // do nothing } @Override public String RepeatUtf8CppString(String token) throws RemoteException { return token; } @Override public String RepeatNullableUtf8CppString(String token) throws RemoteException { return token; } @Override public String[] ReverseUtf8CppString(String[] input, String[] repeated) throws RemoteException { String[] reversed = new String[input.length]; for (int i = 0; i < input.length; i++) { repeated[i] = input[i]; reversed[i] = input[input.length - i - 1]; } return reversed; } @Override public String[] ReverseNullableUtf8CppString(String[] input, String[] repeated) throws RemoteException { if (input == null) return null; String[] reversed = new String[input.length]; for (int i = 0; i < input.length; i++) { repeated[i] = input[i]; reversed[i] = input[input.length - i - 1]; } return reversed; } @Override public List ReverseUtf8CppStringList(List input, List repeated) throws RemoteException { // note - cannot clear 'repeated' here, we can only change its length if (input == null) return null; ArrayList reversed = new ArrayList(); for (String a : input) { repeated.add(a); reversed.add(0, a); } return reversed; } @Override public INamedCallback GetCallback(boolean return_null) throws RemoteException { if (return_null) return null; return new MyNamedCallback("a callback named GetCallback"); } @Override public void FillOutStructuredParcelable(StructuredParcelable parcelable) throws RemoteException { parcelable.shouldBeJerry = "Jerry"; parcelable.shouldContainThreeFs = new int[] {parcelable.f, parcelable.f, parcelable.f}; parcelable.shouldBeByteBar = ByteEnum.BAR; parcelable.shouldBeIntBar = IntEnum.BAR; parcelable.shouldBeLongBar = LongEnum.BAR; parcelable.shouldContainTwoByteFoos = new byte[] {ByteEnum.FOO, ByteEnum.FOO}; parcelable.shouldContainTwoIntFoos = new int[] {IntEnum.FOO, IntEnum.FOO}; parcelable.shouldContainTwoLongFoos = new long[] {LongEnum.FOO, LongEnum.FOO}; parcelable.const_exprs_1 = ConstantExpressionEnum.decInt32_1; parcelable.const_exprs_2 = ConstantExpressionEnum.decInt32_2; parcelable.const_exprs_3 = ConstantExpressionEnum.decInt64_1; parcelable.const_exprs_4 = ConstantExpressionEnum.decInt64_2; parcelable.const_exprs_5 = ConstantExpressionEnum.decInt64_3; parcelable.const_exprs_6 = ConstantExpressionEnum.decInt64_4; parcelable.const_exprs_7 = ConstantExpressionEnum.hexInt32_1; parcelable.const_exprs_8 = ConstantExpressionEnum.hexInt32_2; parcelable.const_exprs_9 = ConstantExpressionEnum.hexInt32_3; parcelable.const_exprs_10 = ConstantExpressionEnum.hexInt64_1; parcelable.shouldSetBit0AndBit2 = StructuredParcelable.BIT0 | StructuredParcelable.BIT2; parcelable.u = Union.ns(new int[] {1, 2, 3}); parcelable.shouldBeConstS1 = Union.s(Union.S1); } @Override public void RepeatExtendableParcelable(ExtendableParcelable ep, ExtendableParcelable ep2) throws RemoteException { ep2.a = ep.a; ep2.b = ep.b; // no way to copy currently w/o unparceling ep2.ext.setParcelable(ep.ext.getParcelable(MyExt.class)); ep2.c = ep.c; ep2.ext2.setParcelable(null); } @Override public RecursiveList ReverseList(RecursiveList list) throws RemoteException { RecursiveList reversed = null; while (list != null) { RecursiveList next = list.next; list.next = reversed; reversed = list; list = next; } return reversed; } @Override public IBinder[] ReverseIBinderArray(IBinder[] input, IBinder[] repeated) { IBinder[] reversed = new IBinder[input.length]; for (int i = 0; i < input.length; i++) { repeated[i] = input[i]; reversed[i] = input[input.length - i - 1]; } return reversed; } @Override public IBinder[] ReverseNullableIBinderArray(IBinder[] input, IBinder[] repeated) { IBinder[] reversed = new IBinder[input.length]; for (int i = 0; i < input.length; i++) { repeated[i] = input[i]; reversed[i] = input[input.length - i - 1]; } return reversed; } @Override public SimpleParcelable RepeatSimpleParcelable(SimpleParcelable input, SimpleParcelable repeat) throws RemoteException { repeat.set(input.getName(), input.getNumber()); return input; } @Override public SimpleParcelable[] ReverseSimpleParcelables( SimpleParcelable[] input, SimpleParcelable[] repeated) throws RemoteException { SimpleParcelable[] reversed = new SimpleParcelable[input.length]; for (int i = 0; i < input.length; i++) { repeated[i] = input[i]; reversed[i] = input[input.length - i - 1]; } return reversed; } private static class MyOldName extends IOldName.Stub { @Override public String RealName() { return "OldName"; } } @Override public IOldName GetOldNameInterface() throws RemoteException { return new MyOldName(); } private static class MyNewName extends INewName.Stub { @Override public String RealName() { return "NewName"; } } @Override public INewName GetNewNameInterface() throws RemoteException { return new MyNewName(); } @Override public int[] GetUnionTags(Union[] input) throws RemoteException { int[] tags = new int[input.length]; for (int i = 0; i < input.length; i++) { tags[i] = input[i].getTag(); } return tags; } class MyCppJavaTests extends ICppJavaTests.Stub { @Override public BadParcelable RepeatBadParcelable(BadParcelable input) throws RemoteException { return input; } @Override public GenericStructuredParcelable RepeatGenericParcelable( GenericStructuredParcelable input, GenericStructuredParcelable repeat) throws RemoteException { repeat.a = input.a; repeat.b = input.b; return input; } @Override public PersistableBundle RepeatPersistableBundle(PersistableBundle input) throws RemoteException { return input; } @Override public PersistableBundle[] ReversePersistableBundles( PersistableBundle[] input, PersistableBundle[] repeated) throws RemoteException { PersistableBundle[] reversed = new PersistableBundle[input.length]; for (int i = 0; i < input.length; i++) { repeated[i] = input[i]; reversed[i] = input[input.length - i - 1]; } return reversed; } @Override public Union ReverseUnion(Union input, Union repeated) throws RemoteException { int[] repeatedArray = new int[input.getNs().length]; int[] reversedArray = ReverseInt(input.getNs(), repeatedArray); repeated.setNs(repeatedArray); return Union.ns(reversedArray); } @Override public List ReverseNamedCallbackList(List input, List repeated) throws RemoteException { ArrayList reversed = new ArrayList(); for (IBinder a : input) { repeated.add(a); reversed.add(0, a); } return reversed; } @Override public FileDescriptor RepeatFileDescriptor(FileDescriptor read) throws RemoteException { return read; } @Override public FileDescriptor[] ReverseFileDescriptorArray( FileDescriptor[] input, FileDescriptor[] repeated) throws RemoteException { FileDescriptor[] reversed = new FileDescriptor[input.length]; for (int i = 0; i < input.length; i++) { repeated[i] = input[i]; reversed[i] = input[input.length - i - 1]; } return reversed; } } public static class FixedSizeArrayService extends IRepeatFixedSizeArray.Stub { @Override public byte[] RepeatBytes(byte[] input, byte[] repeated) throws RemoteException { for (int i = 0; i < input.length; i++) { repeated[i] = input[i]; } return input; } @Override public int[] RepeatInts(int[] input, int[] repeated) throws RemoteException { for (int i = 0; i < input.length; i++) { repeated[i] = input[i]; } return input; } @Override public IBinder[] RepeatBinders(IBinder[] input, IBinder[] repeated) throws RemoteException { for (int i = 0; i < input.length; i++) { repeated[i] = input[i]; } return input; } @Override public IntParcelable[] RepeatParcelables(IntParcelable[] input, IntParcelable[] repeated) throws RemoteException { for (int i = 0; i < input.length; i++) { repeated[i] = input[i]; } return input; } @Override public byte[][] Repeat2dBytes(byte[][] input, byte[][] repeated) throws RemoteException { for (int i = 0; i < input.length; i++) { for (int j = 0; j < input[i].length; j++) { repeated[i][j] = input[i][j]; } } return input; } @Override public int[][] Repeat2dInts(int[][] input, int[][] repeated) throws RemoteException { for (int i = 0; i < input.length; i++) { for (int j = 0; j < input[i].length; j++) { repeated[i][j] = input[i][j]; } } return input; } @Override public IBinder[][] Repeat2dBinders(IBinder[][] input, IBinder[][] repeated) throws RemoteException { for (int i = 0; i < input.length; i++) { for (int j = 0; j < input[i].length; j++) { repeated[i][j] = input[i][j]; } } return input; } @Override public IntParcelable[][] Repeat2dParcelables( IntParcelable[][] input, IntParcelable[][] repeated) throws RemoteException { for (int i = 0; i < input.length; i++) { for (int j = 0; j < input[i].length; j++) { repeated[i][j] = input[i][j]; } } return input; } } @Override public IBinder GetCppJavaTests() throws RemoteException { return new MyCppJavaTests(); } @Override public byte getBackendType() throws RemoteException { return BackendType.JAVA; } private static class MyCircular extends ICircular.Stub { private ITestService mSrv; MyCircular(ITestService srv) { mSrv = srv; } @Override public ITestService GetTestService() { return mSrv; } } @Override public ICircular GetCircular(CircularParcelable cp) throws RemoteException { cp.testService = this; return new MyCircular(this); } public static class TrunkStableService extends ITrunkStableTest.Stub { @Override public MyParcelable repeatParcelable(MyParcelable input) throws android.os.RemoteException { return input; } @Override public byte repeatEnum(byte input) throws android.os.RemoteException { return input; } @Override public ITrunkStableTest.MyUnion repeatUnion(MyUnion input) throws android.os.RemoteException { return input; } @Override public void callMyCallback(IMyCallback cb) throws android.os.RemoteException { MyParcelable p1, p2; p1 = new MyParcelable(); p2 = cb.repeatParcelable(p1); byte e1, e2; e1 = MyEnum.THREE; e2 = cb.repeatEnum(e1); MyUnion u1, u2; u1 = new MyUnion(); u2 = cb.repeatUnion(u1); MyOtherParcelable o1, o2; o1 = new MyOtherParcelable(); // expected to fail when not using the frozen version try { o2 = cb.repeatOtherParcelable(o1); } catch (RemoteException e) { } } @Override public MyOtherParcelable repeatOtherParcelable(MyOtherParcelable input) throws android.os.RemoteException { return input; } @Override public final int getInterfaceVersion() { return super.VERSION; } @Override public final String getInterfaceHash() { return super.HASH; } } } ./PaxHeaders.X/tests_java_src_android_aidl_tests_0100644 0000000 0000000 00000000034 15172120304 021303 xustar000000000 0000000 28 mtime=1776853188.7680000 tests/java/src/android/aidl/tests/0040755 0000000 0000000 00000000000 15172120304 016150 5ustar000000000 0000000 ./PaxHeaders.X/tests_java_src_android_aidl_tests_AidlJavaTests.java0100644 0000000 0000000 00000000034 15172120304 024642 xustar000000000 0000000 28 mtime=1776853188.7680000 tests/java/src/android/aidl/tests/AidlJavaTests.java0100644 0000000 0000000 00000001362 15172120304 021510 0ustar000000000 0000000 package android.aidl.tests; import org.junit.internal.TextListener; import org.junit.runner.JUnitCore; import org.junit.runner.Result; public class AidlJavaTests { public static void main(String[] args) { JUnitCore junit = new JUnitCore(); junit.addListener(new TextListener(System.out)); Result result = junit.run(ExtensionTests.class, GenericTests.class, JavaOnlyImmutableAnnotationTests.class, MapTests.class, NullableTests.class, TestServiceClient.class, TestVersionedInterface.class, UnionTests.class, VintfTests.class, BuiltInTests.class, DelegatorTests.class, TrunkStableTests.class); System.out.println(result.wasSuccessful() ? "TEST SUCCESS" : "TEST FAILURE"); } } ./PaxHeaders.X/tests_java_src_android_aidl_tests_BadParcelable.java0100644 0000000 0000000 00000000034 15172120304 024605 xustar000000000 0000000 28 mtime=1776853188.7690000 tests/java/src/android/aidl/tests/BadParcelable.java0100644 0000000 0000000 00000004414 15172120304 021454 0ustar000000000 0000000 /* * Copyright (C) 2021, 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. */ package android.aidl.tests; import android.os.Parcel; import android.os.Parcelable; public class BadParcelable implements Parcelable { private boolean mBad; private String mName; private int mNumber; BadParcelable() {} BadParcelable(boolean bad, String name, int number) { this.mBad = bad; this.mName = name; this.mNumber = number; } public int describeContents() { return 0; } public void writeToParcel(Parcel dest, int flags) { dest.writeBoolean(mBad); dest.writeString(mName); dest.writeInt(mNumber); // BAD! write superfluous data if (mBad) { dest.writeInt(42); } } public void readFromParcel(Parcel source) { mBad = source.readBoolean(); mName = source.readString(); mNumber = source.readInt(); } public boolean equals(Object o) { if (o == null) { return false; } if (!(o instanceof BadParcelable)) { return false; } BadParcelable p = (BadParcelable) o; if (mBad != p.mBad) { return false; } if ((mName == null && p.mName != null) || (mName != null && !mName.equals(p.mName))) { return false; } return mNumber == p.mNumber; } public String toString() { return "BadParcelable(bad=" + mBad + ",name=" + mName + ",number=" + mNumber + "}"; } public static final Parcelable.Creator CREATOR = new Parcelable.Creator() { public BadParcelable createFromParcel(Parcel source) { BadParcelable p = new BadParcelable(); p.readFromParcel(source); return p; } public BadParcelable[] newArray(int size) { return new BadParcelable[size]; } }; } ./PaxHeaders.X/tests_java_src_android_aidl_tests_BuiltInTests.java0100644 0000000 0000000 00000000034 15172120304 024535 xustar000000000 0000000 28 mtime=1776853188.7690000 tests/java/src/android/aidl/tests/BuiltInTests.java0100644 0000000 0000000 00000002763 15172120304 021411 0ustar000000000 0000000 /* * Copyright (C) 2021, 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. */ package android.aidl.tests; import static org.hamcrest.core.Is.is; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertThat; import static org.junit.Assert.assertTrue; import android.os.IBinder; import android.os.RemoteException; import android.os.ServiceManager; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; @RunWith(JUnit4.class) public class BuiltInTests { private IBinder mBinder; @Before public void setUp() throws RemoteException { mBinder = ServiceManager.waitForService(ITestService.class.getName()); assertNotNull(mBinder); } @Test public void testPing() { assertTrue(mBinder.pingBinder()); } @Test public void testInterfaceDescriptor() throws RemoteException { assertThat(mBinder.getInterfaceDescriptor(), is("android.aidl.tests.ITestService")); } } ./PaxHeaders.X/tests_java_src_android_aidl_tests_DelegatorTests.java0100644 0000000 0000000 00000000034 15172120304 025075 xustar000000000 0000000 28 mtime=1776853188.7690000 tests/java/src/android/aidl/tests/DelegatorTests.java0100644 0000000 0000000 00000004766 15172120304 021756 0ustar000000000 0000000 /* * Copyright (C) 2022, 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. */ package android.aidl.tests; import static org.hamcrest.core.Is.is; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertThat; import android.os.IBinder; import android.os.RemoteException; import android.os.ServiceManager; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; @RunWith(JUnit4.class) public class DelegatorTests { static byte kFakeByte = 16; static byte kExpectedByte = 12; private class Custom extends ITestService.Delegator { public Custom(ITestService impl) { super(impl); } @Override public byte RepeatByte(byte token) throws RemoteException { return kFakeByte; } } @Test public void testDelegator() throws RemoteException { IBinder binder = ServiceManager.waitForService(ITestService.class.getName()); assertNotNull(binder); ITestService service = ITestService.Stub.asInterface(binder); ITestService.Delegator delegator = new ITestService.Delegator(service); assertThat(delegator.RepeatByte(kExpectedByte), is(kExpectedByte)); } @Test public void testCustomDelegator() throws RemoteException { IBinder binder = ServiceManager.waitForService(ITestService.class.getName()); assertNotNull(binder); ITestService service = ITestService.Stub.asInterface(binder); ITestService.Delegator custom = new Custom(service); assertThat(custom.RepeatByte(kExpectedByte), is(kFakeByte)); } @Test public void testAsBinderAsInterface() throws RemoteException { IBinder binder = ServiceManager.waitForService(ITestService.class.getName()); assertNotNull(binder); ITestService service = ITestService.Stub.asInterface(binder); ITestService.Delegator delegator = new ITestService.Delegator(service); assertThat(ITestService.Delegator.asInterface(delegator.asBinder()).RepeatByte(kExpectedByte), is(kExpectedByte)); } } ./PaxHeaders.X/tests_java_src_android_aidl_tests_ExtensionTests.java0100644 0000000 0000000 00000000034 15172120304 025143 xustar000000000 0000000 28 mtime=1776853188.7690000 tests/java/src/android/aidl/tests/ExtensionTests.java0100644 0000000 0000000 00000020016 15172120304 022006 0ustar000000000 0000000 /* * 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. */ package android.aidl.tests; import static org.hamcrest.core.Is.is; import static org.hamcrest.core.IsNull.nullValue; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertThat; import static org.junit.Assume.assumeTrue; import static org.testng.Assert.assertThrows; import android.aidl.tests.extension.ExtendableParcelable; import android.aidl.tests.extension.MyExt; import android.aidl.tests.extension.MyExt2; import android.aidl.tests.extension.MyExtLike; import android.aidl.tests.nonvintf.NonVintfExtendableParcelable; import android.aidl.tests.nonvintf.NonVintfParcelable; import android.aidl.tests.unstable.UnstableExtendableParcelable; import android.aidl.tests.unstable.UnstableParcelable; import android.aidl.tests.vintf.VintfExtendableParcelable; import android.aidl.tests.vintf.VintfParcelable; import android.os.BadParcelableException; import android.os.IBinder; import android.os.Parcel; import android.os.ParcelableHolder; import android.os.RemoteException; import android.os.ServiceManager; import java.util.Arrays; import java.util.HashMap; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; @RunWith(JUnit4.class) public class ExtensionTests { private VintfExtendableParcelable vep; private VintfParcelable vp; private NonVintfExtendableParcelable sep; private NonVintfParcelable sp; private UnstableExtendableParcelable uep; private UnstableParcelable up; private ITestService mService; @Before public void setUp() { IBinder binder = ServiceManager.waitForService(ITestService.class.getName()); assertNotNull(binder); mService = ITestService.Stub.asInterface(binder); assertNotNull(mService); vep = new VintfExtendableParcelable(); vp = new VintfParcelable(); sep = new NonVintfExtendableParcelable(); sp = new NonVintfParcelable(); uep = new UnstableExtendableParcelable(); up = new UnstableParcelable(); } @Test public void testRepeatExtendableParcelable() throws RemoteException { MyExt ext = new MyExt(); ext.a = 42; ext.b = "EXT"; ExtendableParcelable ep = new ExtendableParcelable(); ep.a = 1; ep.b = "a"; ep.c = 42L; ep.ext.setParcelable(ext); ExtendableParcelable ep2 = new ExtendableParcelable(); mService.RepeatExtendableParcelable(ep, ep2); assertThat(ep2.a, is(ep.a)); assertThat(ep2.b, is(ep.b)); MyExt retExt = ep2.ext.getParcelable(MyExt.class); assertThat(retExt.a, is(ext.a)); assertThat(retExt.b, is(ext.b)); } @Test public void testVintfParcelableHolderCanContainVintfParcelable() { vep.ext.setParcelable(vp); assertThat(vep.ext.getParcelable(VintfParcelable.class), is(vp)); } @Test public void testVintfParcelableHolderCannotContainNonVintfParcelable() { assertThrows(BadParcelableException.class, () -> { vep.ext.setParcelable(sp); }); assertThat(vep.ext.getParcelable(VintfParcelable.class), is(nullValue())); } @Test public void testVintfParcelableHolderCannotContainUnstableParcelable() { assertThrows(BadParcelableException.class, () -> { vep.ext.setParcelable(up); }); assertThat(vep.ext.getParcelable(UnstableParcelable.class), is(nullValue())); } @Test public void testStableParcelableHolderCanContainVintfParcelable() { sep.ext.setParcelable(vp); assertThat(sep.ext.getParcelable(VintfParcelable.class), is(vp)); } @Test public void testStableParcelableHolderCanContainNonVintfParcelable() { sep.ext.setParcelable(sp); assertThat(sep.ext.getParcelable(NonVintfParcelable.class), is(sp)); } @Test public void testStableParcelableHolderCanContainUnstableParcelable() { sep.ext.setParcelable(up); assertThat(sep.ext.getParcelable(UnstableParcelable.class), is(up)); } @Test public void testUnstableParcelableHolderCanContainVintfParcelable() { uep.ext.setParcelable(vp); assertThat(uep.ext.getParcelable(VintfParcelable.class), is(vp)); } @Test public void testUnstableParcelableHolderCanContainNonVintfParcelable() { uep.ext.setParcelable(sp); assertThat(uep.ext.getParcelable(NonVintfParcelable.class), is(sp)); } @Test public void testUnstableParcelableHolderCanContainUnstableParcelable() { uep.ext.setParcelable(up); assertThat(uep.ext.getParcelable(UnstableParcelable.class), is(up)); } @Test public void testReadWriteExtension() { MyExt ext = new MyExt(); ext.a = 42; ext.b = "EXT"; MyExt2 ext2 = new MyExt2(); ext2.a = 42; ext2.b = new MyExt(); ext2.b.a = 24; ext2.b.b = "INEXT"; ext2.c = "EXT2"; Parcel parcel = Parcel.obtain(); { ExtendableParcelable ep = new ExtendableParcelable(); ep.a = 1; ep.b = "a"; ep.c = 42L; ep.ext.setParcelable(ext); ep.ext2.setParcelable(ext2); // The extension type must be MyExt, so it has to fail // even though MyExtLike has the same structure as MyExt. assertThrows(BadParcelableException.class, () -> { MyExtLike extLike = ep.ext.getParcelable(MyExtLike.class); }); MyExt actualExt = ep.ext.getParcelable(MyExt.class); MyExt2 actualExt2 = ep.ext2.getParcelable(MyExt2.class); checkContent(ep, ext, ext2); ep.writeToParcel(parcel, 0); } parcel.setDataPosition(0); { ExtendableParcelable ep1 = new ExtendableParcelable(); ep1.readFromParcel(parcel); parcel.setDataPosition(0); ep1.writeToParcel(parcel, 0); parcel.setDataPosition(0); ExtendableParcelable ep2 = new ExtendableParcelable(); ep2.readFromParcel(parcel); // The extension type must be MyExt, so it has to fail // even though MyExtLike has the same structure as MyExt. assertThrows(BadParcelableException.class, () -> { MyExtLike extLike = ep2.ext.getParcelable(MyExtLike.class); }); MyExt actualExt = ep2.ext.getParcelable(MyExt.class); MyExt2 newExt2 = new MyExt2(); newExt2.a = 79; newExt2.b = new MyExt(); newExt2.b.a = 42; newExt2.b.b = "INNEWEXT"; newExt2.c = "NEWEXT2"; ep2.ext2.setParcelable(newExt2); checkContent(ep1, ext, ext2); checkContent(ep2, ext, newExt2); } } private void checkContent(ExtendableParcelable ep, MyExt ext, MyExt2 ext2) { assertThat(ep.a, is(1)); assertThat(ep.b, is("a")); assertThat(ep.c, is(42L)); MyExt actualExt = ep.ext.getParcelable(MyExt.class); assertThat(dumpMyExt(actualExt), is(dumpMyExt(ext))); MyExt2 actualExt2 = ep.ext2.getParcelable(MyExt2.class); assertThat(dumpMyExt2(actualExt2), is(dumpMyExt2(ext2))); } private static String dumpMyExt(MyExt ext) { if (ext == null) { return null; } return "{a: " + ext.a + ", b: " + ext.b + "}"; } private static String dumpMyExt2(MyExt2 ext2) { if (ext2 == null) { return null; } return "{a: " + ext2.a + ", b: " + dumpMyExt(ext2.b) + ", " + ext2.c + "}"; } } ./PaxHeaders.X/tests_java_src_android_aidl_tests_GenericTests.java0100644 0000000 0000000 00000000034 15172120304 024543 xustar000000000 0000000 28 mtime=1776853188.7700000 tests/java/src/android/aidl/tests/GenericTests.java0100644 0000000 0000000 00000004535 15172120304 021416 0ustar000000000 0000000 /* * Copyright (C) 2019, 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. */ package android.aidl.tests; import static org.hamcrest.core.Is.is; import static org.junit.Assert.assertThat; import android.aidl.tests.IntEnum; import android.aidl.tests.generic.Baz; import android.aidl.tests.generic.IFaz; import android.aidl.tests.generic.Pair; import android.os.IBinder; import android.os.RemoteException; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; @RunWith(JUnit4.class) public class GenericTests { @Test public void testGeneric() throws RemoteException { IFaz.Stub ifaz = new IFaz.Stub() { public Pair getPair() { Pair ret = new Pair(); ret.mFirst = 15; ret.mSecond = "My"; return ret; } public Pair getPair2() { Pair ret = new Pair(); ret.mFirst = new Baz(); ret.mFirst.a = 15; ret.mSecond = new Baz(); ret.mSecond.a = 16; return ret; } public Pair getPair3() { Pair ret = new Pair(); ret.mFirst = 15; ret.mSecond = IntEnum.BAR; return ret; } }; IFaz service = IFaz.Stub.asInterface(ifaz); assertThat(service.getPair().mFirst, is(15)); assertThat(service.getPair().mSecond, is("My")); assertThat(service.getPair2().mFirst.a, is(15)); assertThat(service.getPair2().mSecond.a, is(16)); assertThat(service.getPair3().mFirst, is(15)); assertThat(service.getPair3().mSecond, is(IntEnum.BAR)); } } ./PaxHeaders.X/tests_java_src_android_aidl_tests_JavaOnlyImmutableAnnotationTests.java0100644 0000000 0000000 00000000034 15172120304 030605 xustar000000000 0000000 28 mtime=1776853188.7700000 tests/java/src/android/aidl/tests/JavaOnlyImmutableAnnotationTests.java0100644 0000000 0000000 00000011100 15172120304 025442 0ustar000000000 0000000 /* * 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. */ package android.aidl.tests; import static org.hamcrest.core.Is.is; import static org.junit.Assert.assertThat; import static org.junit.Assert.fail; import android.aidl.tests.immutable.Bar; import android.aidl.tests.immutable.Foo; import android.aidl.tests.immutable.Union; import android.os.Parcel; import android.os.RemoteException; import java.lang.UnsupportedOperationException; import java.lang.reflect.Field; import java.lang.reflect.Modifier; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; @RunWith(JUnit4.class) public class JavaOnlyImmutableAnnotationTests { @Test public void testReadWriteJavaOnlyImmutableParcelable() { Parcel parcel = Parcel.obtain(); List list = new ArrayList(); list.add(new Bar("aa")); Map map = new HashMap(); map.put("key", new Bar("value")); Bar[] array = new Bar[3]; array[0] = new Bar("zero"); array[1] = new Bar("one"); array[2] = new Bar("two"); Foo foo = new Foo(7, new Bar("my"), list, map, array, Union.num(42)); foo.writeToParcel(parcel, 0); parcel.setDataPosition(0); Foo foo2 = Foo.CREATOR.createFromParcel(parcel); assertThat(foo.a, is(foo2.a)); assertThat(foo.b.s, is(foo2.b.s)); assertThat(foo.c.size(), is(foo.c.size())); assertThat(foo.c.get(0).s, is(foo2.c.get(0).s)); assertThat(foo.c.size(), is(foo.c.size())); assertThat(foo.d.get("key").s, is(foo2.d.get("key").s)); assertThat(foo.e.length, is(foo.e.length)); for (int i = 0; i < foo.e.length; i++) { assertThat(foo.e[i].s, is(foo2.e[i].s)); } assertThat(foo.u.getNum(), is(foo2.u.getNum())); } @Test public void testEveryFieldIsFinal() { for (Field f : Foo.class.getDeclaredFields()) { if (!Modifier.isFinal(f.getModifiers())) { fail(f.getName() + " should be final."); } } } @Test(expected = UnsupportedOperationException.class) public void testListIsUnmodifiable() { Foo foo = new Foo(7, new Bar("my"), new ArrayList(), new HashMap(), new Bar[5], Union.num(42)); foo.c.add(new Bar("hi")); // It is supposed to fail. fail("A List in an immutable parcelable isn't modifiable."); } @Test(expected = UnsupportedOperationException.class) public void testMapIsUnmodifiable() { Foo foo = new Foo(7, new Bar("my"), new ArrayList(), new HashMap(), new Bar[5], Union.num(42)); foo.d.put("key", new Bar("value")); // It is supposed to fail. fail("A Map in an immutable parcelable isn't modifiable."); } @Test public void testBuilderRespectDefaultValue() { assertThat(new Foo.Builder().build().a, is(10)); assertThat(new Bar.Builder().build().s, is("bar")); } @Test public void testBuilder() { Bar b = new Bar("my"); List list = new ArrayList(); list.add(new Bar("aa")); Map map = new HashMap(); map.put("key", new Bar("value")); Bar[] array = new Bar[3]; array[0] = new Bar("zero"); array[1] = new Bar("one"); array[2] = new Bar("two"); Foo foo = new Foo(7, b, list, map, array, Union.num(42)); Foo foo2 = new Foo.Builder() .setA(7) .setB(b) .setC(list) .setD(map) .setE(array) .setU(Union.num(42)) .build(); assertThat(foo.a, is(foo2.a)); assertThat(foo.b.s, is(foo2.b.s)); assertThat(foo.c.size(), is(foo.c.size())); assertThat(foo.c.get(0).s, is(foo2.c.get(0).s)); assertThat(foo.c.size(), is(foo.c.size())); assertThat(foo.d.get("key").s, is(foo2.d.get("key").s)); assertThat(foo.e.length, is(foo.e.length)); for (int i = 0; i < foo.e.length; i++) { assertThat(foo.e[i].s, is(foo2.e[i].s)); } assertThat(foo.u.getNum(), is(foo2.u.getNum())); } } ./PaxHeaders.X/tests_java_src_android_aidl_tests_MapTests.java0100644 0000000 0000000 00000000034 15172120304 023704 xustar000000000 0000000 28 mtime=1776853188.7700000 tests/java/src/android/aidl/tests/MapTests.java0100644 0000000 0000000 00000006620 15172120304 020554 0ustar000000000 0000000 /* * Copyright (C) 2019, 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. */ package android.aidl.tests; import static org.hamcrest.core.Is.is; import static org.junit.Assert.assertThat; import android.aidl.tests.map.Bar; import android.aidl.tests.map.Foo; import android.aidl.tests.map.IEmpty; import android.aidl.tests.map.IntEnum; import android.os.Parcel; import java.util.HashMap; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; @RunWith(JUnit4.class) public class MapTests { @Test public void testWriteAndThenReadMaps() { Parcel parcel = Parcel.obtain(); // Write Foo foo = new Foo(); foo.intEnumArrayMap = new HashMap<>(); foo.intEnumArrayMap.put("Foo", new int[] {IntEnum.FOO}); foo.intArrayMap = new HashMap<>(); foo.intArrayMap.put("Foo", new int[] {42}); Bar bar = new Bar(); bar.a = 42; bar.b = "Bar"; foo.barMap = new HashMap<>(); foo.barMap.put("Foo", bar); foo.barArrayMap = new HashMap<>(); foo.barArrayMap.put("Foo", new Bar[] {bar}); foo.stringMap = new HashMap<>(); foo.stringMap.put("Foo", "Bar"); foo.stringArrayMap = new HashMap<>(); foo.stringArrayMap.put("Foo", new String[] {"Bar"}); IEmpty intf = new IEmpty.Stub() {}; foo.interfaceMap = new HashMap<>(); foo.interfaceMap.put("Foo", intf); foo.ibinderMap = new HashMap<>(); foo.ibinderMap.put("Foo", intf.asBinder()); foo.writeToParcel(parcel, 0); // And then read parcel.setDataPosition(0); Foo readFoo = new Foo(); readFoo.readFromParcel(parcel); assertThat(readFoo.intEnumArrayMap.size(), is(1)); assertThat(readFoo.intEnumArrayMap.get("Foo"), is(new int[] {IntEnum.FOO})); assertThat(readFoo.intArrayMap.size(), is(1)); assertThat(readFoo.intArrayMap.get("Foo"), is(new int[] {42})); assertThat(readFoo.barMap.containsKey("Foo"), is(true)); assertThat(readFoo.barMap.size(), is(1)); Bar readBar = readFoo.barMap.get("Foo"); assertThat(readBar.a, is(42)); assertThat(readBar.b, is("Bar")); Bar[] bars = readFoo.barArrayMap.get("Foo"); assertThat(bars.length, is(1)); assertThat(bars[0].a, is(42)); assertThat(bars[0].b, is("Bar")); assertThat(readFoo.stringMap.size(), is(1)); assertThat(readFoo.stringMap.get("Foo"), is("Bar")); String[] strings = readFoo.stringArrayMap.get("Foo"); assertThat(strings.length, is(1)); assertThat(strings[0], is("Bar")); assertThat(readFoo.interfaceMap.size(), is(1)); assertThat(readFoo.interfaceMap.get("Foo"), is(intf)); assertThat(readFoo.ibinderMap.size(), is(1)); assertThat(readFoo.ibinderMap.get("Foo"), is(intf.asBinder())); } } ./PaxHeaders.X/tests_java_src_android_aidl_tests_NestedTypesTests.java0100644 0000000 0000000 00000000034 15172120304 025436 xustar000000000 0000000 28 mtime=1776853188.7700000 tests/java/src/android/aidl/tests/NestedTypesTests.java0100644 0000000 0000000 00000004116 15172120304 022304 0ustar000000000 0000000 /* * Copyright (C) 2021, 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. */ package android.aidl.tests; import static org.hamcrest.core.Is.is; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertThat; import static org.junit.Assume.assumeTrue; import android.aidl.tests.nested.INestedService; import android.aidl.tests.nested.ParcelableWithNested; import android.os.IBinder; import android.os.RemoteException; import android.os.ServiceManager; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; @RunWith(JUnit4.class) public class NestedTypesTests { @Test public void testUseNestedTypes() throws RemoteException { IBinder binder = ServiceManager.waitForService(INestedService.class.getName()); assertNotNull(binder); INestedService nestedService = INestedService.Stub.asInterface(binder); assertNotNull(nestedService); // OK -> NOT_OK ParcelableWithNested p = new ParcelableWithNested(); p.status = ParcelableWithNested.Status.OK; INestedService.Result result = nestedService.flipStatus(p); assertThat(result, is(ParcelableWithNested.Status.NOT_OK)); // NOT_OK -> OK with nested callback interface class Callback extends INestedService.ICallback.Stub { byte received = ParcelableWithNested.Status.NOT_OK; @Override public void done(byte st) { received = st; } } Callback cb = new Callback(); nestedService.flipStatusWithCallback(p.status, cb); assertThat(cb.received, is(ParcelableWithNested.Status.OK)); } } ./PaxHeaders.X/tests_java_src_android_aidl_tests_NullableTests.java0100644 0000000 0000000 00000000034 15172120304 024725 xustar000000000 0000000 28 mtime=1776853188.7700000 tests/java/src/android/aidl/tests/NullableTests.java0100644 0000000 0000000 00000011637 15172120304 021601 0ustar000000000 0000000 /* * 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. */ package android.aidl.tests; import static org.hamcrest.core.Is.is; import static org.hamcrest.core.IsNull.notNullValue; import static org.hamcrest.core.IsNull.nullValue; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertThat; import static org.junit.Assert.fail; import static org.junit.Assume.assumeTrue; import android.os.Binder; import android.os.IBinder; import android.os.RemoteException; import android.os.ServiceManager; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; @RunWith(JUnit4.class) public class NullableTests { private ITestService mService; private ICppJavaTests mCppJavaTests; @Before public void setUp() throws RemoteException { IBinder binder = ServiceManager.waitForService(ITestService.class.getName()); assertNotNull(binder); mService = ITestService.Stub.asInterface(binder); assertNotNull(mService); IBinder binder2 = mService.GetCppJavaTests(); if (binder2 != null) { mCppJavaTests = ICppJavaTests.Stub.asInterface(binder2); } } @Test public void testExpectNpeWithNullString() throws RemoteException { try { String response = mService.RepeatString(null); } catch (NullPointerException ex) { return; } if (mService.getBackendType() != BackendType.JAVA) { fail("NullPointerException was expected, but wasn't thrown"); } } @Test public void testRepeatNullableParcelableArray() throws RemoteException { ITestService.Empty[] input = {new ITestService.Empty(), null}; assertThat(mService.RepeatNullableParcelableArray(input), is(input)); assertThat(mService.RepeatNullableParcelableArray(null), is(nullValue())); } @Test public void testRepeatNullableParcelableList() throws RemoteException { List input = Arrays.asList(new ITestService.Empty(), null); assertThat(mService.RepeatNullableParcelableList(input), is(input)); assertThat(mService.RepeatNullableParcelableList(null), is(nullValue())); } @Test public void testExpectNpeWithNullBinder() throws RemoteException { try { mService.TakesAnIBinder(null); } catch (NullPointerException ex) { return; } if (mService.getBackendType() != BackendType.JAVA) { fail("NullPointerException was expected, but wasn't thrown"); } } @Test public void testExpectNpeWithNullBinderList() throws RemoteException { List listWithNulls = new ArrayList(); listWithNulls.add(null); try { mService.TakesAnIBinderList(listWithNulls); } catch (NullPointerException ex) { return; } if (mService.getBackendType() != BackendType.JAVA) { fail("NullPointerException was expected, but wasn't thrown"); } } @Test public void testReverseIBinderArray() throws RemoteException { IBinder[] input = {new Binder(), new Binder()}; IBinder[] repeated = new IBinder[input.length]; IBinder[] reversed = mService.ReverseIBinderArray(input, repeated); assertThat(repeated, is(input)); assertThat(reversed.length, is(input.length)); for (int i = 0; i < input.length; ++i) { int j = reversed.length - (1 + i); assertThat(reversed[j], is(input[i])); } } @Test public void testReverseNullableIBinderArray() throws RemoteException { IBinder[] input = {new Binder(), null}; IBinder[] repeated = new IBinder[input.length]; IBinder[] reversed = mService.ReverseNullableIBinderArray(input, repeated); assertThat(repeated, is(input)); assertThat(reversed.length, is(input.length)); for (int i = 0; i < input.length; ++i) { int j = reversed.length - (1 + i); assertThat(reversed[j], is(input[i])); } } @Test public void testNullableIInterface() throws RemoteException { INamedCallback callback = mService.GetCallback(false); assertThat(callback, is(notNullValue())); callback = mService.GetCallback(true); assertThat(callback, is(nullValue())); } } ./PaxHeaders.X/tests_java_src_android_aidl_tests_SimpleParcelable.java0100644 0000000 0000000 00000000034 15172120304 025350 xustar000000000 0000000 28 mtime=1776853188.7700000 tests/java/src/android/aidl/tests/SimpleParcelable.java0100644 0000000 0000000 00000004542 15172120304 022221 0ustar000000000 0000000 /* * Copyright (C) 2015, 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. */ package android.aidl.tests; import android.os.Parcel; import android.os.Parcelable; public class SimpleParcelable implements Parcelable { private String mName; private int mNumber; SimpleParcelable() {} SimpleParcelable(String name, int number) { set(name, number); } public int describeContents() { return 0; } public void set(String name, int number) { mName = name; mNumber = number; } public String getName() { return mName; } public int getNumber() { return mNumber; } public void writeToParcel(Parcel dest, int flags) { dest.writeString(mName); dest.writeInt(mNumber); } public void readFromParcel(Parcel source) { mName = source.readString(); mNumber = source.readInt(); } public boolean equals(Object o) { if (o == null) { return false; } if (!(o instanceof SimpleParcelable)) { return false; } SimpleParcelable p = (SimpleParcelable)o; if ((mName == null && p.mName != null) || (mName != null && !mName.equals(p.mName))) { return false; } return mNumber == p.mNumber; } public String toString() { return "SimpleParcelable(" + mName + ", " + mNumber + ")"; } public static final Parcelable.Creator CREATOR = new Parcelable.Creator() { public SimpleParcelable createFromParcel(Parcel source) { String name = source.readString(); int number = source.readInt(); return new SimpleParcelable(name, number); } public SimpleParcelable[] newArray(int size) { return new SimpleParcelable[size]; } }; } ./PaxHeaders.X/tests_java_src_android_aidl_tests_TestServiceClient.java0100644 0000000 0000000 00000000034 15172120304 025543 xustar000000000 0000000 28 mtime=1776853188.7710000 tests/java/src/android/aidl/tests/TestServiceClient.java0100644 0000000 0000000 00000122054 15172120304 022413 0ustar000000000 0000000 /* * Copyright (C) 2015, 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. */ package android.aidl.tests; import static org.hamcrest.core.Is.is; import static org.hamcrest.core.IsNull.notNullValue; import static org.junit.Assert.assertArrayEquals; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNull; import static org.junit.Assert.assertThat; import static org.junit.Assert.assertThrows; import static org.junit.Assert.assertTrue; import static org.junit.Assume.assumeTrue; import android.aidl.fixedsizearray.FixedSizeArrayExample.IRepeatFixedSizeArray; import android.aidl.fixedsizearray.FixedSizeArrayExample.IntParcelable; import android.aidl.tests.BadParcelable; import android.aidl.tests.ByteEnum; import android.aidl.tests.GenericStructuredParcelable; import android.aidl.tests.INamedCallback; import android.aidl.tests.ITestService; import android.aidl.tests.ITestService.CompilerChecks; import android.aidl.tests.IntEnum; import android.aidl.tests.LongEnum; import android.aidl.tests.SimpleParcelable; import android.aidl.tests.StructuredParcelable; import android.aidl.tests.Union; import android.aidl.versioned.tests.IFooInterface; import android.app.Activity; import android.content.Context; import android.content.Intent; import android.os.BadParcelableException; import android.os.Bundle; import android.os.IBinder; import android.os.ParcelFileDescriptor; import android.os.Parcelable; import android.os.PersistableBundle; import android.os.RemoteException; import android.os.ServiceManager; import android.os.ServiceSpecificException; import android.util.Log; import java.io.File; import java.io.FileDescriptor; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.lang.reflect.Array; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; @RunWith(JUnit4.class) public class TestServiceClient { private ITestService service; private ICppJavaTests cpp_java_tests; @Before public void setUp() throws RemoteException { IBinder binder = ServiceManager.waitForService(ITestService.class.getName()); assertNotNull(binder); service = ITestService.Stub.asInterface(binder); assertNotNull(service); IBinder binder2 = service.GetCppJavaTests(); if (binder2 != null) { cpp_java_tests = ICppJavaTests.Stub.asInterface(binder2); } } @Test public void testBinderIdentity() throws RemoteException { IBinder binder = ServiceManager.waitForService(ITestService.class.getName()); assertEquals(binder, service.asBinder()); } @Test public void testOneway() throws RemoteException { service.TestOneway(); } @Test public void testBooleanRepeat() throws RemoteException { boolean query = true; assertThat(service.RepeatBoolean(query), is(query)); } @Test public void testCharRepeat() throws RemoteException { char query = 'A'; assertThat(service.RepeatChar(query), is(query)); } @Test public void testByteRepeat() throws RemoteException { byte query = -128; assertThat(service.RepeatByte(query), is(query)); } @Test public void testIntRepeat() throws RemoteException { int query = 1 << 30; assertThat(service.RepeatInt(query), is(query)); } @Test public void testConstRepeat() throws RemoteException { int query[] = {ITestService.CONSTANT, ITestService.CONSTANT2, ITestService.CONSTANT3, ITestService.CONSTANT4, ITestService.CONSTANT5, ITestService.CONSTANT6, ITestService.CONSTANT7, ITestService.CONSTANT8}; for (int i = 0; i < query.length; i++) { assertThat(service.RepeatInt(query[i]), is(query[i])); } } @Test public void testConstFloatRepeat() throws RemoteException { float query[] = {ITestService.FLOAT_CONSTANT, ITestService.FLOAT_CONSTANT2, ITestService.FLOAT_CONSTANT3, ITestService.FLOAT_CONSTANT4, ITestService.FLOAT_CONSTANT5, ITestService.FLOAT_CONSTANT6, ITestService.FLOAT_CONSTANT7}; for (int i = 0; i < query.length; i++) { assertThat(service.RepeatFloat(query[i]), is(query[i])); } } @Test public void testConstDoubleRepeat() throws RemoteException { double query[] = {ITestService.DOUBLE_CONSTANT, ITestService.DOUBLE_CONSTANT2, ITestService.DOUBLE_CONSTANT3, ITestService.DOUBLE_CONSTANT4, ITestService.DOUBLE_CONSTANT5, ITestService.DOUBLE_CONSTANT6, ITestService.DOUBLE_CONSTANT7}; for (int i = 0; i < query.length; i++) { assertThat(service.RepeatDouble(query[i]), is(query[i])); } } @Test public void testLongRepeat() throws RemoteException { long query = 1L << 60; assertThat(service.RepeatLong(query), is(query)); } @Test public void testFloatRepeat() throws RemoteException { float query = 1.0f/3.0f; assertThat(service.RepeatFloat(query), is(query)); } @Test public void testDoubleRepeat() throws RemoteException { double query = 1.0/3.0; assertThat(service.RepeatDouble(query), is(query)); } @Test public void testByteEnumRepeat() throws RemoteException { byte query = ByteEnum.FOO; assertThat(service.RepeatByteEnum(query), is(query)); } @Test public void testIntEnumRepeat() throws RemoteException { int query = IntEnum.FOO; assertThat(service.RepeatIntEnum(query), is(query)); } @Test public void testLongEnumRepeat() throws RemoteException { long query = LongEnum.FOO; assertThat(service.RepeatLongEnum(query), is(query)); } @Test public void testStringListRepeat() throws RemoteException { List queries = Arrays.asList( "not empty", "", "\0", ITestService.STRING_CONSTANT, ITestService.STRING_CONSTANT2); for (String query : queries) { assertThat(service.RepeatString(query), is(query)); } } @Test public void testBooleanArrayReversal() throws RemoteException { boolean[] input = {true, false, false, false}; boolean echoed[] = new boolean[input.length]; boolean[] reversed = service.ReverseBoolean(input, echoed); assertThat(echoed, is(input)); assertThat(reversed.length, is(input.length)); for (int i = 0; i < input.length; ++i) { int j = reversed.length - (1 + i); assertThat(reversed[j], is(input[i])); } } @Test public void testByteArrayReversal() throws RemoteException { byte[] input = {0, 1, 2}; byte echoed[] = new byte[input.length]; byte[] reversed = service.ReverseByte(input, echoed); assertThat(echoed, is(input)); assertThat(reversed.length, is(input.length)); for (int i = 0; i < input.length; ++i) { int j = reversed.length - (1 + i); assertThat(reversed[j], is(input[i])); } } @Test public void testCharArrayReversal() throws RemoteException { char[] input = {'A', 'B', 'C', 'D', 'E'}; char echoed[] = new char[input.length]; char[] reversed = service.ReverseChar(input, echoed); assertThat(echoed, is(input)); assertThat(reversed.length, is(input.length)); for (int i = 0; i < input.length; ++i) { int j = reversed.length - (1 + i); assertThat(reversed[j], is(input[i])); } } @Test public void testIntArrayReversal() throws RemoteException { int[] input = {-1, 0, 1, 2, 3, 4, 5, 6}; int echoed[] = new int[input.length]; int[] reversed = service.ReverseInt(input, echoed); assertThat(echoed, is(input)); assertThat(reversed.length, is(input.length)); for (int i = 0; i < input.length; ++i) { int j = reversed.length - (1 + i); assertThat(reversed[j], is(input[i])); } } @Test public void testLongArrayReversal() throws RemoteException { long[] input = {-2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8}; long echoed[] = new long[input.length]; long[] reversed = service.ReverseLong(input, echoed); assertThat(echoed, is(input)); assertThat(reversed.length, is(input.length)); for (int i = 0; i < input.length; ++i) { int j = reversed.length - (1 + i); assertThat(reversed[j], is(input[i])); } } @Test public void testFloatArrayReversal() throws RemoteException { float[] input = {0.0f, 1.0f, -0.3f}; float echoed[] = new float[input.length]; float[] reversed = service.ReverseFloat(input, echoed); assertThat(echoed, is(input)); assertThat(reversed.length, is(input.length)); for (int i = 0; i < input.length; ++i) { int j = reversed.length - (1 + i); assertThat(reversed[j], is(input[i])); } } @Test public void testDoubleArrayReversal() throws RemoteException { double[] input = {-1.0, -4.0, -2.0}; double echoed[] = new double[input.length]; double[] reversed = service.ReverseDouble(input, echoed); assertThat(echoed, is(input)); assertThat(reversed.length, is(input.length)); for (int i = 0; i < input.length; ++i) { int j = reversed.length - (1 + i); assertThat(reversed[j], is(input[i])); } } @Test public void testStringArrayReversal() throws RemoteException { String[] input = {"For", "relaxing", "times"}; String echoed[] = new String[input.length]; String[] reversed = service.ReverseString(input, echoed); assertThat(echoed, is(input)); assertThat(reversed.length, is(input.length)); for (int i = 0; i < input.length; ++i) { int j = reversed.length - (1 + i); assertThat(reversed[j], is(input[i])); } } @Test public void testBinderExchange() throws RemoteException { INamedCallback got = service.GetOtherTestService("Smythe"); assertThat(got.GetName(), is("Smythe")); assertThat(service.VerifyName(got, "Smythe"), is(true)); } @Test public void testBinderArrayExchange() throws RemoteException { String[] names = {"Fizz", "Buzz"}; INamedCallback[] got = service.GetInterfaceArray(names); assertThat(got[0].GetName(), is(names[0])); assertThat(got[1].GetName(), is(names[1])); assertThat(service.VerifyNamesWithInterfaceArray(got, names), is(true)); } @Test public void testNullableBinderArrayExchange() throws RemoteException { String[] names = {"Fizz", null, "Buzz"}; INamedCallback[] got = service.GetNullableInterfaceArray(names); assertThat(got[0].GetName(), is(names[0])); assertNull(got[1]); assertThat(got[2].GetName(), is(names[2])); assertThat(service.VerifyNamesWithNullableInterfaceArray(got, names), is(true)); } @Test public void testInterfaceListExchange() throws RemoteException { String[] names = {"Fizz", null, "Buzz"}; List got = service.GetInterfaceList(names); assertThat(got.get(0).GetName(), is(names[0])); assertNull(got.get(1)); assertThat(got.get(2).GetName(), is(names[2])); assertThat(service.VerifyNamesWithInterfaceList(got, names), is(true)); } @Test public void testListReversal() throws RemoteException { List input = Arrays.asList("Walk", "into", "Córdoba"); List echoed = new ArrayList(); List reversed = service.ReverseStringList(input, echoed); assertThat(echoed, is(input)); Collections.reverse(input); assertThat(reversed, is(input)); } @Test public void testRepeatGenericParcelable() throws RemoteException { assumeTrue(cpp_java_tests != null); GenericStructuredParcelable input = new GenericStructuredParcelable(); GenericStructuredParcelable out_param = new GenericStructuredParcelable(); input.a = 41; input.b = 42; GenericStructuredParcelable testing = input; assertThat(testing, is(input)); GenericStructuredParcelable returned = cpp_java_tests.RepeatGenericParcelable(input, out_param); assertThat(out_param.a, is(input.a)); assertThat(out_param.b, is(input.b)); assertThat(returned.a, is(input.a)); assertThat(returned.b, is(input.b)); } @Test public void testBadParcelable() throws RemoteException { assumeTrue(cpp_java_tests != null); BadParcelable bad = new BadParcelable(/*bad=*/true, "foo", 42); Throwable error = assertThrows(BadParcelableException.class, () -> cpp_java_tests.RepeatBadParcelable(bad)); assertTrue(error.getMessage().contains("Parcel data not fully consumed")); BadParcelable notBad = new BadParcelable(/*bad=*/false, "foo", 42); BadParcelable output = cpp_java_tests.RepeatBadParcelable(notBad); assertThat(notBad, is(output)); } @Test public void testRepeatParcelable() throws RemoteException { SimpleParcelable input = new SimpleParcelable("foo", 42); SimpleParcelable out_param = new SimpleParcelable(); SimpleParcelable returned = service.RepeatSimpleParcelable(input, out_param); assertThat(out_param, is(input)); assertThat(returned, is(input)); } @Test public void testReverseParcelable() throws RemoteException { SimpleParcelable[] input = new SimpleParcelable[3]; input[0] = new SimpleParcelable("a", 1); input[1] = new SimpleParcelable("b", 2); input[2] = new SimpleParcelable("c", 3); SimpleParcelable[] repeated = new SimpleParcelable[3]; SimpleParcelable[] reversed = service.ReverseSimpleParcelables(input, repeated); assertThat(repeated, is(input)); assertThat(reversed.length, is(input.length)); for (int i = 0, k = input.length - 1; i < input.length; ++i, --k) { assertThat(reversed[k], is(input[i])); } } @Test public void testRepeatEmptyPersistableBundle() throws RemoteException { assumeTrue(cpp_java_tests != null); PersistableBundle emptyBundle = new PersistableBundle(); PersistableBundle returned = cpp_java_tests.RepeatPersistableBundle(emptyBundle); assertThat(returned.size(), is(emptyBundle.size())); assertThat(returned.toString(), is(emptyBundle.toString())); } @Test public void testRepeatNonEmptyPersistableBundle() throws RemoteException { assumeTrue(cpp_java_tests != null); PersistableBundle pb = new PersistableBundle(); final String testBoolKey = "testBool"; final String testIntKey = "testInt"; final String testNestedIntKey = "testNestedInt"; final String testLongKey = "testLong"; final String testDoubleKey = "testDouble"; final String testStringKey = "testString"; final String testBoolArrayKey = "testBoolArray"; final String testIntArrayKey = "testIntArray"; final String testLongArrayKey = "testLongArray"; final String testDoubleArrayKey = "testDoubleArray"; final String testStringArrayKey = "testStringArray"; final String testPersistableBundleKey = "testPersistableBundle"; pb.putBoolean(testBoolKey, false); pb.putInt(testIntKey, 33); pb.putLong(testLongKey, 34359738368L); pb.putDouble(testDoubleKey, 1.1); pb.putString(testStringKey, new String("Woot!")); pb.putBooleanArray(testBoolArrayKey, new boolean[] {true, false, true}); pb.putIntArray(testIntArrayKey, new int[] {33, 44, 55, 142}); pb.putLongArray(testLongArrayKey, new long[] {34L, 8371L, 34359738375L}); pb.putDoubleArray(testDoubleArrayKey, new double[] {2.2, 5.4}); pb.putStringArray(testStringArrayKey, new String[] {"hello", "world!"}); PersistableBundle testNestedPersistableBundle = new PersistableBundle(); testNestedPersistableBundle.putInt(testNestedIntKey, 345); pb.putPersistableBundle(testPersistableBundleKey, testNestedPersistableBundle); PersistableBundle ret = cpp_java_tests.RepeatPersistableBundle(pb); assertThat(ret.size(), is(pb.size())); assertThat(ret.getBoolean(testBoolKey), is(pb.getBoolean(testBoolKey))); assertThat(ret.getInt(testIntKey), is(pb.getInt(testIntKey))); assertThat(ret.getLong(testLongKey), is(pb.getLong(testLongKey))); assertThat(ret.getDouble(testDoubleKey), is(pb.getDouble(testDoubleKey))); assertThat(ret.getString(testStringKey), is(pb.getString(testStringKey))); assertThat(ret.getBooleanArray(testBoolArrayKey), is(pb.getBooleanArray(testBoolArrayKey))); assertThat(ret.getIntArray(testIntArrayKey), is(pb.getIntArray(testIntArrayKey))); assertThat(ret.getLongArray(testLongArrayKey), is(pb.getLongArray(testLongArrayKey))); assertThat(ret.getDoubleArray(testDoubleArrayKey), is(pb.getDoubleArray(testDoubleArrayKey))); assertThat(ret.getStringArray(testStringArrayKey), is(pb.getStringArray(testStringArrayKey))); PersistableBundle nested = ret.getPersistableBundle(testPersistableBundleKey); assertThat(nested, is(notNullValue())); assertThat(nested.getInt(testNestedIntKey), is(testNestedPersistableBundle.getInt(testNestedIntKey))); } @Test public void testReversePersistableBundleArray() throws RemoteException { assumeTrue(cpp_java_tests != null); PersistableBundle[] input = new PersistableBundle[3]; PersistableBundle first = new PersistableBundle(); PersistableBundle second = new PersistableBundle(); PersistableBundle third = new PersistableBundle(); final String testIntKey = new String("testInt"); final String testLongKey = new String("testLong"); final String testDoubleKey = new String("testDouble"); first.putInt(testIntKey, 1231); second.putLong(testLongKey, 222222L); third.putDouble(testDoubleKey, 10.8); input[0] = first; input[1] = second; input[2] = third; final int original_input_size = input.length; PersistableBundle[] repeated = new PersistableBundle[input.length]; PersistableBundle[] reversed = cpp_java_tests.ReversePersistableBundles(input, repeated); assertThat(repeated.length, is(input.length)); assertThat(input.length, is(original_input_size)); assertThat(repeated[0].getInt(testIntKey), is(input[0].getInt(testIntKey))); assertThat(repeated[1].getLong(testLongKey), is(input[1].getLong(testLongKey))); assertThat(repeated[2].getDouble(testDoubleKey), is(input[2].getDouble(testDoubleKey))); assertThat(reversed.length, is(input.length)); assertThat(reversed[0].getInt(testIntKey), is(input[2].getInt(testIntKey))); assertThat(reversed[1].getLong(testLongKey), is(input[1].getLong(testLongKey))); assertThat(reversed[2].getDouble(testDoubleKey), is(input[0].getDouble(testDoubleKey))); } private void writeToFd(FileDescriptor fd, byte[] testData) throws IOException { FileOutputStream fdStream = new FileOutputStream(fd); fdStream.write(testData); fdStream.close(); } private void verifyFileContents(String file, byte[] testData) throws IOException { FileInputStream fis = new FileInputStream(file); byte[] readData = new byte[testData.length]; assertThat(fis.read(readData), is(readData.length)); assertThat(readData, is(testData)); assertThat(fis.read(), is(-1)); } @Test public void testFileDescriptorPassing() throws RemoteException, IOException { assumeTrue(cpp_java_tests != null); String file = "/data/local/tmp/aidl-test-file"; FileOutputStream fos = new FileOutputStream(file, false /*append*/); FileDescriptor descriptor = fos.getFD(); FileDescriptor journeyed = cpp_java_tests.RepeatFileDescriptor(descriptor); fos.close(); String testData = "FrazzleSnazzleFlimFlamFlibbityGumboChops"; writeToFd(journeyed, testData.getBytes()); verifyFileContents(file, testData.getBytes()); } @Test public void testFileDescriptorArrayPassing() throws RemoteException, IOException { assumeTrue(cpp_java_tests != null); final int kTestSize = 2; String fileBase = "/data/local/tmp/aidl-test-file_"; String[] files = new String[kTestSize]; // any size to test FileOutputStream[] fos = new FileOutputStream[kTestSize]; FileDescriptor[] descriptors = new FileDescriptor[kTestSize]; for (int i = 0; i < kTestSize; i++) { files[i] = fileBase + i; fos[i] = new FileOutputStream(files[i], false /*append*/); descriptors[i] = fos[i].getFD(); } FileDescriptor[] repeated = new FileDescriptor[kTestSize]; FileDescriptor[] reversed = cpp_java_tests.ReverseFileDescriptorArray(descriptors, repeated); for (int i = 0; i < kTestSize; i++) { fos[i].close(); } for (int i = 0; i < kTestSize; i++) { String testData = "Something " + i; writeToFd(reversed[kTestSize - 1 - i], testData.getBytes()); verifyFileContents(files[i], testData.getBytes()); writeToFd(repeated[i], testData.getBytes()); verifyFileContents(files[i], (testData + testData).getBytes()); } } @Test public void testParcelFileDescriptorPassing() throws RemoteException, IOException { String file = "/data/local/tmp/aidl-test-file"; ParcelFileDescriptor descriptor = ParcelFileDescriptor.open( new File(file), ParcelFileDescriptor.MODE_CREATE | ParcelFileDescriptor.MODE_WRITE_ONLY); ParcelFileDescriptor journeyed = service.RepeatParcelFileDescriptor(descriptor); FileOutputStream journeyedStream = new ParcelFileDescriptor.AutoCloseOutputStream(journeyed); String testData = "FrazzleSnazzleFlimFlamFlibbityGumboChops"; byte[] output = testData.getBytes(); journeyedStream.write(output); journeyedStream.close(); FileInputStream fis = new FileInputStream(file); byte[] input = new byte[output.length]; assertThat(fis.read(input), is(input.length)); assertThat(input, is(output)); } @Test public void testServiceSpecificExceptions() throws RemoteException { for (int i = -1; i < 2; ++i) { try { service.ThrowServiceException(i); } catch (ServiceSpecificException ex) { assertThat(ex.errorCode, is(i)); } } } private static final List utf8_queries = Arrays.asList( "typical string", "", "\0\0\0", // Java doesn't handle unicode code points above U+FFFF well. new String(Character.toChars(0x1F701)) + "\u03A9"); @Test public void testRepeatUtf8String() throws RemoteException { for (String query : utf8_queries) { String response = service.RepeatUtf8CppString(query); assertThat(response, is(query)); } } @Test public void testReverseUtf8StringArray() throws RemoteException { String[] input = utf8_queries.toArray(new String[0]); String echoed[] = new String[input.length]; String[] reversed = service.ReverseUtf8CppString(input, echoed); assertThat(echoed, is(input)); assertThat(reversed.length, is(input.length)); for (int i = 0; i < input.length; ++i) { int j = reversed.length - (1 + i); assertThat(reversed[j], is(input[i])); } } @Test public void testReverseNullableUtf8StringArray() throws RemoteException { final List utf8_queries_and_nulls = Arrays.asList( "typical string", null, "", "\0\0\0", null, // Java doesn't handle unicode code points above U+FFFF well. new String(Character.toChars(0x1F701)) + "\u03A9"); String[] input = utf8_queries_and_nulls.toArray(new String[0]); String echoed[] = new String[input.length]; String[] reversed = service.ReverseNullableUtf8CppString(input, echoed); assertThat(echoed, is(input)); assertThat(reversed.length, is(input.length)); for (int i = 0; i < input.length; ++i) { int j = reversed.length - (1 + i); if (input[i] == null && reversed[j] == null) { continue; } assertThat(reversed[j], is(input[i])); } } @Test public void testOutArrayWithNull() throws RemoteException { // In Java out-array parameter can't be null. The proxy code always throws NPE. assertThrows(NullPointerException.class, () -> service.ReverseUtf8CppString(null, null)); assertThrows(NullPointerException.class, () -> service.ReverseNullableUtf8CppString(null, null)); } private void shouldBeTheSame(StructuredParcelable a, StructuredParcelable b) { assertTrue(a.equals(b)); assertTrue(b.equals(a)); assertTrue(a.equals(a)); assertTrue(b.equals(b)); assertTrue(a.hashCode() == b.hashCode()); } private void shouldBeDifferent(StructuredParcelable a, StructuredParcelable b) { assertFalse(a.equals(b)); assertFalse(b.equals(a)); assertFalse(a.hashCode() == b.hashCode()); } @Test public void testStructuredParcelableEquality() { StructuredParcelable p = new StructuredParcelable(); p.shouldContainThreeFs = new int[] {1, 2, 3}; p.shouldBeJerry = "Jerry"; StructuredParcelable p2 = new StructuredParcelable(); p2.shouldContainThreeFs = new int[] {1, 2, 3}; p2.shouldBeJerry = "Jerry"; shouldBeTheSame(p, p2); StructuredParcelable p3 = new StructuredParcelable(); p3.shouldContainThreeFs = new int[] {1, 2, 3, 4}; p3.shouldBeJerry = "Jerry"; shouldBeDifferent(p, p3); StructuredParcelable p4 = new StructuredParcelable(); p4.shouldContainThreeFs = new int[] {1, 2, 3}; p4.shouldBeJerry = "Tom"; shouldBeDifferent(p, p4); } @Test public void testStructuredParcelable() throws RemoteException { final int kDesiredFValue = 17; StructuredParcelable p = new StructuredParcelable(); p.shouldContainThreeFs = new int[0]; p.f = kDesiredFValue; p.shouldBeJerry = ""; p.shouldContainTwoByteFoos = new byte[2]; p.shouldContainTwoIntFoos = new int[2]; p.shouldContainTwoLongFoos = new long[2]; p.empty = new StructuredParcelable.Empty(); // Check the default values assertThat(p.stringDefaultsToFoo, is("foo")); final byte byteFour = 4; assertThat(p.byteDefaultsToFour, is(byteFour)); assertThat(p.intDefaultsToFive, is(5)); assertThat(p.longDefaultsToNegativeSeven, is(-7L)); assertThat(p.booleanDefaultsToTrue, is(true)); assertThat(p.charDefaultsToC, is('C')); assertThat(p.floatDefaultsToPi, is(3.14f)); assertThat(p.doubleWithDefault, is(-3.14e17)); assertThat(p.arrayDefaultsTo123, is(new int[] {1, 2, 3})); assertThat(p.arrayDefaultsToEmpty.length, is(0)); assertThat(p.defaultWithFoo, is(IntEnum.FOO)); service.FillOutStructuredParcelable(p); // Check the returned values assertThat(p.shouldContainThreeFs, is(new int[] {kDesiredFValue, kDesiredFValue, kDesiredFValue})); assertThat(p.shouldBeJerry, is("Jerry")); assertThat(p.shouldBeByteBar, is(ByteEnum.BAR)); assertThat(p.shouldBeIntBar, is(IntEnum.BAR)); assertThat(p.shouldBeLongBar, is(LongEnum.BAR)); assertThat(p.shouldContainTwoByteFoos, is(new byte[] {ByteEnum.FOO, ByteEnum.FOO})); assertThat(p.shouldContainTwoIntFoos, is(new int[] {IntEnum.FOO, IntEnum.FOO})); assertThat(p.shouldContainTwoLongFoos, is(new long[] {LongEnum.FOO, LongEnum.FOO})); assertThat(p.int32_min, is(Integer.MIN_VALUE)); assertThat(p.int32_max, is(Integer.MAX_VALUE)); assertThat(p.int64_max, is(Long.MAX_VALUE)); assertThat(p.hexInt32_neg_1, is(-1)); for (int ndx = 0; ndx < p.int8_1.length; ndx++) { assertThat(p.int8_1[ndx], is((byte) 1)); } for (int ndx = 0; ndx < p.int32_1.length; ndx++) { assertThat(p.int32_1[ndx], is(1)); } for (int ndx = 0; ndx < p.int64_1.length; ndx++) { assertThat(p.int64_1[ndx], is(1L)); } assertThat(p.hexInt32_pos_1, is(1)); assertThat(p.hexInt64_pos_1, is(1)); assertThat(p.const_exprs_1, is(1)); assertThat(p.const_exprs_2, is(1)); assertThat(p.const_exprs_3, is(1)); assertThat(p.const_exprs_4, is(1)); assertThat(p.const_exprs_5, is(1)); assertThat(p.const_exprs_6, is(1)); assertThat(p.const_exprs_7, is(1)); assertThat(p.const_exprs_8, is(1)); assertThat(p.const_exprs_9, is(1)); assertThat(p.const_exprs_10, is(1)); assertThat( p.shouldSetBit0AndBit2, is(StructuredParcelable.BIT0 | StructuredParcelable.BIT2)); assertThat(p.u.getNs(), is(new int[] {1, 2, 3})); assertThat(p.shouldBeConstS1.getS(), is(Union.S1)); final String expected = "StructuredParcelable{" + "shouldContainThreeFs: [17, 17, 17], " + "f: 17, " + "shouldBeJerry: Jerry, " + "shouldBeByteBar: 2, " + "shouldBeIntBar: BAR, " + "shouldBeLongBar: 200000000000, " + "shouldContainTwoByteFoos: [1, 1], " + "shouldContainTwoIntFoos: [FOO, FOO], " + "shouldContainTwoLongFoos: [100000000000, 100000000000], " + "stringDefaultsToFoo: foo, " + "byteDefaultsToFour: 4, " + "intDefaultsToFive: 5, " + "longDefaultsToNegativeSeven: -7, " + "booleanDefaultsToTrue: true, " + "charDefaultsToC: C, " + "floatDefaultsToPi: 3.14, " + "doubleWithDefault: -3.14E17, " + "arrayDefaultsTo123: [1, 2, 3], " + "arrayDefaultsToEmpty: [], " + "boolDefault: false, " + "byteDefault: 0, " + "intDefault: 0, " + "longDefault: 0, " + "floatDefault: 0.0, " + "doubleDefault: 0.0, " + "checkDoubleFromFloat: 3.14, " + "checkStringArray1: [a, b], " + "checkStringArray2: [a, b], " + "int32_min: -2147483648, " + "int32_max: 2147483647, " + "int64_max: 9223372036854775807, " + "hexInt32_neg_1: -1, " + "ibinder: null, " + "empty: Empty{}, " + "int8_1: [1, 1, 1, 1, 1], " + "int32_1: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, " + "1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, " + "1, 1, 1, 1, 1, 1, 1, 1, 1, 1], " + "int64_1: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], " + "hexInt32_pos_1: 1, " + "hexInt64_pos_1: 1, " + "const_exprs_1: 1, " + "const_exprs_2: 1, " + "const_exprs_3: 1, " + "const_exprs_4: 1, " + "const_exprs_5: 1, " + "const_exprs_6: 1, " + "const_exprs_7: 1, " + "const_exprs_8: 1, " + "const_exprs_9: 1, " + "const_exprs_10: 1, " + "addString1: hello world!, " + "addString2: The quick brown fox jumps over the lazy dog., " + "shouldSetBit0AndBit2: 5, " + "u: Union.ns([1, 2, 3]), " + "shouldBeConstS1: Union.s(a string constant in union), " + "defaultWithFoo: FOO" + "}"; assertThat(p.toString(), is(expected)); } @Test public void testDefaultImpl() throws RemoteException { final int expectedArg = 100; final int expectedReturnValue = 200; boolean success = ITestService.Stub.setDefaultImpl(new ITestService.Default() { @Override public int UnimplementedMethod(int arg) throws RemoteException { if (arg != expectedArg) { throw new RemoteException("Argument for UnimplementedMethod is expected " + " to be " + expectedArg + ", but got " + arg); } return expectedReturnValue; } }); assertThat(success, is(true)); int ret = service.UnimplementedMethod(expectedArg); assertThat(ret, is(expectedReturnValue)); } @Test public void testToString() { ParcelableForToString p = new ParcelableForToString(); p.intValue = 10; p.intArray = new int[]{20, 30}; p.longValue = 100L; p.longArray = new long[]{200L, 300L}; p.doubleValue = 3.14d; p.doubleArray = new double[]{1.1d, 1.2d}; p.floatValue = 3.14f; p.floatArray = new float[]{1.1f, 1.2f}; p.byteValue = 3; p.byteArray = new byte[]{5, 6}; p.booleanValue = true; p.booleanArray = new boolean[]{true, false}; p.stringValue = "this is a string"; p.stringArray = new String[]{"hello", "world"}; p.stringList = Arrays.asList(new String[]{"alice", "bob"}); OtherParcelableForToString op = new OtherParcelableForToString(); op.field = "other"; p.parcelableValue = op; p.parcelableArray = new OtherParcelableForToString[]{op, op}; p.enumValue = IntEnum.FOO; p.enumArray = new int[]{IntEnum.FOO, IntEnum.BAR}; p.nullArray = null; p.nullList = null; GenericStructuredParcelable gen = new GenericStructuredParcelable(); gen.a = 1; gen.b = 2; p.parcelableGeneric = gen; p.unionValue = null; // for testing even though it is not @nullable in .aidl final String expected = "ParcelableForToString{" + "intValue: 10, " + "intArray: [20, 30], " + "longValue: 100, " + "longArray: [200, 300], " + "doubleValue: 3.14, " + "doubleArray: [1.1, 1.2], " + "floatValue: 3.14, " + "floatArray: [1.1, 1.2], " + "byteValue: 3, " + "byteArray: [5, 6], " + "booleanValue: true, " + "booleanArray: [true, false], " + "stringValue: this is a string, " + "stringArray: [hello, world], " + "stringList: [alice, bob], " + "parcelableValue: OtherParcelableForToString{field: other}, " + "parcelableArray: [" + "OtherParcelableForToString{field: other}, " + "OtherParcelableForToString{field: other}], " + "enumValue: FOO, " + "enumArray: [FOO, BAR], " + "nullArray: null, " + "nullList: null, " + "parcelableGeneric: GenericStructuredParcelable{a: 1, b: 2}, " + "unionValue: null" + "}"; assertThat(p.toString(), is(expected)); } @Test public void testEnumToString() { assertThat(IntEnum.$.toString(IntEnum.FOO), is("FOO")); assertThat(IntEnum.$.toString(0), is("0")); assertThat(IntEnum.$.arrayToString(null), is("null")); assertThat(IntEnum.$.arrayToString(new int[] {}), is("[]")); assertThat(IntEnum.$.arrayToString(new int[] {IntEnum.FOO, IntEnum.BAR}), is("[FOO, BAR]")); assertThat(IntEnum.$.arrayToString(new int[] {IntEnum.FOO, 0}), is("[FOO, 0]")); assertThat(IntEnum.$.arrayToString(new int[][] {{IntEnum.FOO, IntEnum.BAR}, {IntEnum.BAZ}}), is("[[FOO, BAR], [BAZ]]")); assertThrows(IllegalArgumentException.class, () -> IntEnum.$.arrayToString(IntEnum.FOO)); assertThrows( IllegalArgumentException.class, () -> IntEnum.$.arrayToString(new long[] {LongEnum.FOO})); } @Test public void testRenamedInterface() throws RemoteException { IOldName oldAsOld = service.GetOldNameInterface(); assertNotNull(oldAsOld); assertThat(oldAsOld.DESCRIPTOR, is("android.aidl.tests.IOldName")); assertThat(oldAsOld.RealName(), is("OldName")); INewName newAsNew = service.GetNewNameInterface(); assertNotNull(newAsNew); assertThat(newAsNew.DESCRIPTOR, is("android.aidl.tests.IOldName")); assertThat(oldAsOld.RealName(), is("OldName")); IOldName newAsOld = IOldName.Stub.asInterface(service.GetNewNameInterface().asBinder()); assertNotNull(newAsOld); assertThat(newAsOld.DESCRIPTOR, is("android.aidl.tests.IOldName")); assertThat(newAsOld.RealName(), is("NewName")); INewName oldAsNew = INewName.Stub.asInterface(service.GetOldNameInterface().asBinder()); assertNotNull(oldAsNew); assertThat(oldAsNew.DESCRIPTOR, is("android.aidl.tests.IOldName")); assertThat(oldAsNew.RealName(), is("OldName")); } @Test public void testReverseUnion() throws RemoteException { assumeTrue(cpp_java_tests != null); Union original = Union.ns(new int[] {1, 2, 3}); Union repeated = new Union(); Union reversed = cpp_java_tests.ReverseUnion(original, repeated); assertNotNull(reversed); assertThat(repeated.getNs(), is(new int[] {1, 2, 3})); assertThat(reversed.getNs(), is(new int[] {3, 2, 1})); } @Test public void testReverseRecursiveList() throws RemoteException { RecursiveList head = null; for (int i = 0; i < 10; i++) { RecursiveList node = new RecursiveList(); node.value = i; node.next = head; head = node; } // head: [9, 8, .. , 0] RecursiveList reversed = service.ReverseList(head); // reversed should be [0, 1, .. 9] for (int i = 0; i < 10; i++) { assertThat(reversed.value, is(i)); reversed = reversed.next; } assertNull(reversed); } @Test public void testGetUnionTags() throws RemoteException { assertArrayEquals(new int[] {}, service.GetUnionTags(new Union[] {})); assertArrayEquals(new int[] {Union.n, Union.ns}, service.GetUnionTags(new Union[] {Union.n(0), Union.ns(new int[] {})})); } @Test public void testDescribeContents() throws Exception { CompilerChecks cc = new CompilerChecks(); cc.pfd_array = new ParcelFileDescriptor[] {null, null, null}; assertThat(cc.describeContents(), is(0)); String file = "/data/local/tmp/aidl-test-file"; cc.pfd_array[1] = ParcelFileDescriptor.open( new File(file), ParcelFileDescriptor.MODE_CREATE | ParcelFileDescriptor.MODE_WRITE_ONLY); assertThat(cc.describeContents(), is(Parcelable.CONTENTS_FILE_DESCRIPTOR)); } @Test public void testFixedSizeArrayOverBinder() throws Exception { IBinder binder = ServiceManager.waitForService(IRepeatFixedSizeArray.DESCRIPTOR); assertNotNull(binder); IRepeatFixedSizeArray service = IRepeatFixedSizeArray.Stub.asInterface(binder); assertNotNull(service); { byte[] input = new byte[] {1, 2, 3}; byte[] repeated = new byte[3]; byte[] output = service.RepeatBytes(input, repeated); assertArrayEquals(input, repeated); assertArrayEquals(input, output); } { int[] input = new int[] {1, 2, 3}; int[] repeated = new int[3]; int[] output = service.RepeatInts(input, repeated); assertArrayEquals(input, repeated); assertArrayEquals(input, output); } { IntParcelable p1 = new IntParcelable(); p1.value = 1; IntParcelable p2 = new IntParcelable(); p2.value = 1; IntParcelable p3 = new IntParcelable(); p3.value = 1; IntParcelable[][] input = new IntParcelable[][] {{p1, p2, p3}, {p1, p2, p3}}; IntParcelable[][] repeated = new IntParcelable[2][3]; IntParcelable[][] output = service.Repeat2dParcelables(input, repeated); assertArrayEquals(input, repeated); assertArrayEquals(input, output); } } } ./PaxHeaders.X/tests_java_src_android_aidl_tests_TestVersionedInterface.java0100644 0000000 0000000 00000000034 15172120304 026563 xustar000000000 0000000 28 mtime=1776853188.7720000 tests/java/src/android/aidl/tests/TestVersionedInterface.java0100644 0000000 0000000 00000007534 15172120304 023440 0ustar000000000 0000000 /* * 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. */ package android.aidl.tests; import static org.hamcrest.core.Is.is; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertThat; import static org.junit.Assert.assertTrue; import android.aidl.versioned.tests.BazUnion; import android.aidl.versioned.tests.Foo; import android.aidl.versioned.tests.IFooInterface; import android.os.IBinder; import android.os.RemoteException; import android.os.ServiceManager; import org.junit.Before; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; @RunWith(JUnit4.class) public class TestVersionedInterface { private IFooInterface service; @Before public void setUp() { IBinder binder = ServiceManager.waitForService(IFooInterface.class.getName()); assertNotNull(binder); service = IFooInterface.Stub.asInterface(binder); assertNotNull(service); } @Test public void testGetInterfaceVersion() throws RemoteException { assertThat(service.getInterfaceVersion(), is(1)); } @Test public void testGetInterfaceHash() throws RemoteException { assertThat(service.getInterfaceHash(), is("9e7be1859820c59d9d55dd133e71a3687b5d2e5b")); } @Rule public ExpectedException expectedException = ExpectedException.none(); @Test public void testUnimplementedMethodTriggersException() throws RemoteException { expectedException.expect(RemoteException.class); expectedException.expectMessage("Method newApi is unimplemented."); service.newApi(); } @Test public void testOldServerAcceptsUnionWithOldField() throws RemoteException { assertThat(service.acceptUnionAndReturnString(BazUnion.intNum(42)), is("42")); } @Test public void testUnknownUnionFieldTriggersException() throws RemoteException { expectedException.expect(IllegalArgumentException.class); service.acceptUnionAndReturnString(BazUnion.longNum(42L)); } @Test public void testArrayOfPacelableWithNewField() throws RemoteException { Foo[] foos = new Foo[42]; for (int i = 0; i < foos.length; i++) { foos[i] = new Foo(); } int length = service.returnsLengthOfFooArray(foos); assertThat(length, is(foos.length)); } @Test public void testReadDataCorrectlyAfterParcelableWithNewField() throws RemoteException { Foo inFoo = new Foo(); Foo inoutFoo = new Foo(); inoutFoo.intDefault42 = 0; Foo outFoo = new Foo(); outFoo.intDefault42 = 0; int ret = service.ignoreParcelablesAndRepeatInt(inFoo, inoutFoo, outFoo, 43); assertThat(ret, is(43)); assertThat(inoutFoo.intDefault42, is(0)); assertThat(outFoo.intDefault42, is(0)); } @Test public void testDelegatorGetInterfaceVersion() throws RemoteException { IFooInterface.Delegator delegator = new IFooInterface.Delegator(service); assertThat(delegator.getInterfaceVersion(), is(1)); } @Test public void testDelegatorGetInterfaceHash() throws RemoteException { IFooInterface.Delegator delegator = new IFooInterface.Delegator(service); assertThat(delegator.getInterfaceHash(), is("9e7be1859820c59d9d55dd133e71a3687b5d2e5b")); } } ./PaxHeaders.X/tests_java_src_android_aidl_tests_TrunkStableTests.java0100644 0000000 0000000 00000000034 15172120304 025425 xustar000000000 0000000 28 mtime=1776853188.7720000 tests/java/src/android/aidl/tests/TrunkStableTests.java0100644 0000000 0000000 00000013266 15172120304 022301 0ustar000000000 0000000 /* * Copyright (C) 2023, 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. */ package android.aidl.tests; import static org.hamcrest.core.Is.is; import static org.hamcrest.core.IsNot.not; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertThat; import static org.junit.Assert.assertTrue; import android.aidl.test.trunk.ITrunkStableTest; import android.aidl.test.trunk.ITrunkStableTest.IMyCallback; import android.aidl.test.trunk.ITrunkStableTest.MyEnum; import android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable; import android.aidl.test.trunk.ITrunkStableTest.MyParcelable; import android.aidl.test.trunk.ITrunkStableTest.MyUnion; import android.os.IBinder; import android.os.RemoteException; import android.os.ServiceManager; import org.junit.Before; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; @RunWith(JUnit4.class) public class TrunkStableTests { private ITrunkStableTest service; // Java doesn't know about the build-time flag, so this test is based on the // reported version of the service. The cpp/ndk client tests will make sure // the reported version is due to the build-time flag. private int mRemoteVersion; @Rule public ExpectedException expectedException = ExpectedException.none(); @Before public void setUp() throws RemoteException { IBinder binder = ServiceManager.waitForService(ITrunkStableTest.class.getName()); assertNotNull(binder); service = ITrunkStableTest.Stub.asInterface(binder); assertNotNull(service); mRemoteVersion = service.getInterfaceVersion(); } @Test public void testGetInterfaceVersion() throws RemoteException { if (mRemoteVersion == 1) { assertThat(service.getInterfaceVersion(), is(1)); assertThat(ITrunkStableTest.VERSION, is(1)); } else { assertThat(service.getInterfaceVersion(), is(2)); assertThat(ITrunkStableTest.VERSION, is(2)); } } @Test public void testGetInterfaceHash() throws RemoteException { if (mRemoteVersion == 1) { assertThat(service.getInterfaceHash(), is("88311b9118fb6fe9eff4a2ca19121de0587f6d5f")); assertThat(ITrunkStableTest.HASH, is("88311b9118fb6fe9eff4a2ca19121de0587f6d5f")); } else { assertThat(service.getInterfaceHash(), is("notfrozen")); assertThat(ITrunkStableTest.HASH, is("notfrozen")); } } @Test public void testRepeatParcelable() throws RemoteException { MyParcelable p1 = new MyParcelable(); p1.a = 12; p1.b = 13; p1.c = 14; MyParcelable p2; p2 = service.repeatParcelable(p1); assertThat(p2.a, is(p1.a)); assertThat(p2.b, is(p1.b)); if (mRemoteVersion == 1) { assertTrue(p2.c != p1.c); } else { assertTrue(p2.c == p1.c); } } @Test public void testRepeatEnum() throws RemoteException { byte e1 = MyEnum.THREE; byte e2 = 0; e2 = service.repeatEnum(e1); assertThat(e2, is(e1)); } @Test public void testRepeatUnion() throws RemoteException { MyUnion u1, u2; u1 = MyUnion.c(13); if (mRemoteVersion == 1) { // 'c' is a new field only in V2 and will throw the exception expectedException.expect(IllegalArgumentException.class); } u2 = service.repeatUnion(u1); if (mRemoteVersion != 1) { assertThat(u2.getC(), is(u1.getC())); } } @Test public void testRepeatOtherParcelable() throws RemoteException { MyOtherParcelable p1 = new MyOtherParcelable(); p1.a = 12; p1.b = 13; MyOtherParcelable p2; if (mRemoteVersion == 1) { expectedException.expect(RemoteException.class); } p2 = service.repeatOtherParcelable(p1); } public static class MyCallback extends IMyCallback.Stub { @Override public MyParcelable repeatParcelable(MyParcelable input) throws android.os.RemoteException { repeatParcelableCalled = true; return input; } @Override public byte repeatEnum(byte input) throws android.os.RemoteException { repeatEnumCalled = true; return input; } @Override public ITrunkStableTest.MyUnion repeatUnion(MyUnion input) throws android.os.RemoteException { repeatUnionCalled = true; return input; } @Override public MyOtherParcelable repeatOtherParcelable(MyOtherParcelable input) throws android.os.RemoteException { repeatOtherParcelableCalled = true; return input; } @Override public final int getInterfaceVersion() { return super.VERSION; } @Override public final String getInterfaceHash() { return super.HASH; } boolean repeatParcelableCalled = false; boolean repeatEnumCalled = false; boolean repeatUnionCalled = false; boolean repeatOtherParcelableCalled = false; } @Test public void testCallMyCallback() throws RemoteException { MyCallback cb = new MyCallback(); service.callMyCallback(cb); assertTrue(cb.repeatParcelableCalled); assertTrue(cb.repeatEnumCalled); assertTrue(cb.repeatUnionCalled); if (mRemoteVersion == 1) { assertTrue(!cb.repeatOtherParcelableCalled); } else { assertTrue(cb.repeatOtherParcelableCalled); } } } ./PaxHeaders.X/tests_java_src_android_aidl_tests_UnionTests.java0100644 0000000 0000000 00000000034 15172120304 024257 xustar000000000 0000000 28 mtime=1776853188.7730000 tests/java/src/android/aidl/tests/UnionTests.java0100644 0000000 0000000 00000007550 15172120304 021132 0ustar000000000 0000000 /* * 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. */ package android.aidl.tests; import static org.hamcrest.core.Is.is; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertThat; import static org.junit.Assert.assertTrue; import android.aidl.tests.Union; import android.aidl.tests.UnionWithFd; import android.aidl.tests.unions.EnumUnion; import android.os.Parcel; import android.os.ParcelFileDescriptor; import android.os.Parcelable; import java.io.File; import java.io.FileDescriptor; import java.io.FileNotFoundException; import java.util.Arrays; import java.util.List; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; @RunWith(JUnit4.class) public class UnionTests { @Test public void defaultConstructorInitsWithFirstField() { assertThat(new Union(), is(Union.ns(new int[] {}))); // int[] ns = {} assertThat( new EnumUnion(), is(EnumUnion.intEnum(IntEnum.FOO))); // IntEnum intEnum = IntEnum.FOO } @Test public void updatesUnionWithSetter() { Union u = new Union(); u.setNs(new int[] {1, 2, 3}); assertThat(u.getTag(), is(Union.ns)); assertThat(u.getNs(), is(new int[] {1, 2, 3})); } @Test(expected = IllegalStateException.class) public void gettingWrongFieldThrowsException() { Union u = new Union(); u.getSs(); } @Test public void readWriteViaParcel() { List ss = Arrays.asList("hello", "world"); Union u = Union.ss(ss); Parcel parcel = Parcel.obtain(); u.writeToParcel(parcel, 0); parcel.setDataPosition(0); Union v = Union.CREATOR.createFromParcel(parcel); assertThat(v.getTag(), is(Union.ss)); assertThat(v.getSs(), is(ss)); parcel.recycle(); } @Test public void unionDescribeContents() { UnionWithFd u = UnionWithFd.num(0); assertTrue((u.describeContents() & Parcelable.CONTENTS_FILE_DESCRIPTOR) == 0); final Parcel parcel = Parcel.obtain(); try { u.setPfd(ParcelFileDescriptor.open(new File("/system"), ParcelFileDescriptor.MODE_READ_ONLY)); } catch (FileNotFoundException e) { throw new RuntimeException("can't open /system", e); } assertTrue((u.describeContents() & Parcelable.CONTENTS_FILE_DESCRIPTOR) != 0); u.writeToParcel(parcel, 0); UnionWithFd v = UnionWithFd.num(0); parcel.setDataPosition(0); v.readFromParcel(parcel); assertTrue((v.describeContents() & Parcelable.CONTENTS_FILE_DESCRIPTOR) != 0); parcel.recycle(); } private void shouldBeTheSame(Union a, Union b) { assertTrue(a.equals(b)); assertTrue(b.equals(a)); assertTrue(a.equals(a)); assertTrue(b.equals(b)); assertTrue(a.hashCode() == b.hashCode()); } private void shouldBeDifferent(Union a, Union b) { assertFalse(a.equals(b)); assertFalse(b.equals(a)); assertFalse(a.hashCode() == b.hashCode()); } @Test public void equalsAndHashCode() { // same tag, same value shouldBeTheSame(Union.s("hello"), Union.s("hello")); // different tag, same value shouldBeDifferent(Union.m(10), Union.n(10)); // same tag, different value shouldBeDifferent(Union.s("hello"), Union.s("world")); // with array shouldBeTheSame(Union.ns(new int[]{1, 2, 3}),Union.ns(new int[]{1, 2, 3})); shouldBeDifferent(Union.ns(new int[]{1, 2, 3}), Union.ns(new int[]{1, 2, 4})); } } ./PaxHeaders.X/tests_java_src_android_aidl_tests_VintfTests.java0100644 0000000 0000000 00000000034 15172120304 024255 xustar000000000 0000000 28 mtime=1776853188.7730000 tests/java/src/android/aidl/tests/VintfTests.java0100644 0000000 0000000 00000004046 15172120304 021125 0ustar000000000 0000000 /* * Copyright (C) 2021, 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. */ package android.aidl.tests; import static org.hamcrest.core.Is.is; import static org.hamcrest.core.IsNull.notNullValue; import static org.hamcrest.core.IsNull.nullValue; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertThat; import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; import static org.junit.Assume.assumeTrue; import android.os.Binder; import android.os.IBinder; import android.os.RemoteException; import android.os.ServiceManager; import java.util.ArrayList; import java.util.List; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; @RunWith(JUnit4.class) public class VintfTests { private static final String kInstance = "android.does.not.exist.IFoo/default"; @Test public void cantAddVintfService() throws RemoteException { Binder binder = new Binder(); binder.markVintfStability(); // <- do not do this, for test only boolean hasException = false; try { ServiceManager.addService(kInstance, binder); } catch (IllegalArgumentException e) { hasException = true; } assertTrue(hasException); } @Test public void canDowngradeVintfService() throws RemoteException { Binder binder = new Binder(); binder.markVintfStability(); // <- do not do this, for test only binder.forceDowngradeToSystemStability(); ServiceManager.addService(kInstance, binder); } } ./PaxHeaders.X/tests_java_src_android_aidl_tests_generic_0100644 0000000 0000000 00000000034 15172120304 022777 xustar000000000 0000000 28 mtime=1776853188.7730000 tests/java/src/android/aidl/tests/generic/0040755 0000000 0000000 00000000000 15172120304 017564 5ustar000000000 0000000 ./PaxHeaders.X/tests_java_src_android_aidl_tests_generic_Pair.java0100644 0000000 0000000 00000000034 15172120304 024533 xustar000000000 0000000 28 mtime=1776853188.7730000 tests/java/src/android/aidl/tests/generic/Pair.java0100644 0000000 0000000 00000002612 15172120304 021320 0ustar000000000 0000000 /* * Copyright (C) 2019, 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. */ package android.aidl.tests.generic; import android.os.Parcel; import android.os.Parcelable; public class Pair implements Parcelable { public A mFirst; public B mSecond; public Pair() {} public Pair(Parcel source) { readFromParcel(source); } public int describeContents() { return 0; } public void writeToParcel(Parcel dest, int flags) { dest.writeValue(mFirst); dest.writeValue(mSecond); } public void readFromParcel(Parcel source) { mFirst = (A) source.readValue(null); mSecond = (B) source.readValue(null); } public static final Parcelable.Creator CREATOR = new Parcelable.Creator() { public Pair createFromParcel(Parcel source) { return new Pair(source); } public Pair[] newArray(int size) { return new Pair[size]; } }; } ./PaxHeaders.X/tests_lazy_test_0100644 0000000 0000000 00000000034 15172120304 015616 xustar000000000 0000000 28 mtime=1776853188.7730000 tests/lazy_test/0040755 0000000 0000000 00000000000 15172120304 012763 5ustar000000000 0000000 ./PaxHeaders.X/tests_lazy_test_Android.bp0100644 0000000 0000000 00000000034 15172120304 017517 xustar000000000 0000000 28 mtime=1776853188.7730000 tests/lazy_test/Android.bp0100644 0000000 0000000 00000003261 15172120304 014665 0ustar000000000 0000000 package { // See: http://go/android-license-faq // A large-scale-change added 'default_applicable_licenses' to import // all of the 'license_kinds' from "system_tools_aidl_license" // to get the below license kinds: // SPDX-license-identifier-Apache-2.0 default_applicable_licenses: ["system_tools_aidl_license"], } cc_test { name: "aidl_lazy_test", srcs: ["main.cpp"], test_suites: ["general-tests"], require_root: true, shared_libs: [ "libbase", "liblog", "libutils", "libbinder", ], static_libs: [ "lazy_test_service_aidl-cpp", "lazy_cb_test_service_aidl-cpp", ], } cc_binary { name: "aidl_lazy_test_server", srcs: [ "server.cpp", "LazyTestService.cpp", ], init_rc: ["aidl_lazy_test_server.rc"], system_ext_specific: true, shared_libs: [ "libbase", "libbinder", "liblog", "libutils", ], static_libs: [ "lazy_test_service_aidl-cpp", ], } aidl_interface { name: "lazy_test_service_aidl", unstable: true, flags: ["-Werror"], srcs: [ "ILazyTestService.aidl", ], } cc_binary { name: "aidl_lazy_cb_test_server", srcs: [ "ServerCb.cpp", "LazyTestServiceCb.cpp", ], init_rc: ["aidl_lazy_cb_test_server.rc"], system_ext_specific: true, shared_libs: [ "libbinder", "liblog", "libutils", ], static_libs: [ "lazy_cb_test_service_aidl-cpp", ], } aidl_interface { name: "lazy_cb_test_service_aidl", unstable: true, flags: ["-Werror"], srcs: [ "ILazyTestServiceCb.aidl", ], } ./PaxHeaders.X/tests_lazy_test_ILazyTestService.aidl0100644 0000000 0000000 00000000034 15172120304 021660 xustar000000000 0000000 28 mtime=1776853188.7730000 tests/lazy_test/ILazyTestService.aidl0100644 0000000 0000000 00000001264 15172120304 017027 0ustar000000000 0000000 /* * 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. */ interface ILazyTestService { void forcePersist(boolean persist); } ./PaxHeaders.X/tests_lazy_test_ILazyTestServiceCb.aidl0100644 0000000 0000000 00000000034 15172120304 022125 xustar000000000 0000000 28 mtime=1776853188.7730000 tests/lazy_test/ILazyTestServiceCb.aidl0100644 0000000 0000000 00000001535 15172120304 017275 0ustar000000000 0000000 /* * Copyright (C) 2021 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. */ interface ILazyTestServiceCb { /** * Set the eventfd used to notify that the active services * callback is being executed and is about to terminate the process. */ void setEventFd(in ParcelFileDescriptor parcelFd); } ./PaxHeaders.X/tests_lazy_test_LazyTestService.cpp0100644 0000000 0000000 00000000034 15172120304 021420 xustar000000000 0000000 28 mtime=1776853188.7730000 tests/lazy_test/LazyTestService.cpp0100644 0000000 0000000 00000001676 15172120304 016576 0ustar000000000 0000000 /* * 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 "LazyTestService.h" #include namespace android { namespace binder { Status LazyTestService::forcePersist(bool persist) { auto lazyRegistrar = LazyServiceRegistrar::getInstance(); lazyRegistrar.forcePersist(persist); return Status::ok(); } } // namespace binder } // namespace android ./PaxHeaders.X/tests_lazy_test_LazyTestService.h0100644 0000000 0000000 00000000034 15172120304 021065 xustar000000000 0000000 28 mtime=1776853188.7730000 tests/lazy_test/LazyTestService.h0100644 0000000 0000000 00000001675 15172120304 016242 0ustar000000000 0000000 /* * 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. */ #pragma once #include #include namespace android { namespace binder { class LazyTestService : public BnLazyTestService { public: LazyTestService() {} virtual ~LazyTestService() {} ::android::binder::Status forcePersist(bool persist); }; } // namespace binder } // namespace android ./PaxHeaders.X/tests_lazy_test_LazyTestServiceCb.cpp0100644 0000000 0000000 00000000034 15172120304 021665 xustar000000000 0000000 28 mtime=1776853188.7730000 tests/lazy_test/LazyTestServiceCb.cpp0100644 0000000 0000000 00000003657 15172120304 017044 0ustar000000000 0000000 /* * Copyright (C) 2021 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 #include #include "LazyTestServiceCb.h" namespace android { namespace binder { void LazyTestServiceCb::setCustomActiveServicesCallback() { auto lazyRegistrar = LazyServiceRegistrar::getInstance(); lazyRegistrar.setActiveServicesCallback([lazyRegistrar, this](bool hasClients) mutable -> bool { if (hasClients) { return false; } if (mFd < 0) { // Prevent shutdown (test will fail) return true; } // Unregister all services if (!lazyRegistrar.tryUnregister()) { // Prevent shutdown (test will fail) return true; } // Re-register all services lazyRegistrar.reRegister(); // Unregister again before shutdown if (!lazyRegistrar.tryUnregister()) { // Prevent shutdown (test will fail) return true; } // Tell the test we're shutting down if (TEMP_FAILURE_RETRY(eventfd_write(mFd, /* value */ 1)) < 0) { // Prevent shutdown (test will fail) return true; } exit(EXIT_SUCCESS); // Unreachable }); } Status LazyTestServiceCb::setEventFd(const ::android::os::ParcelFileDescriptor& parcelFd) { mFd = dup(parcelFd.get()); return mFd < 0 ? Status::fromExceptionCode(Status::EX_ILLEGAL_ARGUMENT) : Status::ok(); } } // namespace binder } // namespace android ./PaxHeaders.X/tests_lazy_test_LazyTestServiceCb.h0100644 0000000 0000000 00000000034 15172120304 021332 xustar000000000 0000000 28 mtime=1776853188.7740000 tests/lazy_test/LazyTestServiceCb.h0100644 0000000 0000000 00000002066 15172120304 016502 0ustar000000000 0000000 /* * Copyright (C) 2021 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. */ #pragma once #include #include namespace android { namespace binder { class LazyTestServiceCb : public BnLazyTestServiceCb { public: LazyTestServiceCb() : mFd(-1) {} virtual ~LazyTestServiceCb() {} ::android::binder::Status setEventFd(const ::android::os::ParcelFileDescriptor& parcelFd); void setCustomActiveServicesCallback(); private: int mFd; }; } // namespace binder } // namespace android ./PaxHeaders.X/tests_lazy_test_README0100644 0000000 0000000 00000000034 15172120304 016474 xustar000000000 0000000 28 mtime=1776853188.7740000 tests/lazy_test/README0100644 0000000 0000000 00000010455 15172120304 013645 0ustar000000000 0000000 ================================================================================================== aidl_lazy_test ================================================================================================== This test can be run in one of two ways: -------------------------------------------- Without arguments: aidl_lazy_test -------------------------------------------- This will run tests on the test service (described below), the goal being to test the dynamic service infrastructure. -------------------------------------------- With a service: aidl_lazy_test serviceName... -------------------------------------------- This will run tests on the input service, verifying whether it successfully displays lazy behavior. If the service has multiple interfaces, each can be entered as a separate argument to be tested simultaneously. Infrastructure tests that rely on specific features of the dedicated test service will be skipped. ================================================================================================== aidl_lazy_test_server ================================================================================================== aidl_lazy_test_server is a simple test service. Because it represents the bare minimum requirements for implementing a service, it also serves as an example of how to add a new service. The required files are as follows: ============================================ In this directory ============================================ -------------------------------------------- server.cpp -------------------------------------------- The implementation of the server. The only required function is main(), wherein the service must be instantiated and added (either to servicemanager as a standard service or to LazyServiceRegistrar to be a dynamic service). The server then joins the thread pool. -------------------------------------------- aidl_lazy_test_server.rc -------------------------------------------- This file is read by init, which later starts the service. The interface, oneshot, and disabled lines are only required for dynamic services. -------------------------------------------- LazyTestService.h/.cpp -------------------------------------------- The implementation of the service's functionality. -------------------------------------------- ILazyTestService.aidl -------------------------------------------- The AIDL interface for the service, this will generate code that clients can use to interact with the service via IPC. -------------------------------------------- Android.bp -------------------------------------------- An aidl_interface entry will need to be added for the .aidl file. A cc_binary entry will need to be added for the service with: name srcs - The source file(s) init_rc - The .rc file shared_libs - Any shared libraries the source file depends on static_libs - The AIDL interface ============================================ In system/sepolicy ============================================ -------------------------------------------- private/aidl_lazy_test_server.te -------------------------------------------- Only two lines are required in this file. -------------------------------------------- public/aidl_lazy_test_server.te -------------------------------------------- The first two lines establish types for aidl_lazy_test_server and aidl_lazy_test_server_exec. binder_use and binder_call allow for basic use of this service. add_service allows the service to be registered. Note that an additional service type is required as the second argument to this function. -------------------------------------------- private/compat//.ignore.cil -------------------------------------------- aidl_lazy_test_server and aidl_lazy_test_server_exec, and aidl_lazy_test_service need to be added to the new objects list. -------------------------------------------- private/file_contexts -------------------------------------------- A line is required to map aidl_lazy_test_server to aidl_lazy_test_server_exec. -------------------------------------------- private/service_contexts -------------------------------------------- Each interface for the service must be mapped to aidl_lazy_test_service here. -------------------------------------------- public/service.te -------------------------------------------- A line is required to define aidl_lazy_test_service. ./PaxHeaders.X/tests_lazy_test_ServerCb.cpp0100644 0000000 0000000 00000000034 15172120304 020033 xustar000000000 0000000 28 mtime=1776853188.7740000 tests/lazy_test/ServerCb.cpp0100644 0000000 0000000 00000002712 15172120304 015201 0ustar000000000 0000000 /* * Copyright (C) 2021 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 #include #include #include #include #include "LazyTestServiceCb.h" using android::BBinder; using android::IBinder; using android::IPCThreadState; using android::OK; using android::sp; using android::binder::LazyServiceRegistrar; using android::binder::LazyTestServiceCb; // TODO: shouldn't be expanded or copied - instead, merge with server.cpp int main() { sp service = new LazyTestServiceCb(); // Set the callback before registering the service service->setCustomActiveServicesCallback(); auto lazyRegistrar = LazyServiceRegistrar::getInstance(); LOG_ALWAYS_FATAL_IF(OK != lazyRegistrar.registerService(service, "aidl_lazy_cb_test"), ""); IPCThreadState::self()->joinThreadPool(); return 1; } ./PaxHeaders.X/tests_lazy_test_aidl_lazy_cb_test_server.rc0100644 0000000 0000000 00000000034 15172120304 023203 xustar000000000 0000000 28 mtime=1776853188.7740000 tests/lazy_test/aidl_lazy_cb_test_server.rc0100644 0000000 0000000 00000000242 15172120304 020345 0ustar000000000 0000000 service aidl_lazy_cb_test /system_ext/bin/aidl_lazy_cb_test_server interface aidl aidl_lazy_cb_test user system group system oneshot disabled ./PaxHeaders.X/tests_lazy_test_aidl_lazy_test_server.rc0100644 0000000 0000000 00000000034 15172120304 022537 xustar000000000 0000000 28 mtime=1776853188.7740000 tests/lazy_test/aidl_lazy_test_server.rc0100644 0000000 0000000 00000000550 15172120304 017703 0ustar000000000 0000000 service aidl_lazy_test /system_ext/bin/aidl_lazy_test_server interface aidl aidl_lazy_test_1 interface aidl aidl_lazy_test_2 user system group system oneshot disabled service aidl_lazy_test_quit /system_ext/bin/aidl_lazy_test_server quit interface aidl aidl_lazy_test_quit user system group system oneshot disabled ./PaxHeaders.X/tests_lazy_test_main.cpp0100644 0000000 0000000 00000000034 15172120304 017244 xustar000000000 0000000 28 mtime=1776853188.7770000 tests/lazy_test/main.cpp0100644 0000000 0000000 00000022622 15172120304 014414 0ustar000000000 0000000 /* * Copyright (C) 2019, 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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include using ::ILazyTestService; using ::android::DEAD_OBJECT; using ::android::IBinder; using ::android::IPCThreadState; using ::android::IServiceManager; using ::android::OK; using ::android::sp; using ::android::String16; using ::android::base::unique_fd; using ::android::os::ParcelFileDescriptor; std::vector gServiceNames; static constexpr size_t SHUTDOWN_WAIT_MS = 10000; static constexpr size_t CALLBACK_SHUTDOWN_WAIT_MS = 5000; sp waitForService(const String16& name) { sp manager; manager = android::defaultServiceManager(); EXPECT_NE(manager, nullptr); return manager->waitForService(name); } bool isServiceRunning(const String16& name) { sp manager; manager = android::defaultServiceManager(); EXPECT_NE(manager, nullptr); return manager->checkService(name) != nullptr; } TEST(AidlLazyQuitTest, Quits) { const String16 quitter = String16("aidl_lazy_test_quit"); usleep(SHUTDOWN_WAIT_MS * 1000); ASSERT_FALSE(isServiceRunning(quitter)); auto binder = waitForService(quitter); // binder dies. Could also linkToDeath to switch to cond var. for (size_t i = 0; i < 1000; i++) { if (binder->pingBinder() != OK) break; usleep(10000); } EXPECT_EQ(DEAD_OBJECT, binder->pingBinder()); // service should quit immediately, but wait a bit before checking // so that servicemanager has time to process the death notification usleep(SHUTDOWN_WAIT_MS * 1000 / 2); ASSERT_FALSE(isServiceRunning(quitter)); } class AidlLazyTest : public ::testing::Test { protected: sp manager; void SetUp() override { manager = android::defaultServiceManager(); ASSERT_NE(manager, nullptr); for (size_t i = 0; i < gServiceNames.size(); i++) { ASSERT_FALSE(isServiceRunning(gServiceNames.at(i))) << "Service '" << android::String8(gServiceNames.at(i)) << "' is already running. " << "Please ensure this is implemented as a lazy service, then kill all " << "clients of this service and try again."; } } void TearDown() override { std::cout << "Waiting " << SHUTDOWN_WAIT_MS << " milliseconds before checking that the " << "service has shut down." << std::endl; IPCThreadState::self()->flushCommands(); usleep(SHUTDOWN_WAIT_MS * 1000); for (size_t i = 0; i < gServiceNames.size(); i++) { ASSERT_FALSE(isServiceRunning(gServiceNames.at(i))) << "Service failed to shut down."; } } }; static constexpr size_t NUM_IMMEDIATE_GETS = 100; TEST_F(AidlLazyTest, GetRelease) { size_t nServices = gServiceNames.size(); for (size_t i = 0; i < nServices * NUM_IMMEDIATE_GETS; i++) { IPCThreadState::self()->flushCommands(); sp service = waitForService(gServiceNames.at(i % nServices)); ASSERT_NE(service.get(), nullptr); ASSERT_EQ(service->pingBinder(), android::NO_ERROR); } } static std::vector waitMs(size_t numTimes, size_t maxWait) { std::vector times(numTimes); for (size_t i = 0; i < numTimes; i++) { times.at(i) = (size_t)(rand() % (maxWait + 1)); } return times; } static void testWithTimes(const std::vector& waitMs, bool beforeGet) { size_t nServices = gServiceNames.size(); for (size_t i = 0; i < waitMs.size(); i++) { IPCThreadState::self()->flushCommands(); if (beforeGet) { std::cout << "Thread waiting " << waitMs.at(i) << " while not holding service." << std::endl; usleep(waitMs.at(i) * 1000); } sp service = waitForService(gServiceNames.at(i % nServices)); if (!beforeGet) { std::cout << "Thread waiting " << waitMs.at(i) << " while holding service." << std::endl; usleep(waitMs.at(i) * 1000); } ASSERT_NE(service.get(), nullptr); ASSERT_EQ(service->pingBinder(), android::NO_ERROR); } } static constexpr size_t NUM_TIMES_GET_RELEASE = 5; static constexpr size_t MAX_WAITING_DURATION_MS = 10000; static constexpr size_t NUM_CONCURRENT_THREADS = 3; static void testConcurrentThreadsWithDelays(bool delayBeforeGet) { size_t nServices = gServiceNames.size(); std::vector> threadWaitTimes(NUM_CONCURRENT_THREADS); int maxWait = 0; for (size_t i = 0; i < threadWaitTimes.size(); i++) { threadWaitTimes.at(i) = waitMs(NUM_TIMES_GET_RELEASE * nServices, MAX_WAITING_DURATION_MS); int totalWait = std::accumulate(threadWaitTimes.at(i).begin(), threadWaitTimes.at(i).end(), 0); maxWait = std::max(maxWait, totalWait); } std::cout << "Additional runtime expected from sleeps: " << maxWait << " millisecond(s)." << std::endl; std::vector threads(NUM_CONCURRENT_THREADS); for (size_t i = 0; i < threads.size(); i++) { threads.at(i) = std::thread(testWithTimes, threadWaitTimes.at(i), delayBeforeGet); } for (auto& thread : threads) { thread.join(); } } TEST_F(AidlLazyTest, GetConcurrentWithWaitBefore) { testConcurrentThreadsWithDelays(true); } TEST_F(AidlLazyTest, GetConcurrentWithWaitAfter) { testConcurrentThreadsWithDelays(false); } class AidlLazyRegistrarTest : public ::testing::Test { protected: const String16 serviceName = String16("aidl_lazy_test_1"); void SetUp() override { if (std::find(gServiceNames.begin(), gServiceNames.end(), serviceName) == gServiceNames.end()) { GTEST_SKIP() << "Persistence test requires special instance: " << serviceName; } } }; template sp waitForLazyTestService(String16 name) { sp service = android::waitForService(name); EXPECT_NE(service, nullptr); return service; } TEST_F(AidlLazyRegistrarTest, ForcedPersistenceTest) { sp service; for (int i = 0; i < 2; i++) { service = waitForLazyTestService(serviceName); EXPECT_TRUE(service->forcePersist(i == 0).isOk()); service = nullptr; std::cout << "Waiting " << SHUTDOWN_WAIT_MS << " milliseconds before checking whether the " << "service is still running." << std::endl; IPCThreadState::self()->flushCommands(); usleep(SHUTDOWN_WAIT_MS * 1000); if (i == 0) { ASSERT_TRUE(isServiceRunning(serviceName)) << "Service shut down when it shouldn't have."; } else { ASSERT_FALSE(isServiceRunning(serviceName)) << "Service failed to shut down."; } } } TEST_F(AidlLazyRegistrarTest, ActiveServicesCountCallbackTest) { const String16 cbServiceName = String16("aidl_lazy_cb_test"); int efd = eventfd(0, 0); ASSERT_GE(efd, 0) << "Failed to create eventfd"; unique_fd uniqueEventFd(efd); ParcelFileDescriptor parcelEventFd(std::move(uniqueEventFd)); sp service; service = waitForLazyTestService(cbServiceName); ASSERT_TRUE(service->setEventFd(parcelEventFd).isOk()); service = nullptr; IPCThreadState::self()->flushCommands(); std::cout << "Waiting " << SHUTDOWN_WAIT_MS << " milliseconds for callback completion " << "notification." << std::endl; int epollFd = epoll_create1(EPOLL_CLOEXEC); ASSERT_GE(epollFd, 0) << "Failed to create epoll"; unique_fd epollUniqueFd(epollFd); const int EPOLL_MAX_EVENTS = 1; struct epoll_event event, events[EPOLL_MAX_EVENTS]; event.events = EPOLLIN; event.data.fd = efd; int rc = epoll_ctl(epollFd, EPOLL_CTL_ADD, efd, &event); ASSERT_GE(rc, 0) << "Failed to add fd to epoll"; rc = TEMP_FAILURE_RETRY(epoll_wait(epollFd, events, EPOLL_MAX_EVENTS, SHUTDOWN_WAIT_MS)); ASSERT_NE(rc, 0) << "Service shutdown timeout"; ASSERT_GT(rc, 0) << "Error waiting for service shutdown notification"; eventfd_t counter; rc = TEMP_FAILURE_RETRY(eventfd_read(parcelEventFd.get(), &counter)); ASSERT_GE(rc, 0) << "Failed to get callback completion notification from service"; ASSERT_EQ(counter, 1); std::cout << "Waiting " << CALLBACK_SHUTDOWN_WAIT_MS << " milliseconds before checking whether the " << "service is still running." << std::endl; usleep(CALLBACK_SHUTDOWN_WAIT_MS * 1000); ASSERT_FALSE(isServiceRunning(serviceName)) << "Service failed to shut down."; } int main(int argc, char** argv) { ::testing::InitGoogleTest(&argc, argv); srand(time(nullptr)); if (argc < 2) { // If the user does not specify any service to test, default to these test interfaces gServiceNames.push_back(String16("aidl_lazy_test_1")); gServiceNames.push_back(String16("aidl_lazy_test_2")); } else { for (int i = 1; i < argc; i++) { gServiceNames.push_back(String16(argv[i])); } } android::ProcessState::self()->startThreadPool(); return RUN_ALL_TESTS(); } ./PaxHeaders.X/tests_lazy_test_server.cpp0100644 0000000 0000000 00000000034 15172120304 017626 xustar000000000 0000000 28 mtime=1776853188.7780000 tests/lazy_test/server.cpp0100644 0000000 0000000 00000005167 15172120304 015003 0ustar000000000 0000000 /* * 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 #include #include #include #include #include "LazyTestService.h" using android::BBinder; using android::IBinder; using android::IPCThreadState; using android::OK; using android::sp; using android::binder::LazyServiceRegistrar; using android::binder::LazyTestService; void setupDoubleLazyServer() { sp service1 = sp::make(); sp service2 = sp::make(); // Simulate another callback here, to test to make sure the actual instance // we are relying on doesn't have its state messed up when multiple client // callbacks are registered. // DO NOT COPY - INTENTIONALLY TESTING BAD BEHAVIOR auto extra = LazyServiceRegistrar::createExtraTestInstance(); extra.forcePersist(true); // don't allow this instance to handle process lifetime CHECK_EQ(OK, extra.registerService(service1, "aidl_lazy_test_1")); // DO NOT COPY - INTENTIONALLY TESTING BAD BEHAVIOR auto lazyRegistrar = LazyServiceRegistrar::getInstance(); CHECK_EQ(OK, lazyRegistrar.registerService(service1, "aidl_lazy_test_1")); CHECK_EQ(OK, lazyRegistrar.registerService(service2, "aidl_lazy_test_2")); } void setupQuitterServer() { auto lazyRegistrar = LazyServiceRegistrar::getInstance(); lazyRegistrar.setActiveServicesCallback([](bool hasClients) mutable -> bool { // intentional bad behavior, for instance, simulating a system // shutdown at this time if (hasClients) exit(EXIT_SUCCESS); return false; }); sp service = sp::make(); CHECK_EQ(OK, lazyRegistrar.registerService(service, "aidl_lazy_test_quit")); } int main(int argc, char** argv) { if (argc == 1) { setupDoubleLazyServer(); } else if (argc == 2 && argv[1] == std::string("quit")) { setupQuitterServer(); } else { LOG_ALWAYS_FATAL("usage: %s [quit]", argv[0]); } IPCThreadState::self()->joinThreadPool(); return 1; } ./PaxHeaders.X/tests_main.cpp0100644 0000000 0000000 00000000034 15172120304 015146 xustar000000000 0000000 28 mtime=1776853188.7780000 tests/main.cpp0100644 0000000 0000000 00000000202 15172120304 012364 0ustar000000000 0000000 #include int main(int argc, char **argv) { ::testing::InitGoogleTest(&argc, argv); return RUN_ALL_TESTS(); } ./PaxHeaders.X/tests_rust_0100644 0000000 0000000 00000000034 15172120304 014575 xustar000000000 0000000 28 mtime=1776853188.7780000 tests/rust/0040755 0000000 0000000 00000000000 15172120304 011742 5ustar000000000 0000000 ./PaxHeaders.X/tests_rust_simple_parcelable.rs0100644 0000000 0000000 00000000034 15172120304 020604 xustar000000000 0000000 28 mtime=1776853188.7780000 tests/rust/simple_parcelable.rs0100644 0000000 0000000 00000003162 15172120304 015752 0ustar000000000 0000000 /* * Copyright (C) 2023, 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. */ //! Rust implementation of `SimpleParcelable`. use binder::{ binder_impl::{BorrowedParcel, UnstructuredParcelable}, impl_deserialize_for_unstructured_parcelable, impl_serialize_for_unstructured_parcelable, StatusCode, }; /// Rust implementation of `SimpleParcelable`. #[derive(Clone, Debug, Default, Eq, PartialEq)] pub struct SimpleParcelable { /// The name of the parcelable. pub name: String, /// The number of the parcelable. pub number: i32, } impl UnstructuredParcelable for SimpleParcelable { fn write_to_parcel(&self, parcel: &mut BorrowedParcel) -> Result<(), StatusCode> { parcel.write(&self.name)?; parcel.write(&self.number)?; Ok(()) } fn from_parcel(parcel: &BorrowedParcel) -> Result { let name = parcel.read()?; let number = parcel.read()?; Ok(Self { name, number }) } } impl_deserialize_for_unstructured_parcelable!(SimpleParcelable); impl_serialize_for_unstructured_parcelable!(SimpleParcelable); ./PaxHeaders.X/tests_rust_test_client.rs0100644 0000000 0000000 00000000034 15172120304 017456 xustar000000000 0000000 28 mtime=1776853188.7780000 tests/rust/test_client.rs0100644 0000000 0000000 00000145553 15172120304 014637 0ustar000000000 0000000 /* * 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. */ //! Test Rust client for the AIDL compiler. use ::binder::{binder_impl::Parcel, Parcelable}; use aidl_test_fixedsizearray::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::{ FixedSizeArrayExample, IRepeatFixedSizeArray::{BpRepeatFixedSizeArray, IRepeatFixedSizeArray}, IntParcelable::IntParcelable, }; use aidl_test_interface::aidl::android::aidl::tests::nested::{ INestedService, ParcelableWithNested, }; use aidl_test_interface::aidl::android::aidl::tests::unions::EnumUnion::EnumUnion; use aidl_test_interface::aidl::android::aidl::tests::INewName::{self, BpNewName}; use aidl_test_interface::aidl::android::aidl::tests::IOldName::{self, BpOldName}; use aidl_test_interface::aidl::android::aidl::tests::ITestService::{ self, BpTestService, Empty::Empty, ITestServiceDefault, ITestServiceDefaultRef, }; use aidl_test_interface::aidl::android::aidl::tests::{ extension::ExtendableParcelable::ExtendableParcelable, extension::MyExt::MyExt, extension::MyExt2::MyExt2, extension::MyExtLike::MyExtLike, BackendType::BackendType, ByteEnum::ByteEnum, IntEnum::IntEnum, LongEnum::LongEnum, RecursiveList::RecursiveList, StructuredParcelable, Union, }; use aidl_test_interface::binder::{self, BinderFeatures, IBinder, Interface}; use aidl_test_nonvintf_parcelable::aidl::android::aidl::tests::nonvintf::{ NonVintfExtendableParcelable::NonVintfExtendableParcelable, NonVintfParcelable::NonVintfParcelable, }; use aidl_test_unstable_parcelable::aidl::android::aidl::tests::unstable::{ UnstableExtendableParcelable::UnstableExtendableParcelable, UnstableParcelable::UnstableParcelable, }; use aidl_test_versioned_interface::aidl::android::aidl::versioned::tests::{ BazUnion::BazUnion, Foo::Foo, IFooInterface, IFooInterface::BpFooInterface, }; use aidl_test_vintf_parcelable::aidl::android::aidl::tests::vintf::{ VintfExtendableParcelable::VintfExtendableParcelable, VintfParcelable::VintfParcelable, }; use android_aidl_test_trunk::aidl::android::aidl::test::trunk::{ ITrunkStableTest::BpTrunkStableTest, ITrunkStableTest::IMyCallback, ITrunkStableTest::ITrunkStableTest, ITrunkStableTest::MyEnum::MyEnum, ITrunkStableTest::MyOtherParcelable::MyOtherParcelable, ITrunkStableTest::MyParcelable::MyParcelable, ITrunkStableTest::MyUnion::MyUnion, }; use simple_parcelable::SimpleParcelable; use std::fs::File; use std::io::{Read, Write}; use std::os::fd::{FromRawFd, OwnedFd}; use std::sync::{Arc, Mutex}; fn get_test_service() -> binder::Strong { binder::get_interface(::get_descriptor()) .expect("did not get binder service") } fn get_test_trunk_stable_service() -> binder::Strong { binder::get_interface(::get_descriptor()) .expect("did not get binder service") } #[test] fn test_constants() { assert_eq!(ITestService::A1, 1); assert_eq!(ITestService::A2, 1); assert_eq!(ITestService::A3, 1); assert_eq!(ITestService::A4, 1); assert_eq!(ITestService::A5, 1); assert_eq!(ITestService::A6, 1); assert_eq!(ITestService::A7, 1); assert_eq!(ITestService::A8, 1); assert_eq!(ITestService::A9, 1); assert_eq!(ITestService::A10, 1); assert_eq!(ITestService::A11, 1); assert_eq!(ITestService::A12, 1); assert_eq!(ITestService::A13, 1); assert_eq!(ITestService::A14, 1); assert_eq!(ITestService::A15, 1); assert_eq!(ITestService::A16, 1); assert_eq!(ITestService::A17, 1); assert_eq!(ITestService::A18, 1); assert_eq!(ITestService::A19, 1); assert_eq!(ITestService::A20, 1); assert_eq!(ITestService::A21, 1); assert_eq!(ITestService::A22, 1); assert_eq!(ITestService::A23, 1); assert_eq!(ITestService::A24, 1); assert_eq!(ITestService::A25, 1); assert_eq!(ITestService::A26, 1); assert_eq!(ITestService::A27, 1); assert_eq!(ITestService::A28, 1); assert_eq!(ITestService::A29, 1); assert_eq!(ITestService::A30, 1); assert_eq!(ITestService::A31, 1); assert_eq!(ITestService::A32, 1); assert_eq!(ITestService::A33, 1); assert_eq!(ITestService::A34, 1); assert_eq!(ITestService::A35, 1); assert_eq!(ITestService::A36, 1); assert_eq!(ITestService::A37, 1); assert_eq!(ITestService::A38, 1); assert_eq!(ITestService::A39, 1); assert_eq!(ITestService::A40, 1); assert_eq!(ITestService::A41, 1); assert_eq!(ITestService::A42, 1); assert_eq!(ITestService::A43, 1); assert_eq!(ITestService::A44, 1); assert_eq!(ITestService::A45, 1); assert_eq!(ITestService::A46, 1); assert_eq!(ITestService::A47, 1); assert_eq!(ITestService::A48, 1); assert_eq!(ITestService::A49, 1); assert_eq!(ITestService::A50, 1); assert_eq!(ITestService::A51, 1); assert_eq!(ITestService::A52, 1); assert_eq!(ITestService::A53, 1); assert_eq!(ITestService::A54, 1); assert_eq!(ITestService::A55, 1); assert_eq!(ITestService::A56, 1); assert_eq!(ITestService::A57, 1); assert_eq!(ITestService::FLOAT_CONSTANT4, 2.2_f32); assert_eq!(ITestService::FLOAT_CONSTANT5, -2.2_f32); assert_eq!(ITestService::DOUBLE_CONSTANT4, 2.2_f64); assert_eq!(ITestService::DOUBLE_CONSTANT5, -2.2_f64); } #[test] fn test_oneway() { let result = get_test_service().TestOneway(); assert_eq!(result, Ok(())); } macro_rules! test_primitive { ($test:ident, $func:ident, $value:expr) => { #[test] fn $test() { let value = $value; let result = get_test_service().$func(value); assert_eq!(result, Ok(value)); } }; } test_primitive! {test_primitive_bool_false, RepeatBoolean, false} test_primitive! {test_primitive_bool_true, RepeatBoolean, true} test_primitive! {test_primitive_byte, RepeatByte, -128i8} test_primitive! {test_primitive_char, RepeatChar, 'A' as u16} test_primitive! {test_primitive_int, RepeatInt, 1i32 << 30} test_primitive! {test_primitive_long, RepeatLong, 1i64 << 60} test_primitive! {test_primitive_float, RepeatFloat, 1.0f32 / 3.0f32} test_primitive! {test_primitive_double, RepeatDouble, 1.0f64 / 3.0f64} test_primitive! {test_primitive_byte_constant, RepeatByte, ITestService::BYTE_CONSTANT} test_primitive! {test_primitive_constant1, RepeatInt, ITestService::CONSTANT} test_primitive! {test_primitive_constant2, RepeatInt, ITestService::CONSTANT2} test_primitive! {test_primitive_constant3, RepeatInt, ITestService::CONSTANT3} test_primitive! {test_primitive_constant4, RepeatInt, ITestService::CONSTANT4} test_primitive! {test_primitive_constant5, RepeatInt, ITestService::CONSTANT5} test_primitive! {test_primitive_constant6, RepeatInt, ITestService::CONSTANT6} test_primitive! {test_primitive_constant7, RepeatInt, ITestService::CONSTANT7} test_primitive! {test_primitive_constant8, RepeatInt, ITestService::CONSTANT8} test_primitive! {test_primitive_constant9, RepeatInt, ITestService::CONSTANT9} test_primitive! {test_primitive_constant10, RepeatInt, ITestService::CONSTANT10} test_primitive! {test_primitive_constant11, RepeatInt, ITestService::CONSTANT11} test_primitive! {test_primitive_constant12, RepeatInt, ITestService::CONSTANT12} test_primitive! {test_primitive_long_constant, RepeatLong, ITestService::LONG_CONSTANT} test_primitive! {test_primitive_byte_enum, RepeatByteEnum, ByteEnum::FOO} test_primitive! {test_primitive_int_enum, RepeatIntEnum, IntEnum::BAR} test_primitive! {test_primitive_long_enum, RepeatLongEnum, LongEnum::FOO} test_primitive! {test_primitive_float_constant, RepeatFloat, ITestService::FLOAT_CONSTANT} test_primitive! {test_primitive_float_constant2, RepeatFloat, ITestService::FLOAT_CONSTANT2} test_primitive! {test_primitive_float_constant3, RepeatFloat, ITestService::FLOAT_CONSTANT3} test_primitive! {test_primitive_float_constant4, RepeatFloat, ITestService::FLOAT_CONSTANT4} test_primitive! {test_primitive_float_constant5, RepeatFloat, ITestService::FLOAT_CONSTANT5} test_primitive! {test_primitive_float_constant6, RepeatFloat, ITestService::FLOAT_CONSTANT6} test_primitive! {test_primitive_float_constant7, RepeatFloat, ITestService::FLOAT_CONSTANT7} test_primitive! {test_primitive_double_constant, RepeatDouble, ITestService::DOUBLE_CONSTANT} test_primitive! {test_primitive_double_constant2, RepeatDouble, ITestService::DOUBLE_CONSTANT2} test_primitive! {test_primitive_double_constant3, RepeatDouble, ITestService::DOUBLE_CONSTANT3} test_primitive! {test_primitive_double_constant4, RepeatDouble, ITestService::DOUBLE_CONSTANT4} test_primitive! {test_primitive_double_constant5, RepeatDouble, ITestService::DOUBLE_CONSTANT5} test_primitive! {test_primitive_double_constant6, RepeatDouble, ITestService::DOUBLE_CONSTANT6} test_primitive! {test_primitive_double_constant7, RepeatDouble, ITestService::DOUBLE_CONSTANT7} #[test] fn test_repeat_string() { let service = get_test_service(); let inputs = [ "typical string".into(), String::new(), "\0\0".into(), // This is actually two unicode code points: // U+10437: The 'small letter yee' character in the deseret alphabet // U+20AC: A euro sign String::from_utf16(&[0xD801, 0xDC37, 0x20AC]).expect("error converting string"), ITestService::STRING_CONSTANT.into(), ITestService::STRING_CONSTANT2.into(), ]; for input in &inputs { let result = service.RepeatString(input); assert_eq!(result.as_ref(), Ok(input)); } } #[test] fn test_repeat_parcelable() { let service = get_test_service(); let input = SimpleParcelable { name: "foo".to_string(), number: 42 }; let mut out_param = SimpleParcelable::default(); let returned = service.RepeatSimpleParcelable(&input, &mut out_param); assert_eq!(returned, Ok(input.clone())); assert_eq!(out_param, input); } macro_rules! test_reverse_array { ($test:ident, $func:ident, $array:expr) => { #[test] fn $test() { let mut array = $array.to_vec(); // Java needs initial values here (can't resize arrays) let mut repeated = vec![Default::default(); array.len()]; let result = get_test_service().$func(&array, &mut repeated); assert_eq!(repeated, array); array.reverse(); assert_eq!(result, Ok(array)); } }; } test_reverse_array! {test_array_boolean, ReverseBoolean, [true, false, false]} test_reverse_array! {test_array_byte, ReverseByte, [255u8, 0u8, 127u8]} test_reverse_array! { service, ReverseChar, ['A' as u16, 'B' as u16, 'C' as u16] } test_reverse_array! {test_array_int, ReverseInt, [1, 2, 3]} test_reverse_array! {test_array_long, ReverseLong, [-1i64, 0i64, 1i64 << 60]} test_reverse_array! {test_array_float, ReverseFloat, [-0.3f32, -0.7f32, 8.0f32]} test_reverse_array! { test_array_double, ReverseDouble, [1.0f64 / 3.0f64, 1.0f64 / 7.0f64, 42.0f64] } test_reverse_array! { test_array_string, ReverseString, ["f".into(), "a".into(), "b".into()] } test_reverse_array! { test_array_byte_enum, ReverseByteEnum, [ByteEnum::FOO, ByteEnum::BAR, ByteEnum::BAR] } test_reverse_array! { test_array_byte_enum_values, ReverseByteEnum, ByteEnum::enum_values() } test_reverse_array! { test_array_byte_enum_v2, ReverseByteEnum, [ByteEnum::FOO, ByteEnum::BAR, ByteEnum::BAZ] } test_reverse_array! { test_array_int_enum, ReverseIntEnum, [IntEnum::FOO, IntEnum::BAR, IntEnum::BAR] } test_reverse_array! { test_array_long_enum, ReverseLongEnum, [LongEnum::FOO, LongEnum::BAR, LongEnum::BAR] } test_reverse_array! { test_array_string_list, ReverseStringList, ["f".into(), "a".into(), "b".into()] } test_reverse_array! { test_array_utf8_string, ReverseUtf8CppString, [ "a".into(), String::new(), std::str::from_utf8(&[0xC3, 0xB8]) .expect("error converting string") .into(), ] } test_reverse_array! { test_reverse_parcelable, ReverseSimpleParcelables, [ SimpleParcelable {name: "a".to_string(), number: 1 }, SimpleParcelable {name: "b".to_string(), number: 2 }, SimpleParcelable {name: "c".to_string(), number: 3 }, ] } #[test] fn test_binder_exchange() { const NAME: &str = "Smythe"; let service = get_test_service(); let got = service.GetOtherTestService(NAME).expect("error calling GetOtherTestService"); assert_eq!(got.GetName().as_ref().map(String::as_ref), Ok(NAME)); assert_eq!(service.VerifyName(&got, NAME), Ok(true)); } #[test] fn test_binder_array_exchange() { let names = vec!["Fizz".into(), "Buzz".into()]; let service = get_test_service(); let got = service.GetInterfaceArray(&names).expect("error calling GetInterfaceArray"); assert_eq!(got.iter().map(|s| s.GetName()).collect::, _>>(), Ok(names.clone())); assert_eq!(service.VerifyNamesWithInterfaceArray(&got, &names), Ok(true)); } #[test] fn test_binder_nullable_array_exchange() { let names = vec![Some("Fizz".into()), None, Some("Buzz".into())]; let service = get_test_service(); let got = service .GetNullableInterfaceArray(Some(&names)) .expect("error calling GetNullableInterfaceArray"); assert_eq!( got.as_ref().map(|arr| arr .iter() .map(|opt_s| opt_s.as_ref().map(|s| s.GetName().expect("error calling GetName"))) .collect::>()), Some(names.clone()) ); assert_eq!( service.VerifyNamesWithNullableInterfaceArray(got.as_ref().map(|v| &v[..]), Some(&names)), Ok(true) ); } #[test] fn test_interface_list_exchange() { let names = vec![Some("Fizz".into()), None, Some("Buzz".into())]; let service = get_test_service(); let got = service.GetInterfaceList(Some(&names)).expect("error calling GetInterfaceList"); assert_eq!( got.as_ref().map(|arr| arr .iter() .map(|opt_s| opt_s.as_ref().map(|s| s.GetName().expect("error calling GetName"))) .collect::>()), Some(names.clone()) ); assert_eq!( service.VerifyNamesWithInterfaceList(got.as_ref().map(|v| &v[..]), Some(&names)), Ok(true) ); } fn build_pipe() -> (OwnedFd, OwnedFd) { // Safety: we get two file descriptors from pipe() // and pass them after checking if the function returned // without an error, so the descriptors should be valid // by that point unsafe { let mut fds = [0, 0]; if libc::pipe(fds.as_mut_ptr()) != 0 { panic!("pipe() error"); } (OwnedFd::from_raw_fd(fds[0]), OwnedFd::from_raw_fd(fds[1])) } } /// Helper function that constructs a `File` from a `ParcelFileDescriptor`. /// /// This is needed because `File` is currently the way to read and write /// to pipes using the `Read` and `Write` traits. fn file_from_pfd(fd: &binder::ParcelFileDescriptor) -> File { fd.as_ref().try_clone().expect("failed to clone file descriptor").into() } #[test] fn test_parcel_file_descriptor() { let service = get_test_service(); let (read_fd, write_fd) = build_pipe(); let mut read_file = File::from(read_fd); let write_pfd = binder::ParcelFileDescriptor::new(write_fd); let result_pfd = service .RepeatParcelFileDescriptor(&write_pfd) .expect("error calling RepeatParcelFileDescriptor"); const TEST_DATA: &[u8] = b"FrazzleSnazzleFlimFlamFlibbityGumboChops"; file_from_pfd(&result_pfd).write_all(TEST_DATA).expect("error writing to pipe"); let mut buf = [0u8; TEST_DATA.len()]; read_file.read_exact(&mut buf).expect("error reading from pipe"); assert_eq!(&buf[..], TEST_DATA); } #[test] fn test_parcel_file_descriptor_array() { let service = get_test_service(); let (read_fd, write_fd) = build_pipe(); let input = vec![ binder::ParcelFileDescriptor::new(read_fd), binder::ParcelFileDescriptor::new(write_fd), ]; let mut repeated = vec![]; let backend = service.getBackendType().expect("error getting backend type"); if backend == BackendType::JAVA { // Java needs initial values here (can't resize arrays) // Other backends can't accept 'None', but we can use it in Java for convenience, rather // than creating file descriptors. repeated = vec![None, None]; } let result = service .ReverseParcelFileDescriptorArray(&input[..], &mut repeated) .expect("error calling ReverseParcelFileDescriptorArray"); file_from_pfd(&input[1]).write_all(b"First").expect("error writing to pipe"); file_from_pfd(repeated[1].as_ref().expect("received None for ParcelFileDescriptor")) .write_all(b"Second") .expect("error writing to pipe"); file_from_pfd(&result[0]).write_all(b"Third").expect("error writing to pipe"); const TEST_DATA: &[u8] = b"FirstSecondThird"; let mut buf = [0u8; TEST_DATA.len()]; file_from_pfd(&input[0]).read_exact(&mut buf).expect("error reading from pipe"); assert_eq!(&buf[..], TEST_DATA); } #[test] fn test_service_specific_exception() { let service = get_test_service(); for i in -1..2 { let result = service.ThrowServiceException(i); assert!(result.is_err()); let status = result.unwrap_err(); assert_eq!(status.exception_code(), binder::ExceptionCode::SERVICE_SPECIFIC); assert_eq!(status.service_specific_error(), i); } } macro_rules! test_nullable { ($test:ident, $func:ident, $value:expr) => { #[test] fn $test() { let service = get_test_service(); let value = Some($value); let result = service.$func(value.as_deref()); assert_eq!(result, Ok(value)); let result = service.$func(None); assert_eq!(result, Ok(None)); } }; } test_nullable! {test_nullable_array_int, RepeatNullableIntArray, vec![1, 2, 3]} test_nullable! { test_nullable_array_byte_enum, RepeatNullableByteEnumArray, vec![ByteEnum::FOO, ByteEnum::BAR] } test_nullable! { test_nullable_array_int_enum, RepeatNullableIntEnumArray, vec![IntEnum::FOO, IntEnum::BAR] } test_nullable! { test_nullable_array_long_enum, RepeatNullableLongEnumArray, vec![LongEnum::FOO, LongEnum::BAR] } test_nullable! {test_nullable_string, RepeatNullableString, "Blooob".into()} test_nullable! { test_nullable_string_list, RepeatNullableStringList, vec![ Some("Wat".into()), Some("Blooob".into()), Some("Wat".into()), None, Some("YEAH".into()), Some("OKAAAAY".into()), ] } #[test] fn test_nullable_parcelable() { let value = Empty {}; let service = get_test_service(); let value = Some(value); let result = service.RepeatNullableParcelable(value.as_ref()); assert_eq!(result, Ok(value)); let result = service.RepeatNullableParcelable(None); assert_eq!(result, Ok(None)); } test_nullable! { test_nullable_parcelable_array, RepeatNullableParcelableArray, vec![ Some(Empty {}), None, ] } test_nullable! { test_nullable_parcelable_list, RepeatNullableParcelableList, vec![ Some(Empty {}), None, ] } #[test] fn test_binder() { let service = get_test_service(); assert!(service.GetCallback(true).expect("error calling GetCallback").is_none()); let callback = service .GetCallback(false) .expect("error calling GetCallback") .expect("expected Some from GetCallback"); // We don't have any place to get a fresh `SpIBinder`, so we // reuse the interface for the binder tests let binder = callback.as_binder(); assert_eq!(service.TakesAnIBinder(&binder), Ok(())); assert_eq!(service.TakesANullableIBinder(None), Ok(())); assert_eq!(service.TakesANullableIBinder(Some(&binder)), Ok(())); } macro_rules! test_reverse_null_array { ($service:expr, $func:ident, $expect_repeated:expr) => {{ let mut repeated = None; let result = $service.$func(None, &mut repeated); assert_eq!(repeated, $expect_repeated); assert_eq!(result, Ok(None)); }}; } macro_rules! test_reverse_nullable_array { ($service:expr, $func:ident, $array:expr) => {{ let mut array = $array; // Java needs initial values here (can't resize arrays) let mut repeated = Some(vec![Default::default(); array.len()]); let result = $service.$func(Some(&array[..]), &mut repeated); assert_eq!(repeated.as_ref(), Some(&array)); array.reverse(); assert_eq!(result, Ok(Some(array))); }}; } #[test] fn test_utf8_string() { let service = get_test_service(); let inputs = [ "typical string", "", "\0\0", std::str::from_utf8(&[0xF0, 0x90, 0x90, 0xB7, 0xE2, 0x82, 0xAC]) .expect("error converting string"), ITestService::STRING_CONSTANT_UTF8, ]; for input in &inputs { let result = service.RepeatUtf8CppString(input); assert_eq!(result.as_ref().map(String::as_str), Ok(*input)); let result = service.RepeatNullableUtf8CppString(Some(input)); assert_eq!(result.as_ref().map(Option::as_deref), Ok(Some(*input))); } let result = service.RepeatNullableUtf8CppString(None); assert_eq!(result, Ok(None)); let inputs = vec![ Some("typical string".into()), Some(String::new()), None, Some( std::str::from_utf8(&[0xF0, 0x90, 0x90, 0xB7, 0xE2, 0x82, 0xAC]) .expect("error converting string") .into(), ), Some(ITestService::STRING_CONSTANT_UTF8.into()), ]; // Java can't return a null list as a parameter let backend = service.getBackendType().expect("error getting backend type"); let null_output = if backend == BackendType::JAVA { Some(vec![]) } else { None }; test_reverse_null_array!(service, ReverseUtf8CppStringList, null_output); test_reverse_null_array!(service, ReverseNullableUtf8CppString, None); test_reverse_nullable_array!(service, ReverseUtf8CppStringList, inputs.clone()); test_reverse_nullable_array!(service, ReverseNullableUtf8CppString, inputs); } #[allow(clippy::approx_constant)] #[allow(clippy::float_cmp)] #[test] fn test_parcelable() { let service = get_test_service(); let mut parcelable = StructuredParcelable::StructuredParcelable::default(); const DESIRED_VALUE: i32 = 23; parcelable.f = DESIRED_VALUE; assert_eq!(parcelable.stringDefaultsToFoo, "foo"); assert_eq!(parcelable.byteDefaultsToFour, 4); assert_eq!(parcelable.intDefaultsToFive, 5); assert_eq!(parcelable.longDefaultsToNegativeSeven, -7); assert!(parcelable.booleanDefaultsToTrue); assert_eq!(parcelable.charDefaultsToC, 'C' as u16); assert_eq!(parcelable.floatDefaultsToPi, 3.14f32); assert_eq!(parcelable.doubleWithDefault, -3.14e17f64); assert!(!parcelable.boolDefault); assert_eq!(parcelable.byteDefault, 0); assert_eq!(parcelable.intDefault, 0); assert_eq!(parcelable.longDefault, 0); assert_eq!(parcelable.floatDefault, 0.0f32); assert_eq!(parcelable.doubleDefault, 0.0f64); assert_eq!(parcelable.arrayDefaultsTo123, &[1, 2, 3]); assert!(parcelable.arrayDefaultsToEmpty.is_empty()); let result = service.FillOutStructuredParcelable(&mut parcelable); assert_eq!(result, Ok(())); assert_eq!(parcelable.shouldContainThreeFs, [DESIRED_VALUE, DESIRED_VALUE, DESIRED_VALUE]); assert_eq!(parcelable.shouldBeJerry, "Jerry"); assert_eq!(parcelable.int32_min, i32::MIN); assert_eq!(parcelable.int32_max, i32::MAX); assert_eq!(parcelable.int64_max, i64::MAX); assert_eq!(parcelable.hexInt32_neg_1, -1); for i in parcelable.int8_1 { assert_eq!(i, 1); } for i in parcelable.int32_1 { assert_eq!(i, 1); } for i in parcelable.int64_1 { assert_eq!(i, 1); } assert_eq!(parcelable.hexInt32_pos_1, 1); assert_eq!(parcelable.hexInt64_pos_1, 1); assert_eq!(parcelable.const_exprs_1.0, 1); assert_eq!(parcelable.const_exprs_2.0, 1); assert_eq!(parcelable.const_exprs_3.0, 1); assert_eq!(parcelable.const_exprs_4.0, 1); assert_eq!(parcelable.const_exprs_5.0, 1); assert_eq!(parcelable.const_exprs_6.0, 1); assert_eq!(parcelable.const_exprs_7.0, 1); assert_eq!(parcelable.const_exprs_8.0, 1); assert_eq!(parcelable.const_exprs_9.0, 1); assert_eq!(parcelable.const_exprs_10.0, 1); assert_eq!(parcelable.addString1, "hello world!"); assert_eq!(parcelable.addString2, "The quick brown fox jumps over the lazy dog."); assert_eq!( parcelable.shouldSetBit0AndBit2, StructuredParcelable::BIT0 | StructuredParcelable::BIT2 ); assert_eq!(parcelable.u, Some(Union::Union::Ns(vec![1, 2, 3]))); assert_eq!(parcelable.shouldBeConstS1, Some(Union::Union::S(Union::S1.to_string()))) } #[test] fn test_repeat_extendable_parcelable() { let service = get_test_service(); let ext = Arc::new(MyExt { a: 42, b: "EXT".into() }); let mut ep = ExtendableParcelable { a: 1, b: "a".into(), c: 42, ..Default::default() }; ep.ext.set_parcelable(Arc::clone(&ext)).expect("error setting parcelable"); let mut ep2 = ExtendableParcelable::default(); let result = service.RepeatExtendableParcelable(&ep, &mut ep2); assert_eq!(result, Ok(())); assert_eq!(ep2.a, ep.a); assert_eq!(ep2.b, ep.b); let ret_ext = ep2.ext.get_parcelable::().expect("error getting parcelable"); assert!(ret_ext.is_some()); let ret_ext = ret_ext.unwrap(); assert_eq!(ret_ext.a, ext.a); assert_eq!(ret_ext.b, ext.b); } macro_rules! test_parcelable_holder_stability { ($test:ident, $holder:path, $parcelable:path) => { #[test] fn $test() { let mut holder = <$holder>::default(); let parcelable = Arc::new(<$parcelable>::default()); let result = holder.ext.set_parcelable(Arc::clone(&parcelable)); assert_eq!(result, Ok(())); let parcelable2 = holder.ext.get_parcelable::<$parcelable>().unwrap().unwrap(); assert!(Arc::ptr_eq(&parcelable, &parcelable2)); } }; } test_parcelable_holder_stability! { test_vintf_parcelable_holder_can_contain_vintf_parcelable, VintfExtendableParcelable, VintfParcelable } test_parcelable_holder_stability! { test_stable_parcelable_holder_can_contain_vintf_parcelable, NonVintfExtendableParcelable, VintfParcelable } test_parcelable_holder_stability! { test_stable_parcelable_holder_can_contain_non_vintf_parcelable, NonVintfExtendableParcelable, NonVintfParcelable } test_parcelable_holder_stability! { test_stable_parcelable_holder_can_contain_unstable_parcelable, NonVintfExtendableParcelable, UnstableParcelable } test_parcelable_holder_stability! { test_unstable_parcelable_holder_can_contain_vintf_parcelable, UnstableExtendableParcelable, VintfParcelable } test_parcelable_holder_stability! { test_unstable_parcelable_holder_can_contain_non_vintf_parcelable, UnstableExtendableParcelable, NonVintfParcelable } test_parcelable_holder_stability! { test_unstable_parcelable_holder_can_contain_unstable_parcelable, UnstableExtendableParcelable, UnstableParcelable } #[test] fn test_vintf_parcelable_holder_cannot_contain_not_vintf_parcelable() { let mut holder = VintfExtendableParcelable::default(); let parcelable = Arc::new(NonVintfParcelable::default()); let result = holder.ext.set_parcelable(Arc::clone(&parcelable)); assert_eq!(result, Err(binder::StatusCode::BAD_VALUE)); let parcelable2 = holder.ext.get_parcelable::(); assert!(parcelable2.unwrap().is_none()); } #[test] fn test_vintf_parcelable_holder_cannot_contain_unstable_parcelable() { let mut holder = VintfExtendableParcelable::default(); let parcelable = Arc::new(UnstableParcelable::default()); let result = holder.ext.set_parcelable(Arc::clone(&parcelable)); assert_eq!(result, Err(binder::StatusCode::BAD_VALUE)); let parcelable2 = holder.ext.get_parcelable::(); assert!(parcelable2.unwrap().is_none()); } #[test] fn test_read_write_extension() { let ext = Arc::new(MyExt { a: 42, b: "EXT".into() }); let ext2 = Arc::new(MyExt2 { a: 42, b: MyExt { a: 24, b: "INEXT".into() }, c: "EXT2".into() }); let mut ep = ExtendableParcelable { a: 1, b: "a".into(), c: 42, ..Default::default() }; ep.ext.set_parcelable(Arc::clone(&ext)).unwrap(); ep.ext2.set_parcelable(Arc::clone(&ext2)).unwrap(); let ext_like = ep.ext.get_parcelable::(); assert_eq!(ext_like.unwrap_err(), binder::StatusCode::BAD_VALUE); let actual_ext = ep.ext.get_parcelable::(); assert!(actual_ext.unwrap().is_some()); let actual_ext2 = ep.ext2.get_parcelable::(); assert!(actual_ext2.unwrap().is_some()); check_extension_content(&ep, &ext, &ext2); let mut parcel = Parcel::new(); ep.write_to_parcel(&mut parcel.borrowed()).unwrap(); // SAFETY: 0 is less than the current size of the parcel data buffer, because the parcel is not // empty. unsafe { parcel.set_data_position(0).unwrap(); } let mut ep1 = ExtendableParcelable::default(); ep1.read_from_parcel(parcel.borrowed_ref()).unwrap(); // SAFETY: 0 is less than the current size of the parcel data buffer, because the parcel is not // empty. unsafe { parcel.set_data_position(0).unwrap(); } ep1.write_to_parcel(&mut parcel.borrowed()).unwrap(); // SAFETY: 0 is less than the current size of the parcel data buffer, because the parcel is not // empty. unsafe { parcel.set_data_position(0).unwrap(); } let mut ep2 = ExtendableParcelable::default(); ep2.read_from_parcel(parcel.borrowed_ref()).unwrap(); let ext_like = ep2.ext.get_parcelable::(); assert!(ext_like.unwrap().is_none()); let actual_ext = ep2.ext.get_parcelable::(); assert!(actual_ext.unwrap().is_some()); let new_ext2 = Arc::new(MyExt2 { a: 79, b: MyExt { a: 42, b: "INNEWEXT".into() }, c: "NEWEXT2".into() }); ep2.ext2.set_parcelable(Arc::clone(&new_ext2)).unwrap(); check_extension_content(&ep1, &ext, &ext2); check_extension_content(&ep2, &ext, &new_ext2); } fn check_extension_content(ep: &ExtendableParcelable, ext: &MyExt, ext2: &MyExt2) { assert_eq!(ep.a, 1); assert_eq!(ep.b, "a"); assert_eq!(ep.c, 42); let actual_ext = ep.ext.get_parcelable::().unwrap().unwrap(); assert_eq!(ext.a, actual_ext.a); assert_eq!(ext.b, actual_ext.b); let actual_ext2 = ep.ext2.get_parcelable::().unwrap().unwrap(); assert_eq!(ext2.a, actual_ext2.a); assert_eq!(ext2.b.a, actual_ext2.b.a); assert_eq!(ext2.b.b, actual_ext2.b.b); assert_eq!(ext2.c, actual_ext2.c); } #[test] fn test_reverse_recursive_list() { let service = get_test_service(); let mut head = None; for n in 0..10 { let node = RecursiveList { value: n, next: head }; head = Some(Box::new(node)); } // head = [9, 8, .., 0] let result = service.ReverseList(head.as_ref().unwrap()); assert!(result.is_ok()); // reversed should be [0, 1, ... 9] let mut reversed: Option<&RecursiveList> = result.as_ref().ok(); for n in 0..10 { assert_eq!(reversed.map(|inner| inner.value), Some(n)); reversed = reversed.unwrap().next.as_ref().map(|n| n.as_ref()); } assert!(reversed.is_none()) } #[test] fn test_get_union_tags() { let service = get_test_service(); let result = service.GetUnionTags(&[]); assert_eq!(result, Ok(vec![])); let result = service.GetUnionTags(&[Union::Union::N(0), Union::Union::Ns(vec![])]); assert_eq!(result, Ok(vec![Union::Tag::Tag::n, Union::Tag::Tag::ns])); } #[test] fn test_unions() { assert_eq!(Union::Union::default(), Union::Union::Ns(vec![])); assert_eq!(EnumUnion::default(), EnumUnion::IntEnum(IntEnum::FOO)); } const EXPECTED_ARG_VALUE: i32 = 100; const EXPECTED_RETURN_VALUE: i32 = 200; struct TestDefaultImpl; impl binder::Interface for TestDefaultImpl {} impl ITestServiceDefault for TestDefaultImpl { fn UnimplementedMethod(&self, arg: i32) -> binder::Result { assert_eq!(arg, EXPECTED_ARG_VALUE); Ok(EXPECTED_RETURN_VALUE) } } #[test] fn test_default_impl() { let service = get_test_service(); let di: ITestServiceDefaultRef = Some(Arc::new(TestDefaultImpl)); ::setDefaultImpl(di); let result = service.UnimplementedMethod(EXPECTED_ARG_VALUE); assert_eq!(result, Ok(EXPECTED_RETURN_VALUE)); } #[test] fn test_versioned_interface_version() { let service: binder::Strong = binder::get_interface(::get_descriptor()) .expect("did not get binder service"); let version = service.getInterfaceVersion(); assert_eq!(version, Ok(1)); } #[test] fn test_versioned_interface_hash() { let service: binder::Strong = binder::get_interface(::get_descriptor()) .expect("did not get binder service"); let hash = service.getInterfaceHash(); assert_eq!(hash.as_ref().map(String::as_str), Ok("9e7be1859820c59d9d55dd133e71a3687b5d2e5b")); } #[test] fn test_versioned_known_union_field_is_ok() { let service: binder::Strong = binder::get_interface(::get_descriptor()) .expect("did not get binder service"); assert_eq!(service.acceptUnionAndReturnString(&BazUnion::IntNum(42)), Ok(String::from("42"))); } #[test] fn test_versioned_unknown_union_field_triggers_error() { let service: binder::Strong = binder::get_interface(::get_descriptor()) .expect("did not get binder service"); let ret = service.acceptUnionAndReturnString(&BazUnion::LongNum(42)); assert!(ret.is_err()); let main_service = get_test_service(); let backend = main_service.getBackendType().expect("error getting backend type"); // b/173458620 - for investigation of fixing difference if backend == BackendType::JAVA { assert_eq!(ret.unwrap_err().exception_code(), binder::ExceptionCode::ILLEGAL_ARGUMENT); } else { assert_eq!(ret.unwrap_err().transaction_error(), binder::StatusCode::BAD_VALUE); } } #[test] fn test_array_of_parcelable_with_new_field() { let service: binder::Strong = binder::get_interface(::get_descriptor()) .expect("did not get binder service"); let foos = [Default::default(), Default::default(), Default::default()]; let ret = service.returnsLengthOfFooArray(&foos); assert_eq!(ret, Ok(foos.len() as i32)); } #[test] fn test_read_data_correctly_after_parcelable_with_new_field() { let service: binder::Strong = binder::get_interface(::get_descriptor()) .expect("did not get binder service"); let in_foo = Default::default(); let mut inout_foo = Foo { intDefault42: 0 }; let mut out_foo = Foo { intDefault42: 0 }; let ret = service.ignoreParcelablesAndRepeatInt(&in_foo, &mut inout_foo, &mut out_foo, 43); assert_eq!(ret, Ok(43)); assert_eq!(inout_foo.intDefault42, 0); assert_eq!(out_foo.intDefault42, 0); } #[test] fn test_calling_v2_api_triggers_error() { let service: binder::Strong = binder::get_interface(::get_descriptor()) .expect("did not get binder service"); let ret = service.newApi(); assert_eq!(ret.unwrap_err().transaction_error(), binder::StatusCode::UNKNOWN_TRANSACTION); } fn test_renamed_interface(f: F) where F: FnOnce(binder::Strong, binder::Strong), { let service = get_test_service(); let old_name = service.GetOldNameInterface(); assert!(old_name.is_ok()); let new_name = service.GetNewNameInterface(); assert!(new_name.is_ok()); f(old_name.unwrap(), new_name.unwrap()); } #[test] fn test_renamed_interface_old_as_old() { test_renamed_interface(|old_name, _| { assert_eq!( ::get_descriptor(), "android.aidl.tests.IOldName" ); let real_name = old_name.RealName(); assert_eq!(real_name.as_ref().map(String::as_str), Ok("OldName")); }); } #[test] fn test_renamed_interface_new_as_new() { test_renamed_interface(|_, new_name| { assert_eq!( ::get_descriptor(), "android.aidl.tests.IOldName" ); let real_name = new_name.RealName(); assert_eq!(real_name.as_ref().map(String::as_str), Ok("NewName")); }); } #[test] fn test_renamed_interface_old_as_new() { test_renamed_interface(|old_name, _| { let new_name = old_name.as_binder().into_interface::(); assert!(new_name.is_ok()); let real_name = new_name.unwrap().RealName(); assert_eq!(real_name.as_ref().map(String::as_str), Ok("OldName")); }); } #[test] fn test_renamed_interface_new_as_old() { test_renamed_interface(|_, new_name| { let old_name = new_name.as_binder().into_interface::(); assert!(old_name.is_ok()); let real_name = old_name.unwrap().RealName(); assert_eq!(real_name.as_ref().map(String::as_str), Ok("NewName")); }); } #[derive(Debug, Default)] struct Callback { received: Arc>>, } impl Interface for Callback {} impl INestedService::ICallback::ICallback for Callback { fn done(&self, st: ParcelableWithNested::Status::Status) -> binder::Result<()> { *self.received.lock().unwrap() = Some(st); Ok(()) } } #[test] fn test_nested_type() { let service: binder::Strong = binder::get_interface( ::get_descriptor(), ) .expect("did not get binder service"); let p = ParcelableWithNested::ParcelableWithNested { status: ParcelableWithNested::Status::Status::OK, }; // OK -> NOT_OK let ret = service.flipStatus(&p); assert_eq!( ret, Ok(INestedService::Result::Result { status: ParcelableWithNested::Status::Status::NOT_OK }) ); let received = Arc::new(Mutex::new(None)); // NOT_OK -> OK with nested callback interface let cb = INestedService::ICallback::BnCallback::new_binder( Callback { received: Arc::clone(&received) }, BinderFeatures::default(), ); let ret = service.flipStatusWithCallback(ParcelableWithNested::Status::Status::NOT_OK, &cb); assert_eq!(ret, Ok(())); let received = received.lock().unwrap(); assert_eq!(*received, Some(ParcelableWithNested::Status::Status::OK)) } #[test] fn test_nonnull_binder() { let service = get_test_service(); let result = service.TakesAnIBinder(&service.as_binder()); assert!(result.is_ok()); } #[test] fn test_binder_list_without_null() { let service = get_test_service(); let result = service.TakesAnIBinderList(&[service.as_binder()]); assert!(result.is_ok()); } #[test] fn test_null_binder_to_annotated_method() { let service = get_test_service(); let result = service.TakesANullableIBinder(None); assert!(result.is_ok()); } #[test] fn test_binder_list_with_null_to_annotated_method() { let service = get_test_service(); let result = service.TakesANullableIBinderList(Some(&[Some(service.as_binder()), None])); assert!(result.is_ok()); } #[test] fn test_binder_array() { let service = get_test_service(); let callback = service .GetCallback(false) .expect("error calling GetCallback") .expect("expected Some from GetCallback"); let mut array = vec![service.as_binder(), callback.as_binder()]; // Java needs initial values here (can't resize arrays) let mut repeated = vec![Default::default(); array.len()]; let result = service.ReverseIBinderArray(&array, &mut repeated); assert_eq!(repeated.into_iter().collect::>>().as_ref(), Some(&array)); array.reverse(); assert_eq!(result, Ok(array)); } #[test] fn test_nullable_binder_array() { let service = get_test_service(); let mut array = vec![Some(service.as_binder()), None]; // Java needs initial values here (can't resize arrays) let mut repeated = Some(vec![Default::default(); array.len()]); let result = service.ReverseNullableIBinderArray(Some(&array[..]), &mut repeated); assert_eq!(repeated.as_ref(), Some(&array)); array.reverse(); assert_eq!(result, Ok(Some(array))); } #[test] fn test_read_write_fixed_size_array() { let mut parcel = Parcel::new(); let mut p: FixedSizeArrayExample = Default::default(); p.byteMatrix[0][0] = 0; p.byteMatrix[0][1] = 1; p.byteMatrix[1][0] = 2; p.byteMatrix[1][1] = 3; p.floatMatrix[0][0] = 0.0; p.floatMatrix[0][1] = 1.0; p.floatMatrix[1][0] = 2.0; p.floatMatrix[1][1] = 3.0; p.boolNullableArray = Some([true, false]); p.byteNullableArray = Some([42, 0]); p.stringNullableArray = Some([Some("hello".into()), Some("world".into())]); p.boolNullableMatrix = Some([[true, false], Default::default()]); p.byteNullableMatrix = Some([[42, 0], Default::default()]); p.stringNullableMatrix = Some([[Some("hello".into()), Some("world".into())], Default::default()]); assert_eq!(parcel.write(&p), Ok(())); // SAFETY: 0 is less than the current size of the parcel data buffer, because the parcel is not // empty. unsafe { parcel.set_data_position(0).unwrap(); } assert_eq!(p, parcel.read::().unwrap()); } #[test] fn test_fixed_size_array_uses_array_optimization() { let mut parcel = Parcel::new(); let byte_array = [[1u8, 2u8, 3u8], [4u8, 5u8, 6u8]]; assert_eq!(parcel.write(&byte_array), Ok(())); // SAFETY: 0 is less than the current size of the parcel data buffer, because the parcel is not // empty. unsafe { parcel.set_data_position(0).unwrap(); } assert_eq!(parcel.read::(), Ok(2i32)); assert_eq!(parcel.read::>(), Ok(vec![1u8, 2u8, 3u8])); assert_eq!(parcel.read::>(), Ok(vec![4u8, 5u8, 6u8])); } macro_rules! test_repeat_fixed_size_array { ($service:ident, $func:ident, $value:expr) => { let array = $value; let mut repeated = Default::default(); let result = $service.$func(&array, &mut repeated).unwrap(); assert_eq!(repeated, array); assert_eq!(result, array); }; } macro_rules! test_repeat_fixed_size_array_1d_binder { ($service:ident, $func:ident, $value:expr) => { let array = $value; let mut repeated = Default::default(); let result = $service.$func(&array, &mut repeated).unwrap(); assert_eq!(result, array.clone()); assert_eq!(repeated, array.map(Some)); }; } macro_rules! test_repeat_fixed_size_array_2d_binder { ($service:ident, $func:ident, $value:expr) => { let array = $value; let mut repeated = Default::default(); let result = $service.$func(&array, &mut repeated).unwrap(); assert_eq!(result, array.clone()); assert_eq!(repeated, array.map(|row| row.map(Some))); }; } #[test] fn test_fixed_size_array_over_binder() { let test_service = get_test_service(); let service: binder::Strong = binder::get_interface(::get_descriptor()) .expect("did not get binder service"); test_repeat_fixed_size_array!(service, RepeatBytes, [1u8, 2u8, 3u8]); test_repeat_fixed_size_array!(service, RepeatInts, [1i32, 2i32, 3i32]); let binder1 = test_service.as_binder(); let binder2 = test_service .GetCallback(false) .expect("error calling GetCallback") .expect("expected Some from GetCallback") .as_binder(); let binder3 = service.as_binder(); test_repeat_fixed_size_array_1d_binder!( service, RepeatBinders, [binder1.clone(), binder2.clone(), binder3.clone()] ); let p1 = IntParcelable { value: 1 }; let p2 = IntParcelable { value: 2 }; let p3 = IntParcelable { value: 3 }; test_repeat_fixed_size_array!(service, RepeatParcelables, [p1, p2, p3]); test_repeat_fixed_size_array!(service, Repeat2dBytes, [[1u8, 2u8, 3u8], [1u8, 2u8, 3u8]]); test_repeat_fixed_size_array!(service, Repeat2dInts, [[1i32, 2i32, 3i32], [1i32, 2i32, 3i32]]); test_repeat_fixed_size_array_2d_binder!( service, Repeat2dBinders, [[binder1.clone(), binder2.clone(), binder3.clone()], [binder1, binder2, binder3]] ); test_repeat_fixed_size_array!(service, Repeat2dParcelables, [[p1, p2, p3], [p1, p2, p3]]); } #[test] fn test_ping() { let test_service = get_test_service(); assert_eq!(test_service.as_binder().ping_binder(), Ok(())); } #[test] fn test_trunk_stable_parcelable() { let service = get_test_trunk_stable_service(); let res = service.getInterfaceVersion(); assert!(res.is_ok()); let version = res.unwrap(); let p1 = MyParcelable { a: 12, b: 13, c: 14 }; let result = service.repeatParcelable(&p1); assert!(result.is_ok()); let p2 = result.unwrap(); assert_eq!(p1.a, p2.a); assert_eq!(p1.b, p2.b); if version == 1 { assert_ne!(p1.c, p2.c); assert_eq!(0, p2.c); } else { assert_eq!(p1.c, p2.c); } } #[test] fn test_trunk_stable_enum() { let service = get_test_trunk_stable_service(); let e1 = MyEnum::THREE; let result = service.repeatEnum(e1); assert!(result.is_ok()); assert_eq!(result.unwrap(), e1); } #[test] fn test_trunk_stable_union() { let service = get_test_trunk_stable_service(); let res = service.getInterfaceVersion(); assert!(res.is_ok()); let version = res.unwrap(); let u1 = MyUnion::C(14); let result = service.repeatUnion(&u1); if version == 1 { assert!(result.is_err()); } else { assert!(result.is_ok()); } } #[test] fn test_trunk_stable_unimplemented() { let service = get_test_trunk_stable_service(); let res = service.getInterfaceVersion(); assert!(res.is_ok()); let version = res.unwrap(); let p1 = MyOtherParcelable { a: 12, b: 13 }; let result = service.repeatOtherParcelable(&p1); if version == 1 { assert!(result.is_err()); } else { assert!(result.is_ok()); } } #[test] fn test_trunk_stable_hash() { let service = get_test_trunk_stable_service(); let res = service.getInterfaceVersion(); assert!(res.is_ok()); let version = res.unwrap(); let hash = service.getInterfaceHash(); if version == 1 { assert_eq!( hash.as_ref().map(String::as_str), Ok("88311b9118fb6fe9eff4a2ca19121de0587f6d5f") ); // Check local values of version and hash assert_eq!( android_aidl_test_trunk::aidl::android::aidl::test::trunk::ITrunkStableTest::VERSION, 1 ); assert_eq!( android_aidl_test_trunk::aidl::android::aidl::test::trunk::ITrunkStableTest::HASH, "88311b9118fb6fe9eff4a2ca19121de0587f6d5f" ); } else { assert_eq!(hash.as_ref().map(String::as_str), Ok("notfrozen")); // Check local values of version and hash assert_eq!( android_aidl_test_trunk::aidl::android::aidl::test::trunk::ITrunkStableTest::VERSION, 2 ); assert_eq!( android_aidl_test_trunk::aidl::android::aidl::test::trunk::ITrunkStableTest::HASH, "notfrozen" ); } } #[derive(Debug, Default)] pub struct MyCallback { pub repeat_parcelable_called: Arc>, pub repeat_enum_called: Arc>, pub repeat_union_called: Arc>, pub repeat_other_parcelable_called: Arc>, } impl Interface for MyCallback {} impl IMyCallback::IMyCallback for MyCallback { fn repeatParcelable(&self, in_parcel: &MyParcelable) -> binder::Result { *self.repeat_parcelable_called.lock().unwrap() = true; let tmp: MyParcelable = MyParcelable { a: in_parcel.a, b: in_parcel.b, c: in_parcel.c }; Ok(tmp) } fn repeatEnum(&self, in_enum: MyEnum) -> binder::Result { *self.repeat_enum_called.lock().unwrap() = true; Ok(in_enum) } fn repeatUnion(&self, in_union: &MyUnion) -> binder::Result { *self.repeat_union_called.lock().unwrap() = true; match in_union { MyUnion::A(n) => Ok(MyUnion::A(*n)), MyUnion::B(n) => Ok(MyUnion::B(*n)), MyUnion::C(n) => Ok(MyUnion::C(*n)), } } fn repeatOtherParcelable( &self, in_parcel: &MyOtherParcelable, ) -> binder::Result { *self.repeat_other_parcelable_called.lock().unwrap() = true; let tmp: MyOtherParcelable = MyOtherParcelable { a: in_parcel.a, b: in_parcel.b }; Ok(tmp) } } #[test] fn test_trunk_stable_callback() { let service = get_test_trunk_stable_service(); let res = service.getInterfaceVersion(); assert!(res.is_ok()); let version = res.unwrap(); let repeat_parcelable_called = Arc::new(Mutex::new(false)); let repeat_enum_called = Arc::new(Mutex::new(false)); let repeat_union_called = Arc::new(Mutex::new(false)); let repeat_other_parcelable_called = Arc::new(Mutex::new(false)); let cb = IMyCallback::BnMyCallback::new_binder( MyCallback { repeat_parcelable_called: Arc::clone(&repeat_parcelable_called), repeat_enum_called: Arc::clone(&repeat_enum_called), repeat_union_called: Arc::clone(&repeat_union_called), repeat_other_parcelable_called: Arc::clone(&repeat_other_parcelable_called), }, BinderFeatures::default(), ); let result = service.callMyCallback(&cb); assert!(result.is_ok()); assert!(*repeat_parcelable_called.lock().unwrap()); assert!(*repeat_enum_called.lock().unwrap()); assert!(*repeat_union_called.lock().unwrap()); if version == 1 { assert!(!*repeat_other_parcelable_called.lock().unwrap()); } else { assert!(*repeat_other_parcelable_called.lock().unwrap()); } } ./PaxHeaders.X/tests_rust_test_service.rs0100644 0000000 0000000 00000000034 15172120304 017640 xustar000000000 0000000 28 mtime=1776853188.7840000 tests/rust/test_service.rs0100644 0000000 0000000 00000060327 15172120304 015014 0ustar000000000 0000000 /* * 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. */ //! Test Rust service for the AIDL compiler. use aidl_test_fixedsizearray::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::{ IRepeatFixedSizeArray, IntParcelable::IntParcelable, }; use aidl_test_interface::aidl::android::aidl::tests::nested::{ INestedService, ParcelableWithNested, }; use aidl_test_interface::aidl::android::aidl::tests::ITestService::{ self, BnTestService, BpTestService, Empty::Empty, }; use aidl_test_interface::aidl::android::aidl::tests::{ extension::ExtendableParcelable::ExtendableParcelable, extension::MyExt::MyExt, BackendType::BackendType, ByteEnum::ByteEnum, CircularParcelable::CircularParcelable, ConstantExpressionEnum::ConstantExpressionEnum, ICircular, INamedCallback, INewName, IOldName, IntEnum::IntEnum, LongEnum::LongEnum, RecursiveList::RecursiveList, StructuredParcelable, Union, }; use aidl_test_interface::binder::{ self, BinderFeatures, Interface, ParcelFileDescriptor, SpIBinder, }; use aidl_test_versioned_interface::aidl::android::aidl::versioned::tests::{ BazUnion::BazUnion, Foo::Foo, IFooInterface, IFooInterface::BnFooInterface, IFooInterface::BpFooInterface, }; use android_aidl_test_trunk::aidl::android::aidl::test::trunk::{ ITrunkStableTest, ITrunkStableTest::BnTrunkStableTest, ITrunkStableTest::BpTrunkStableTest, ITrunkStableTest::IMyCallback, ITrunkStableTest::MyEnum::MyEnum, ITrunkStableTest::MyOtherParcelable::MyOtherParcelable, ITrunkStableTest::MyParcelable::MyParcelable, ITrunkStableTest::MyUnion::MyUnion, }; use simple_parcelable::SimpleParcelable; use std::collections::HashMap; use std::sync::Mutex; fn dup_fd(fd: &ParcelFileDescriptor) -> ParcelFileDescriptor { ParcelFileDescriptor::new(fd.as_ref().try_clone().unwrap()) } struct NamedCallback(String); impl Interface for NamedCallback {} impl INamedCallback::INamedCallback for NamedCallback { fn GetName(&self) -> binder::Result { Ok(self.0.clone()) } } struct OldName; impl Interface for OldName {} impl IOldName::IOldName for OldName { fn RealName(&self) -> binder::Result { Ok("OldName".into()) } } #[derive(Debug, Default)] struct NewName; impl Interface for NewName {} impl INewName::INewName for NewName { fn RealName(&self) -> binder::Result { Ok("NewName".into()) } } #[derive(Debug, Default)] struct Circular; impl Interface for Circular {} impl ICircular::ICircular for Circular { fn GetTestService( &self, ) -> binder::Result>> { Ok(None) } } #[derive(Default)] struct TestService { service_map: Mutex>>, } impl Interface for TestService {} macro_rules! impl_repeat { ($repeat_name:ident, $type:ty) => { fn $repeat_name(&self, token: $type) -> binder::Result<$type> { Ok(token) } }; } macro_rules! impl_reverse { ($reverse_name:ident, $type:ty) => { fn $reverse_name( &self, input: &[$type], repeated: &mut Vec<$type>, ) -> binder::Result> { repeated.clear(); repeated.extend_from_slice(input); Ok(input.iter().rev().cloned().collect()) } }; } macro_rules! impl_repeat_reverse { ($repeat_name:ident, $reverse_name:ident, $type:ty) => { impl_repeat! {$repeat_name, $type} impl_reverse! {$reverse_name, $type} }; } macro_rules! impl_repeat_nullable { ($repeat_nullable_name:ident, $type:ty) => { fn $repeat_nullable_name( &self, input: Option<&[$type]>, ) -> binder::Result>> { Ok(input.map(<[$type]>::to_vec)) } }; } impl ITestService::ITestService for TestService { impl_repeat! {RepeatByte, i8} impl_reverse! {ReverseByte, u8} fn UnimplementedMethod(&self, _: i32) -> binder::Result { // Pretend this method hasn't been implemented Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } fn TestOneway(&self) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_ERROR.into()) } fn Deprecated(&self) -> binder::Result<()> { Ok(()) } impl_repeat_reverse! {RepeatBoolean, ReverseBoolean, bool} impl_repeat_reverse! {RepeatChar, ReverseChar, u16} impl_repeat_reverse! {RepeatInt, ReverseInt, i32} impl_repeat_reverse! {RepeatLong, ReverseLong, i64} impl_repeat_reverse! {RepeatFloat, ReverseFloat, f32} impl_repeat_reverse! {RepeatDouble, ReverseDouble, f64} impl_repeat_reverse! {RepeatByteEnum, ReverseByteEnum, ByteEnum} impl_repeat_reverse! {RepeatIntEnum, ReverseIntEnum, IntEnum} impl_repeat_reverse! {RepeatLongEnum, ReverseLongEnum, LongEnum} impl_reverse! {ReverseString, String} impl_reverse! {ReverseStringList, String} impl_reverse! {ReverseUtf8CppString, String} fn RepeatString(&self, input: &str) -> binder::Result { Ok(input.into()) } fn RepeatUtf8CppString(&self, input: &str) -> binder::Result { Ok(input.into()) } fn GetOtherTestService( &self, name: &str, ) -> binder::Result> { let mut service_map = self.service_map.lock().unwrap(); let other_service = service_map.entry(name.into()).or_insert_with(|| { let named_callback = NamedCallback(name.into()); INamedCallback::BnNamedCallback::new_binder(named_callback, BinderFeatures::default()) }); Ok(other_service.to_owned()) } fn SetOtherTestService( &self, name: &str, service: &binder::Strong, ) -> binder::Result { let mut service_map = self.service_map.lock().unwrap(); if let Some(existing_service) = service_map.get(name) { if existing_service == service { return Ok(true); } } service_map.insert(name.into(), service.clone()); Ok(false) } fn VerifyName( &self, service: &binder::Strong, name: &str, ) -> binder::Result { service.GetName().map(|found_name| found_name == name) } fn GetInterfaceArray( &self, names: &[String], ) -> binder::Result>> { names.iter().map(|name| self.GetOtherTestService(name)).collect() } fn VerifyNamesWithInterfaceArray( &self, services: &[binder::Strong], names: &[String], ) -> binder::Result { if services.len() == names.len() { for (s, n) in services.iter().zip(names) { if !self.VerifyName(s, n)? { return Ok(false); } } Ok(true) } else { Ok(false) } } fn GetNullableInterfaceArray( &self, names: Option<&[Option]>, ) -> binder::Result>>>> { if let Some(names) = names { let mut services = vec![]; for name in names { if let Some(name) = name { services.push(Some(self.GetOtherTestService(name)?)); } else { services.push(None); } } Ok(Some(services)) } else { Ok(None) } } fn VerifyNamesWithNullableInterfaceArray( &self, services: Option<&[Option>]>, names: Option<&[Option]>, ) -> binder::Result { if let (Some(services), Some(names)) = (services, names) { for (s, n) in services.iter().zip(names) { if let (Some(s), Some(n)) = (s, n) { if !self.VerifyName(s, n)? { return Ok(false); } } else if s.is_some() || n.is_some() { return Ok(false); } } Ok(true) } else { Ok(services.is_none() && names.is_none()) } } fn GetInterfaceList( &self, names: Option<&[Option]>, ) -> binder::Result>>>> { self.GetNullableInterfaceArray(names) } fn VerifyNamesWithInterfaceList( &self, services: Option<&[Option>]>, names: Option<&[Option]>, ) -> binder::Result { self.VerifyNamesWithNullableInterfaceArray(services, names) } fn RepeatParcelFileDescriptor( &self, read: &ParcelFileDescriptor, ) -> binder::Result { Ok(dup_fd(read)) } fn ReverseParcelFileDescriptorArray( &self, input: &[ParcelFileDescriptor], repeated: &mut Vec>, ) -> binder::Result> { repeated.clear(); repeated.extend(input.iter().map(dup_fd).map(Some)); Ok(input.iter().rev().map(dup_fd).collect()) } fn ThrowServiceException(&self, code: i32) -> binder::Result<()> { Err(binder::Status::new_service_specific_error(code, None)) } impl_repeat_nullable! {RepeatNullableIntArray, i32} impl_repeat_nullable! {RepeatNullableByteEnumArray, ByteEnum} impl_repeat_nullable! {RepeatNullableIntEnumArray, IntEnum} impl_repeat_nullable! {RepeatNullableLongEnumArray, LongEnum} impl_repeat_nullable! {RepeatNullableStringList, Option} fn RepeatNullableString(&self, input: Option<&str>) -> binder::Result> { Ok(input.map(String::from)) } fn RepeatNullableUtf8CppString(&self, input: Option<&str>) -> binder::Result> { Ok(input.map(String::from)) } fn RepeatNullableParcelable(&self, input: Option<&Empty>) -> binder::Result> { Ok(input.cloned()) } impl_repeat_nullable! {RepeatNullableParcelableArray, Option} impl_repeat_nullable! {RepeatNullableParcelableList, Option} fn TakesAnIBinder(&self, _: &SpIBinder) -> binder::Result<()> { Ok(()) } fn TakesANullableIBinder(&self, _: Option<&SpIBinder>) -> binder::Result<()> { Ok(()) } fn TakesAnIBinderList(&self, _: &[SpIBinder]) -> binder::Result<()> { Ok(()) } fn TakesANullableIBinderList(&self, _: Option<&[Option]>) -> binder::Result<()> { Ok(()) } fn ReverseNullableUtf8CppString( &self, input: Option<&[Option]>, repeated: &mut Option>>, ) -> binder::Result>>> { if let Some(input) = input { *repeated = Some(input.to_vec()); Ok(Some(input.iter().rev().cloned().collect())) } else { // We don't touch `repeated` here, since // the C++ test service doesn't either Ok(None) } } fn ReverseUtf8CppStringList( &self, input: Option<&[Option]>, repeated: &mut Option>>, ) -> binder::Result>>> { self.ReverseNullableUtf8CppString(input, repeated) } fn GetCallback( &self, return_null: bool, ) -> binder::Result>> { if return_null { Ok(None) } else { self.GetOtherTestService("ABT: always be testing").map(Some) } } fn FillOutStructuredParcelable( &self, parcelable: &mut StructuredParcelable::StructuredParcelable, ) -> binder::Result<()> { parcelable.shouldBeJerry = "Jerry".into(); parcelable.shouldContainThreeFs = vec![parcelable.f, parcelable.f, parcelable.f]; parcelable.shouldBeByteBar = ByteEnum::BAR; parcelable.shouldBeIntBar = IntEnum::BAR; parcelable.shouldBeLongBar = LongEnum::BAR; parcelable.shouldContainTwoByteFoos = vec![ByteEnum::FOO, ByteEnum::FOO]; parcelable.shouldContainTwoIntFoos = vec![IntEnum::FOO, IntEnum::FOO]; parcelable.shouldContainTwoLongFoos = vec![LongEnum::FOO, LongEnum::FOO]; parcelable.const_exprs_1 = ConstantExpressionEnum::decInt32_1; parcelable.const_exprs_2 = ConstantExpressionEnum::decInt32_2; parcelable.const_exprs_3 = ConstantExpressionEnum::decInt64_1; parcelable.const_exprs_4 = ConstantExpressionEnum::decInt64_2; parcelable.const_exprs_5 = ConstantExpressionEnum::decInt64_3; parcelable.const_exprs_6 = ConstantExpressionEnum::decInt64_4; parcelable.const_exprs_7 = ConstantExpressionEnum::hexInt32_1; parcelable.const_exprs_8 = ConstantExpressionEnum::hexInt32_2; parcelable.const_exprs_9 = ConstantExpressionEnum::hexInt32_3; parcelable.const_exprs_10 = ConstantExpressionEnum::hexInt64_1; parcelable.shouldSetBit0AndBit2 = StructuredParcelable::BIT0 | StructuredParcelable::BIT2; parcelable.u = Some(Union::Union::Ns(vec![1, 2, 3])); parcelable.shouldBeConstS1 = Some(Union::Union::S(Union::S1.to_string())); Ok(()) } fn RepeatExtendableParcelable( &self, ep: &ExtendableParcelable, ep2: &mut ExtendableParcelable, ) -> binder::Result<()> { ep2.a = ep.a; ep2.b = ep.b.clone(); let my_ext = ep.ext.get_parcelable::()?; if let Some(my_ext) = my_ext { ep2.ext.set_parcelable(my_ext)?; } else { ep2.ext.reset(); } Ok(()) } fn ReverseList(&self, list: &RecursiveList) -> binder::Result { let mut reversed: Option = None; let mut cur: Option<&RecursiveList> = Some(list); while let Some(node) = cur { reversed = Some(RecursiveList { value: node.value, next: reversed.map(Box::new) }); cur = node.next.as_ref().map(|n| n.as_ref()); } // `list` is always not empty, so is `reversed`. Ok(reversed.unwrap()) } fn ReverseIBinderArray( &self, input: &[SpIBinder], repeated: &mut Vec>, ) -> binder::Result> { *repeated = input.iter().cloned().map(Some).collect(); Ok(input.iter().rev().cloned().collect()) } fn ReverseNullableIBinderArray( &self, input: Option<&[Option]>, repeated: &mut Option>>, ) -> binder::Result>>> { let input = input.expect("input is null"); *repeated = Some(input.to_vec()); Ok(Some(input.iter().rev().cloned().collect())) } fn RepeatSimpleParcelable( &self, input: &SimpleParcelable, repeat: &mut SimpleParcelable, ) -> binder::Result { *repeat = input.clone(); Ok(input.clone()) } fn ReverseSimpleParcelables( &self, input: &[SimpleParcelable], repeated: &mut Vec, ) -> binder::Result> { *repeated = input.to_vec(); Ok(input.iter().rev().cloned().collect()) } fn GetOldNameInterface(&self) -> binder::Result> { Ok(IOldName::BnOldName::new_binder(OldName, BinderFeatures::default())) } fn GetNewNameInterface(&self) -> binder::Result> { Ok(INewName::BnNewName::new_binder(NewName, BinderFeatures::default())) } fn GetUnionTags(&self, input: &[Union::Union]) -> binder::Result> { Ok(input .iter() .map(|u| match u { Union::Union::Ns(_) => Union::Tag::Tag::ns, Union::Union::N(_) => Union::Tag::Tag::n, Union::Union::M(_) => Union::Tag::Tag::m, Union::Union::S(_) => Union::Tag::Tag::s, Union::Union::Ibinder(_) => Union::Tag::Tag::ibinder, Union::Union::Ss(_) => Union::Tag::Tag::ss, Union::Union::Be(_) => Union::Tag::Tag::be, }) .collect::>()) } fn GetCppJavaTests(&self) -> binder::Result> { Ok(None) } fn getBackendType(&self) -> binder::Result { Ok(BackendType::RUST) } fn GetCircular( &self, _: &mut CircularParcelable, ) -> binder::Result> { Ok(ICircular::BnCircular::new_binder(Circular, BinderFeatures::default())) } } struct FooInterface; impl Interface for FooInterface {} impl IFooInterface::IFooInterface for FooInterface { fn originalApi(&self) -> binder::Result<()> { Ok(()) } fn acceptUnionAndReturnString(&self, u: &BazUnion) -> binder::Result { match u { BazUnion::IntNum(n) => Ok(n.to_string()), } } fn returnsLengthOfFooArray(&self, foos: &[Foo]) -> binder::Result { Ok(foos.len() as i32) } fn ignoreParcelablesAndRepeatInt( &self, _in_foo: &Foo, _inout_foo: &mut Foo, _out_foo: &mut Foo, value: i32, ) -> binder::Result { Ok(value) } } struct TrunkStableTest; impl Interface for TrunkStableTest {} impl ITrunkStableTest::ITrunkStableTest for TrunkStableTest { fn repeatParcelable(&self, in_parcel: &MyParcelable) -> binder::Result { let tmp: MyParcelable = MyParcelable { a: in_parcel.a, b: in_parcel.b, c: in_parcel.c }; Ok(tmp) } fn repeatEnum(&self, in_enum: MyEnum) -> binder::Result { Ok(in_enum) } fn repeatUnion(&self, in_union: &MyUnion) -> binder::Result { match in_union { MyUnion::A(n) => Ok(MyUnion::A(*n)), MyUnion::B(n) => Ok(MyUnion::B(*n)), MyUnion::C(n) => Ok(MyUnion::C(*n)), } } fn repeatOtherParcelable( &self, in_parcel: &MyOtherParcelable, ) -> binder::Result { let tmp: MyOtherParcelable = MyOtherParcelable { a: in_parcel.a, b: in_parcel.b }; Ok(tmp) } fn callMyCallback( &self, _in_cb: &binder::Strong, ) -> binder::Result<()> { let p1 = MyParcelable::default(); let _ = _in_cb.repeatParcelable(&p1); let e1 = MyEnum::THREE; let _ = _in_cb.repeatEnum(e1); let u1 = MyUnion::A(12); let _ = _in_cb.repeatUnion(&u1); let o1 = MyOtherParcelable::default(); // expected to fail when not using the frozen version let _ = _in_cb.repeatOtherParcelable(&o1); Ok(()) } } struct NestedService; impl Interface for NestedService {} impl INestedService::INestedService for NestedService { fn flipStatus( &self, p: &ParcelableWithNested::ParcelableWithNested, ) -> binder::Result { if p.status == ParcelableWithNested::Status::Status::OK { Ok(INestedService::Result::Result { status: ParcelableWithNested::Status::Status::NOT_OK, }) } else { Ok(INestedService::Result::Result { status: ParcelableWithNested::Status::Status::OK }) } } fn flipStatusWithCallback( &self, st: ParcelableWithNested::Status::Status, cb: &binder::Strong, ) -> binder::Result<()> { if st == ParcelableWithNested::Status::Status::OK { cb.done(ParcelableWithNested::Status::Status::NOT_OK) } else { cb.done(ParcelableWithNested::Status::Status::OK) } } } struct FixedSizeArrayService; impl Interface for FixedSizeArrayService {} impl IRepeatFixedSizeArray::IRepeatFixedSizeArray for FixedSizeArrayService { fn RepeatBytes(&self, input: &[u8; 3], repeated: &mut [u8; 3]) -> binder::Result<[u8; 3]> { *repeated = *input; Ok(*input) } fn RepeatInts(&self, input: &[i32; 3], repeated: &mut [i32; 3]) -> binder::Result<[i32; 3]> { *repeated = *input; Ok(*input) } fn RepeatBinders( &self, input: &[SpIBinder; 3], repeated: &mut [Option; 3], ) -> binder::Result<[SpIBinder; 3]> { *repeated = input.clone().map(Some); Ok(input.clone()) } fn RepeatParcelables( &self, input: &[IntParcelable; 3], repeated: &mut [IntParcelable; 3], ) -> binder::Result<[IntParcelable; 3]> { *repeated = *input; Ok(*input) } fn Repeat2dBytes( &self, input: &[[u8; 3]; 2], repeated: &mut [[u8; 3]; 2], ) -> binder::Result<[[u8; 3]; 2]> { *repeated = *input; Ok(*input) } fn Repeat2dInts( &self, input: &[[i32; 3]; 2], repeated: &mut [[i32; 3]; 2], ) -> binder::Result<[[i32; 3]; 2]> { *repeated = *input; Ok(*input) } fn Repeat2dBinders( &self, input: &[[SpIBinder; 3]; 2], repeated: &mut [[Option; 3]; 2], ) -> binder::Result<[[SpIBinder; 3]; 2]> { *repeated = input.clone().map(|nested| nested.map(Some)); Ok(input.clone()) } fn Repeat2dParcelables( &self, input: &[[IntParcelable; 3]; 2], repeated: &mut [[IntParcelable; 3]; 2], ) -> binder::Result<[[IntParcelable; 3]; 2]> { *repeated = *input; Ok(*input) } } fn main() { binder::ProcessState::set_thread_pool_max_thread_count(0); binder::ProcessState::start_thread_pool(); let service_name = ::get_descriptor(); let service = BnTestService::new_binder(TestService::default(), BinderFeatures::default()); binder::add_service(service_name, service.as_binder()).expect("Could not register service"); let versioned_service_name = ::get_descriptor(); let versioned_service = BnFooInterface::new_binder(FooInterface, BinderFeatures::default()); binder::add_service(versioned_service_name, versioned_service.as_binder()) .expect("Could not register service"); let nested_service_name = ::get_descriptor(); let nested_service = INestedService::BnNestedService::new_binder(NestedService, BinderFeatures::default()); binder::add_service(nested_service_name, nested_service.as_binder()) .expect("Could not register service"); let fixed_size_array_service_name = ::get_descriptor(); let fixed_size_array_service = IRepeatFixedSizeArray::BnRepeatFixedSizeArray::new_binder( FixedSizeArrayService, BinderFeatures::default(), ); binder::add_service(fixed_size_array_service_name, fixed_size_array_service.as_binder()) .expect("Could not register service"); let trunk_stable_service_name = ::get_descriptor(); let trunk_stable_service = BnTrunkStableTest::new_binder(TrunkStableTest, BinderFeatures::default()); binder::add_service(trunk_stable_service_name, trunk_stable_service.as_binder()) .expect("Could not register service"); binder::ProcessState::join_thread_pool(); } ./PaxHeaders.X/tests_rust_test_service_async.rs0100644 0000000 0000000 00000000034 15172120304 021035 xustar000000000 0000000 28 mtime=1776853188.7860000 tests/rust/test_service_async.rs0100644 0000000 0000000 00000065306 15172120304 016213 0ustar000000000 0000000 /* * Copyright (C) 2022, 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. */ //! Test Rust service for the AIDL compiler. use aidl_test_fixedsizearray::aidl::android::aidl::fixedsizearray::FixedSizeArrayExample::{ IRepeatFixedSizeArray, IntParcelable::IntParcelable, }; use aidl_test_interface::aidl::android::aidl::tests::nested::{ INestedService, ParcelableWithNested, }; use aidl_test_interface::aidl::android::aidl::tests::ITestService::{ self, BnTestService, BpTestService, Empty::Empty, }; use aidl_test_interface::aidl::android::aidl::tests::{ extension::ExtendableParcelable::ExtendableParcelable, extension::MyExt::MyExt, BackendType::BackendType, ByteEnum::ByteEnum, CircularParcelable::CircularParcelable, ConstantExpressionEnum::ConstantExpressionEnum, ICircular, INamedCallback, INewName, IOldName, IntEnum::IntEnum, LongEnum::LongEnum, RecursiveList::RecursiveList, StructuredParcelable, Union, }; use aidl_test_interface::binder::{ self, BinderFeatures, Interface, ParcelFileDescriptor, SpIBinder, }; use aidl_test_versioned_interface::aidl::android::aidl::versioned::tests::{ BazUnion::BazUnion, Foo::Foo, IFooInterface, IFooInterface::BnFooInterface, IFooInterface::BpFooInterface, }; use android_aidl_test_trunk::aidl::android::aidl::test::trunk::{ ITrunkStableTest, ITrunkStableTest::BnTrunkStableTest, ITrunkStableTest::BpTrunkStableTest, ITrunkStableTest::IMyCallback, ITrunkStableTest::MyEnum::MyEnum, ITrunkStableTest::MyOtherParcelable::MyOtherParcelable, ITrunkStableTest::MyParcelable::MyParcelable, ITrunkStableTest::MyUnion::MyUnion, }; use binder_tokio::Tokio; use simple_parcelable::SimpleParcelable; use std::collections::HashMap; use std::sync::Mutex; use async_trait::async_trait; fn dup_fd(fd: &ParcelFileDescriptor) -> ParcelFileDescriptor { ParcelFileDescriptor::new(fd.as_ref().try_clone().unwrap()) } struct NamedCallback(String); impl Interface for NamedCallback {} #[async_trait] impl INamedCallback::INamedCallbackAsyncServer for NamedCallback { async fn GetName(&self) -> binder::Result { Ok(self.0.clone()) } } struct OldName; impl Interface for OldName {} #[async_trait] impl IOldName::IOldNameAsyncServer for OldName { async fn RealName(&self) -> binder::Result { Ok("OldName".into()) } } #[derive(Debug, Default)] struct NewName; impl Interface for NewName {} #[async_trait] impl INewName::INewNameAsyncServer for NewName { async fn RealName(&self) -> binder::Result { Ok("NewName".into()) } } #[derive(Debug, Default)] struct Circular; impl Interface for Circular {} #[async_trait] impl ICircular::ICircularAsyncServer for Circular { async fn GetTestService( &self, ) -> binder::Result>> { Ok(None) } } #[derive(Default)] struct TestService { service_map: Mutex>>, } impl Interface for TestService {} // Macros are expanded in the wrong order, so async_trait does not apply to // functions defined by declarative macros. type BoxFuture<'a, T> = std::pin::Pin + Send + 'a>>; macro_rules! impl_repeat { ($repeat_name:ident, $type:ty) => { fn $repeat_name<'a, 'b>(&'a self, token: $type) -> BoxFuture<'b, binder::Result<$type>> where 'a: 'b, Self: 'b, { Box::pin(async move { Ok(token) }) } }; } macro_rules! impl_reverse { ($reverse_name:ident, $type:ty) => { fn $reverse_name<'a, 'b, 'c, 'd>( &'a self, input: &'b [$type], repeated: &'c mut Vec<$type>, ) -> BoxFuture<'d, binder::Result>> where 'a: 'd, 'b: 'd, 'c: 'd, Self: 'd, { Box::pin(async move { repeated.clear(); repeated.extend_from_slice(input); Ok(input.iter().rev().cloned().collect()) }) } }; } macro_rules! impl_repeat_reverse { ($repeat_name:ident, $reverse_name:ident, $type:ty) => { impl_repeat! {$repeat_name, $type} impl_reverse! {$reverse_name, $type} }; } macro_rules! impl_repeat_nullable { ($repeat_nullable_name:ident, $type:ty) => { fn $repeat_nullable_name<'a, 'b, 'c>( &'a self, input: Option<&'b [$type]>, ) -> BoxFuture<'c, binder::Result>>> where 'a: 'c, 'b: 'c, Self: 'c, { Box::pin(async move { Ok(input.map(<[$type]>::to_vec)) }) } }; } #[async_trait] impl ITestService::ITestServiceAsyncServer for TestService { impl_repeat! {RepeatByte, i8} impl_reverse! {ReverseByte, u8} async fn UnimplementedMethod(&self, _: i32) -> binder::Result { // Pretend this method hasn't been implemented Err(binder::StatusCode::UNKNOWN_TRANSACTION.into()) } async fn TestOneway(&self) -> binder::Result<()> { Err(binder::StatusCode::UNKNOWN_ERROR.into()) } async fn Deprecated(&self) -> binder::Result<()> { Ok(()) } impl_repeat_reverse! {RepeatBoolean, ReverseBoolean, bool} impl_repeat_reverse! {RepeatChar, ReverseChar, u16} impl_repeat_reverse! {RepeatInt, ReverseInt, i32} impl_repeat_reverse! {RepeatLong, ReverseLong, i64} impl_repeat_reverse! {RepeatFloat, ReverseFloat, f32} impl_repeat_reverse! {RepeatDouble, ReverseDouble, f64} impl_repeat_reverse! {RepeatByteEnum, ReverseByteEnum, ByteEnum} impl_repeat_reverse! {RepeatIntEnum, ReverseIntEnum, IntEnum} impl_repeat_reverse! {RepeatLongEnum, ReverseLongEnum, LongEnum} impl_reverse! {ReverseString, String} impl_reverse! {ReverseStringList, String} impl_reverse! {ReverseUtf8CppString, String} async fn RepeatString(&self, input: &str) -> binder::Result { Ok(input.into()) } async fn RepeatUtf8CppString(&self, input: &str) -> binder::Result { Ok(input.into()) } async fn GetOtherTestService( &self, name: &str, ) -> binder::Result> { let mut service_map = self.service_map.lock().unwrap(); let other_service = service_map.entry(name.into()).or_insert_with(|| { let named_callback = NamedCallback(name.into()); INamedCallback::BnNamedCallback::new_async_binder( named_callback, rt(), BinderFeatures::default(), ) }); Ok(other_service.to_owned()) } async fn SetOtherTestService( &self, name: &str, service: &binder::Strong, ) -> binder::Result { let mut service_map = self.service_map.lock().unwrap(); if let Some(existing_service) = service_map.get(name) { if existing_service == service { return Ok(true); } } service_map.insert(name.into(), service.clone()); Ok(false) } async fn VerifyName( &self, service: &binder::Strong, name: &str, ) -> binder::Result { service.clone().into_async::().GetName().await.map(|found_name| found_name == name) } async fn GetInterfaceArray( &self, names: &[String], ) -> binder::Result>> { let mut res = Vec::new(); for name in names { res.push(self.GetOtherTestService(name).await?); } Ok(res) } async fn VerifyNamesWithInterfaceArray( &self, services: &[binder::Strong], names: &[String], ) -> binder::Result { if services.len() == names.len() { for (s, n) in services.iter().zip(names) { if !self.VerifyName(s, n).await? { return Ok(false); } } Ok(true) } else { Ok(false) } } async fn GetNullableInterfaceArray( &self, names: Option<&[Option]>, ) -> binder::Result>>>> { if let Some(names) = names { let mut services = vec![]; for name in names { if let Some(name) = name { services.push(Some(self.GetOtherTestService(name).await?)); } else { services.push(None); } } Ok(Some(services)) } else { Ok(None) } } async fn VerifyNamesWithNullableInterfaceArray( &self, services: Option<&[Option>]>, names: Option<&[Option]>, ) -> binder::Result { if let (Some(services), Some(names)) = (services, names) { for (s, n) in services.iter().zip(names) { if let (Some(s), Some(n)) = (s, n) { if !self.VerifyName(s, n).await? { return Ok(false); } } else if s.is_some() || n.is_some() { return Ok(false); } } Ok(true) } else { Ok(services.is_none() && names.is_none()) } } async fn GetInterfaceList( &self, names: Option<&[Option]>, ) -> binder::Result>>>> { self.GetNullableInterfaceArray(names).await } async fn VerifyNamesWithInterfaceList( &self, services: Option<&[Option>]>, names: Option<&[Option]>, ) -> binder::Result { self.VerifyNamesWithNullableInterfaceArray(services, names).await } async fn RepeatParcelFileDescriptor( &self, read: &ParcelFileDescriptor, ) -> binder::Result { Ok(dup_fd(read)) } async fn ReverseParcelFileDescriptorArray( &self, input: &[ParcelFileDescriptor], repeated: &mut Vec>, ) -> binder::Result> { repeated.clear(); repeated.extend(input.iter().map(dup_fd).map(Some)); Ok(input.iter().rev().map(dup_fd).collect()) } async fn ThrowServiceException(&self, code: i32) -> binder::Result<()> { Err(binder::Status::new_service_specific_error(code, None)) } impl_repeat_nullable! {RepeatNullableIntArray, i32} impl_repeat_nullable! {RepeatNullableByteEnumArray, ByteEnum} impl_repeat_nullable! {RepeatNullableIntEnumArray, IntEnum} impl_repeat_nullable! {RepeatNullableLongEnumArray, LongEnum} impl_repeat_nullable! {RepeatNullableStringList, Option} async fn RepeatNullableString(&self, input: Option<&str>) -> binder::Result> { Ok(input.map(String::from)) } async fn RepeatNullableUtf8CppString( &self, input: Option<&str>, ) -> binder::Result> { Ok(input.map(String::from)) } async fn RepeatNullableParcelable( &self, input: Option<&Empty>, ) -> binder::Result> { Ok(input.cloned()) } impl_repeat_nullable! {RepeatNullableParcelableArray, Option} impl_repeat_nullable! {RepeatNullableParcelableList, Option} async fn TakesAnIBinder(&self, _: &SpIBinder) -> binder::Result<()> { Ok(()) } async fn TakesANullableIBinder(&self, _: Option<&SpIBinder>) -> binder::Result<()> { Ok(()) } async fn TakesAnIBinderList(&self, _: &[SpIBinder]) -> binder::Result<()> { Ok(()) } async fn TakesANullableIBinderList( &self, _: Option<&[Option]>, ) -> binder::Result<()> { Ok(()) } async fn ReverseNullableUtf8CppString( &self, input: Option<&[Option]>, repeated: &mut Option>>, ) -> binder::Result>>> { if let Some(input) = input { *repeated = Some(input.to_vec()); Ok(Some(input.iter().rev().cloned().collect())) } else { // We don't touch `repeated` here, since // the C++ test service doesn't either Ok(None) } } async fn ReverseUtf8CppStringList( &self, input: Option<&[Option]>, repeated: &mut Option>>, ) -> binder::Result>>> { self.ReverseNullableUtf8CppString(input, repeated).await } async fn GetCallback( &self, return_null: bool, ) -> binder::Result>> { if return_null { Ok(None) } else { self.GetOtherTestService("ABT: always be testing").await.map(Some) } } async fn FillOutStructuredParcelable( &self, parcelable: &mut StructuredParcelable::StructuredParcelable, ) -> binder::Result<()> { parcelable.shouldBeJerry = "Jerry".into(); parcelable.shouldContainThreeFs = vec![parcelable.f, parcelable.f, parcelable.f]; parcelable.shouldBeByteBar = ByteEnum::BAR; parcelable.shouldBeIntBar = IntEnum::BAR; parcelable.shouldBeLongBar = LongEnum::BAR; parcelable.shouldContainTwoByteFoos = vec![ByteEnum::FOO, ByteEnum::FOO]; parcelable.shouldContainTwoIntFoos = vec![IntEnum::FOO, IntEnum::FOO]; parcelable.shouldContainTwoLongFoos = vec![LongEnum::FOO, LongEnum::FOO]; parcelable.const_exprs_1 = ConstantExpressionEnum::decInt32_1; parcelable.const_exprs_2 = ConstantExpressionEnum::decInt32_2; parcelable.const_exprs_3 = ConstantExpressionEnum::decInt64_1; parcelable.const_exprs_4 = ConstantExpressionEnum::decInt64_2; parcelable.const_exprs_5 = ConstantExpressionEnum::decInt64_3; parcelable.const_exprs_6 = ConstantExpressionEnum::decInt64_4; parcelable.const_exprs_7 = ConstantExpressionEnum::hexInt32_1; parcelable.const_exprs_8 = ConstantExpressionEnum::hexInt32_2; parcelable.const_exprs_9 = ConstantExpressionEnum::hexInt32_3; parcelable.const_exprs_10 = ConstantExpressionEnum::hexInt64_1; parcelable.shouldSetBit0AndBit2 = StructuredParcelable::BIT0 | StructuredParcelable::BIT2; parcelable.u = Some(Union::Union::Ns(vec![1, 2, 3])); parcelable.shouldBeConstS1 = Some(Union::Union::S(Union::S1.to_string())); Ok(()) } async fn RepeatExtendableParcelable( &self, ep: &ExtendableParcelable, ep2: &mut ExtendableParcelable, ) -> binder::Result<()> { ep2.a = ep.a; ep2.b = ep.b.clone(); let my_ext = ep.ext.get_parcelable::()?; if let Some(my_ext) = my_ext { ep2.ext.set_parcelable(my_ext)?; } else { ep2.ext.reset(); } Ok(()) } async fn ReverseList(&self, list: &RecursiveList) -> binder::Result { let mut reversed: Option = None; let mut cur: Option<&RecursiveList> = Some(list); while let Some(node) = cur { reversed = Some(RecursiveList { value: node.value, next: reversed.map(Box::new) }); cur = node.next.as_ref().map(|n| n.as_ref()); } // `list` is always not empty, so is `reversed`. Ok(reversed.unwrap()) } async fn ReverseIBinderArray( &self, input: &[SpIBinder], repeated: &mut Vec>, ) -> binder::Result> { *repeated = input.iter().cloned().map(Some).collect(); Ok(input.iter().rev().cloned().collect()) } async fn ReverseNullableIBinderArray( &self, input: Option<&[Option]>, repeated: &mut Option>>, ) -> binder::Result>>> { let input = input.expect("input is null"); *repeated = Some(input.to_vec()); Ok(Some(input.iter().rev().cloned().collect())) } async fn RepeatSimpleParcelable( &self, input: &SimpleParcelable, repeat: &mut SimpleParcelable, ) -> binder::Result { *repeat = input.clone(); Ok(input.clone()) } async fn ReverseSimpleParcelables( &self, input: &[SimpleParcelable], repeated: &mut Vec, ) -> binder::Result> { *repeated = input.to_vec(); Ok(input.iter().rev().cloned().collect()) } async fn GetOldNameInterface(&self) -> binder::Result> { Ok(IOldName::BnOldName::new_async_binder(OldName, rt(), BinderFeatures::default())) } async fn GetNewNameInterface(&self) -> binder::Result> { Ok(INewName::BnNewName::new_async_binder(NewName, rt(), BinderFeatures::default())) } async fn GetUnionTags(&self, input: &[Union::Union]) -> binder::Result> { Ok(input .iter() .map(|u| match u { Union::Union::Ns(_) => Union::Tag::Tag::ns, Union::Union::N(_) => Union::Tag::Tag::n, Union::Union::M(_) => Union::Tag::Tag::m, Union::Union::S(_) => Union::Tag::Tag::s, Union::Union::Ibinder(_) => Union::Tag::Tag::ibinder, Union::Union::Ss(_) => Union::Tag::Tag::ss, Union::Union::Be(_) => Union::Tag::Tag::be, }) .collect::>()) } async fn GetCppJavaTests(&self) -> binder::Result> { Ok(None) } async fn getBackendType(&self) -> binder::Result { Ok(BackendType::RUST) } async fn GetCircular( &self, _: &mut CircularParcelable, ) -> binder::Result> { Ok(ICircular::BnCircular::new_async_binder(Circular, rt(), BinderFeatures::default())) } } struct FooInterface; impl Interface for FooInterface {} #[async_trait] impl IFooInterface::IFooInterfaceAsyncServer for FooInterface { async fn originalApi(&self) -> binder::Result<()> { Ok(()) } async fn acceptUnionAndReturnString(&self, u: &BazUnion) -> binder::Result { match u { BazUnion::IntNum(n) => Ok(n.to_string()), } } async fn returnsLengthOfFooArray(&self, foos: &[Foo]) -> binder::Result { Ok(foos.len() as i32) } async fn ignoreParcelablesAndRepeatInt( &self, _in_foo: &Foo, _inout_foo: &mut Foo, _out_foo: &mut Foo, value: i32, ) -> binder::Result { Ok(value) } } struct TrunkStableTest; impl Interface for TrunkStableTest {} #[async_trait] impl ITrunkStableTest::ITrunkStableTestAsyncServer for TrunkStableTest { async fn repeatParcelable(&self, in_parcel: &MyParcelable) -> binder::Result { let tmp: MyParcelable = MyParcelable { a: in_parcel.a, b: in_parcel.b, c: in_parcel.c }; Ok(tmp) } async fn repeatEnum(&self, in_enum: MyEnum) -> binder::Result { Ok(in_enum) } async fn repeatUnion(&self, in_union: &MyUnion) -> binder::Result { match in_union { MyUnion::A(n) => Ok(MyUnion::A(*n)), MyUnion::B(n) => Ok(MyUnion::B(*n)), MyUnion::C(n) => Ok(MyUnion::C(*n)), } } async fn repeatOtherParcelable( &self, in_parcel: &MyOtherParcelable, ) -> binder::Result { let tmp: MyOtherParcelable = MyOtherParcelable { a: in_parcel.a, b: in_parcel.b }; Ok(tmp) } async fn callMyCallback( &self, _in_cb: &binder::Strong, ) -> binder::Result<()> { let p1 = MyParcelable::default(); let _ = _in_cb.repeatParcelable(&p1); let e1 = MyEnum::THREE; let _ = _in_cb.repeatEnum(e1); let u1 = MyUnion::A(12); let _ = _in_cb.repeatUnion(&u1); let o1 = MyOtherParcelable::default(); // expected to fail when not using the frozen version let _ = _in_cb.repeatOtherParcelable(&o1); Ok(()) } } struct NestedService; impl Interface for NestedService {} #[async_trait] impl INestedService::INestedServiceAsyncServer for NestedService { async fn flipStatus( &self, p: &ParcelableWithNested::ParcelableWithNested, ) -> binder::Result { if p.status == ParcelableWithNested::Status::Status::OK { Ok(INestedService::Result::Result { status: ParcelableWithNested::Status::Status::NOT_OK, }) } else { Ok(INestedService::Result::Result { status: ParcelableWithNested::Status::Status::OK }) } } async fn flipStatusWithCallback( &self, st: ParcelableWithNested::Status::Status, cb: &binder::Strong, ) -> binder::Result<()> { if st == ParcelableWithNested::Status::Status::OK { cb.done(ParcelableWithNested::Status::Status::NOT_OK) } else { cb.done(ParcelableWithNested::Status::Status::OK) } } } struct FixedSizeArrayService; impl Interface for FixedSizeArrayService {} #[async_trait] impl IRepeatFixedSizeArray::IRepeatFixedSizeArrayAsyncServer for FixedSizeArrayService { async fn RepeatBytes( &self, input: &[u8; 3], repeated: &mut [u8; 3], ) -> binder::Result<[u8; 3]> { *repeated = *input; Ok(*input) } async fn RepeatInts( &self, input: &[i32; 3], repeated: &mut [i32; 3], ) -> binder::Result<[i32; 3]> { *repeated = *input; Ok(*input) } async fn RepeatBinders( &self, input: &[SpIBinder; 3], repeated: &mut [Option; 3], ) -> binder::Result<[SpIBinder; 3]> { *repeated = input.clone().map(Some); Ok(input.clone()) } async fn RepeatParcelables( &self, input: &[IntParcelable; 3], repeated: &mut [IntParcelable; 3], ) -> binder::Result<[IntParcelable; 3]> { *repeated = *input; Ok(*input) } async fn Repeat2dBytes( &self, input: &[[u8; 3]; 2], repeated: &mut [[u8; 3]; 2], ) -> binder::Result<[[u8; 3]; 2]> { *repeated = *input; Ok(*input) } async fn Repeat2dInts( &self, input: &[[i32; 3]; 2], repeated: &mut [[i32; 3]; 2], ) -> binder::Result<[[i32; 3]; 2]> { *repeated = *input; Ok(*input) } async fn Repeat2dBinders( &self, input: &[[SpIBinder; 3]; 2], repeated: &mut [[Option; 3]; 2], ) -> binder::Result<[[SpIBinder; 3]; 2]> { *repeated = input.clone().map(|nested| nested.map(Some)); Ok(input.clone()) } async fn Repeat2dParcelables( &self, input: &[[IntParcelable; 3]; 2], repeated: &mut [[IntParcelable; 3]; 2], ) -> binder::Result<[[IntParcelable; 3]; 2]> { *repeated = *input; Ok(*input) } } fn rt() -> binder_tokio::TokioRuntime { binder_tokio::TokioRuntime(tokio::runtime::Handle::current()) } fn main() { binder::ProcessState::set_thread_pool_max_thread_count(0); binder::ProcessState::start_thread_pool(); let runtime = tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap(); runtime.block_on(async { let service_name = ::get_descriptor(); let service = BnTestService::new_async_binder(TestService::default(), rt(), BinderFeatures::default()); binder::add_service(service_name, service.as_binder()).expect("Could not register service"); let versioned_service_name = ::get_descriptor(); let versioned_service = BnFooInterface::new_async_binder(FooInterface, rt(), BinderFeatures::default()); binder::add_service(versioned_service_name, versioned_service.as_binder()) .expect("Could not register service"); let nested_service_name = ::get_descriptor(); let nested_service = INestedService::BnNestedService::new_async_binder( NestedService, rt(), BinderFeatures::default(), ); binder::add_service(nested_service_name, nested_service.as_binder()) .expect("Could not register service"); let fixed_size_array_service_name = ::get_descriptor(); let fixed_size_array_service = IRepeatFixedSizeArray::BnRepeatFixedSizeArray::new_async_binder( FixedSizeArrayService, rt(), BinderFeatures::default(), ); binder::add_service(fixed_size_array_service_name, fixed_size_array_service.as_binder()) .expect("Could not register service"); let trunk_stable_service_name = ::get_descriptor(); let trunk_stable_service = BnTrunkStableTest::new_async_binder( TrunkStableTest, rt(), BinderFeatures::default() ); binder::add_service(trunk_stable_service_name, trunk_stable_service.as_binder()) .expect("Could not register service"); // By awaiting `pending`, we yield to the runtime. This results in the current-thread // runtime being driven by the current thread (the main thread in this case). E.g., this // means that anything spawned with `tokio::spawn` will run on this thread. std::future::pending().await }) } ./PaxHeaders.X/tests_simple_parcelable.cpp0100644 0000000 0000000 00000000034 15172120304 017665 xustar000000000 0000000 28 mtime=1776853188.7870000 tests/simple_parcelable.cpp0100644 0000000 0000000 00000003074 15172120304 015115 0ustar000000000 0000000 /* * Copyright (C) 2015 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 "tests/simple_parcelable.h" #include #include #include using android::base::StringPrintf; namespace android { namespace aidl { namespace tests { SimpleParcelable::SimpleParcelable(const std::string& name, int32_t number) : name_(name.c_str(), name.length()), number_(number) {} status_t SimpleParcelable::writeToParcel(Parcel* parcel) const { status_t status = parcel->writeString16(name_); if (status != OK) { return status; } status = parcel->writeInt32(number_); return status; } status_t SimpleParcelable::readFromParcel(const Parcel* parcel) { status_t status = parcel->readString16(&name_); if (status != OK) { return status; } return parcel->readInt32(&number_); } std::string SimpleParcelable::toString() const { return StringPrintf("%s(%d)", String8(name_).c_str(), number_); } } // namespace tests } // namespace aidl } // namespace android ./PaxHeaders.X/tests_simple_parcelable.h0100644 0000000 0000000 00000000034 15172120304 017332 xustar000000000 0000000 28 mtime=1776853188.7870000 tests/simple_parcelable.h0100644 0000000 0000000 00000004355 15172120304 014565 0ustar000000000 0000000 /* * Copyright (C) 2015 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. */ #ifndef AIDL_TESTS_SIMPLE_PARCELABLE_H_ #define AIDL_TESTS_SIMPLE_PARCELABLE_H_ #include #include #include #include #include namespace android { namespace aidl { namespace tests { class SimpleParcelable : public Parcelable { public: SimpleParcelable() = default; SimpleParcelable(const std::string& name, int32_t number); virtual ~SimpleParcelable() = default; // Write |this| parcelable to the given |parcel|. Keep in mind that // implementations of writeToParcel must be manually kept in sync // with readFromParcel and the Java equivalent versions of these methods. // // Returns android::OK on success and an appropriate error otherwise. status_t writeToParcel(Parcel* parcel) const override; // Read data from the given |parcel| into |this|. After readFromParcel // completes, |this| should have equivalent state to the object that // wrote itself to the parcel. // // Returns android::OK on success and an appropriate error otherwise. status_t readFromParcel(const Parcel* parcel) override; std::string toString() const; friend bool operator==(const SimpleParcelable& lhs, const SimpleParcelable& rhs) { return (lhs.name_ == rhs.name_) && (lhs.number_ == rhs.number_); } friend bool operator!=(const SimpleParcelable& lhs, const SimpleParcelable& rhs) { return !(lhs == rhs); } private: String16 name_; int32_t number_ = 0; }; // class SimpleParcelable } // namespace tests } // namespace aidl } // namespace android #endif // AIDL_TESTS_SIMPLE_PARCELABLE_H_ ./PaxHeaders.X/tests_simple_parcelable_ndk.cpp0100644 0000000 0000000 00000000034 15172120304 020521 xustar000000000 0000000 28 mtime=1776853188.7870000 tests/simple_parcelable_ndk.cpp0100644 0000000 0000000 00000003357 15172120304 015755 0ustar000000000 0000000 /* * Copyright (C) 2023 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 "tests/simple_parcelable_ndk.h" #include #include #include using android::base::StringPrintf; using ndk::AParcel_readString; using ndk::AParcel_writeString; namespace aidl { namespace android { namespace aidl { namespace tests { SimpleParcelable::SimpleParcelable(const std::string& name, int32_t number) : name_(name), number_(number) {} binder_status_t SimpleParcelable::writeToParcel(AParcel* _Nonnull parcel) const { binder_status_t status = AParcel_writeString(parcel, name_); if (status != STATUS_OK) { return status; } status = AParcel_writeInt32(parcel, number_); return status; } binder_status_t SimpleParcelable::readFromParcel(const AParcel* _Nonnull parcel) { binder_status_t status = AParcel_readString(parcel, &name_); if (status != STATUS_OK) { return status; } return AParcel_readInt32(parcel, &number_); } std::string SimpleParcelable::toString() const { return StringPrintf("%s(%d)", name_.c_str(), number_); } } // namespace tests } // namespace aidl } // namespace android } // namespace aidl ./PaxHeaders.X/tests_simple_parcelable_ndk.h0100644 0000000 0000000 00000000034 15172120304 020166 xustar000000000 0000000 28 mtime=1776853188.7870000 tests/simple_parcelable_ndk.h0100644 0000000 0000000 00000004321 15172120304 015412 0ustar000000000 0000000 /* * Copyright (C) 2023 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. */ #ifndef AIDL_TESTS_SIMPLE_PARCELABLE_NDK_H_ #define AIDL_TESTS_SIMPLE_PARCELABLE_NDK_H_ #include #include #include #include namespace aidl { namespace android { namespace aidl { namespace tests { class SimpleParcelable { public: SimpleParcelable() = default; SimpleParcelable(const std::string& name, int32_t number); virtual ~SimpleParcelable() = default; // Write |this| parcelable to the given |parcel|. Keep in mind that // implementations of writeToParcel must be manually kept in sync // with readFromParcel and the Java equivalent versions of these methods. // // Returns android::OK on success and an appropriate error otherwise. binder_status_t writeToParcel(AParcel* _Nonnull parcel) const; // Read data from the given |parcel| into |this|. After readFromParcel // completes, |this| should have equivalent state to the object that // wrote itself to the parcel. // // Returns android::OK on success and an appropriate error otherwise. binder_status_t readFromParcel(const AParcel* _Nonnull parcel); std::string toString() const; friend bool operator==(const SimpleParcelable& lhs, const SimpleParcelable& rhs) { return (lhs.name_ == rhs.name_) && (lhs.number_ == rhs.number_); } friend bool operator!=(const SimpleParcelable& lhs, const SimpleParcelable& rhs) { return !(lhs == rhs); } private: std::string name_; int32_t number_ = 0; }; // class SimpleParcelable } // namespace tests } // namespace aidl } // namespace android } // namespace aidl #endif // AIDL_TESTS_SIMPLE_PARCELABLE_NDK_H_ ./PaxHeaders.X/tests_stability_test_0100644 0000000 0000000 00000000034 15172120304 016643 xustar000000000 0000000 28 mtime=1776853188.7870000 tests/stability_test/0040755 0000000 0000000 00000000000 15172120304 014010 5ustar000000000 0000000 ./PaxHeaders.X/tests_stability_test_Android.bp0100644 0000000 0000000 00000000034 15172120304 020544 xustar000000000 0000000 28 mtime=1776853188.7870000 tests/stability_test/Android.bp0100644 0000000 0000000 00000004266 15172120304 015720 0ustar000000000 0000000 // // 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. // package { // See: http://go/android-license-faq // A large-scale-change added 'default_applicable_licenses' to import // all of the 'license_kinds' from "system_tools_aidl_license" // to get the below license kinds: // SPDX-license-identifier-Apache-2.0 default_applicable_licenses: ["system_tools_aidl_license"], } aidl_interface { name: "aidl_test_nonvintf_parcelable", flags: ["-Werror"], srcs: [ "android/aidl/tests/nonvintf/*.aidl", ], backend: { java: { platform_apis: true, }, cpp: { enabled: false, }, ndk: { enabled: false, }, rust: { enabled: true, }, }, versions: ["1"], } aidl_interface { name: "aidl_test_unstable_parcelable", unstable: true, flags: ["-Werror"], srcs: [ "android/aidl/tests/unstable/*.aidl", ], backend: { java: { platform_apis: true, }, cpp: { enabled: false, }, ndk: { enabled: false, }, rust: { enabled: true, }, }, } aidl_interface { name: "aidl_test_vintf_parcelable", stability: "vintf", flags: ["-Werror"], srcs: [ "android/aidl/tests/vintf/*.aidl", ], backend: { java: { platform_apis: true, }, cpp: { enabled: false, }, ndk: { enabled: false, }, rust: { enabled: true, }, }, versions: ["1"], } ./PaxHeaders.X/tests_stability_test_aidl_api_0100644 0000000 0000000 00000000034 15172120304 020465 xustar000000000 0000000 28 mtime=1776853188.7870000 tests/stability_test/aidl_api/0040755 0000000 0000000 00000000000 15172120304 015552 5ustar000000000 0000000 ./PaxHeaders.X/tests_stability_test_aidl_api_aidl_test_nonvintf_parcelable_0100644 0000000 0000000 00000000034 15172120304 026610 xustar000000000 0000000 28 mtime=1776853188.7870000 tests/stability_test/aidl_api/aidl_test_nonvintf_parcelable/0040755 0000000 0000000 00000000000 15172120304 023615 5ustar000000000 0000000 ./PaxHeaders.X/tests_stability_test_aidl_api_aidl_test_nonvintf_parcelable_1_0100644 0000000 0000000 00000000034 15172120304 027030 xustar000000000 0000000 28 mtime=1776853188.7870000 tests/stability_test/aidl_api/aidl_test_nonvintf_parcelable/1/0040755 0000000 0000000 00000000000 15172120304 023755 5ustar000000000 0000000 ./PaxHeaders.X/tests_stability_test_aidl_api_aidl_test_nonvintf_parcelable_1_.hash0100644 0000000 0000000 00000000034 15172120304 027752 xustar000000000 0000000 28 mtime=1776853188.7870000 tests/stability_test/aidl_api/aidl_test_nonvintf_parcelable/1/.hash0100644 0000000 0000000 00000000051 15172120304 024672 0ustar000000000 0000000 873769e09e3ac6d71f380fd36df9e15526d250e5 ./PaxHeaders.X/tests_stability_test_aidl_api_aidl_test_nonvintf_parcelable_1_android_0100644 0000000 0000000 00000000034 15172120304 030530 xustar000000000 0000000 28 mtime=1776853188.7880000 tests/stability_test/aidl_api/aidl_test_nonvintf_parcelable/1/android/0040755 0000000 0000000 00000000000 15172120304 025375 5ustar000000000 0000000 ./PaxHeaders.X/tests_stability_test_aidl_api_aidl_test_nonvintf_parcelable_1_android_aidl_0100644 0000000 0000000 00000000034 15172120304 031521 xustar000000000 0000000 28 mtime=1776853188.7880000 tests/stability_test/aidl_api/aidl_test_nonvintf_parcelable/1/android/aidl/0040755 0000000 0000000 00000000000 15172120304 026306 5ustar000000000 0000000 ./PaxHeaders.X/tests_stability_test_aidl_api_aidl_test_nonvintf_parcelable_1_android_aidl_tests_0100644 0000000 0000000 00000000034 15172120304 032743 xustar000000000 0000000 28 mtime=1776853188.7880000 tests/stability_test/aidl_api/aidl_test_nonvintf_parcelable/1/android/aidl/tests/0040755 0000000 0000000 00000000000 15172120304 027450 5ustar000000000 0000000 ./PaxHeaders.X/tests_stability_test_aidl_api_aidl_test_nonvintf_parcelable_1_android_aidl_tests_non0100644 0000000 0000000 00000000034 15172120304 033456 xustar000000000 0000000 28 mtime=1776853188.7880000 tests/stability_test/aidl_api/aidl_test_nonvintf_parcelable/1/android/aidl/tests/nonvintf/0040755 0000000 0000000 00000000000 15172120304 031311 5ustar000000000 0000000 ./PaxHeaders.X/tests_stability_test_aidl_api_aidl_test_nonvintf_parcelable_1_android_aidl_tests_non0100644 0000000 0000000 00000000241 15172120304 033456 xustar000000000 0000000 133 path=tests/stability_test/aidl_api/aidl_test_nonvintf_parcelable/1/android/aidl/tests/nonvintf/NonVintfExtendableParcelable.aidl 28 mtime=1776853188.7880000 tests/stability_test/aidl_api/aidl_test_nonvintf_parcelable/1/android/aidl/tests/nonvintf/NonVintfEx0100644 0000000 0000000 00000002176 15172120304 033275 0ustar000000000 0000000 /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL interface (or parcelable). Do not try to // edit this file. It looks like you are doing that because you have modified // an AIDL interface in a backward-incompatible way, e.g., deleting a function // from an interface or a field from a parcelable and it broke the build. That // breakage is intended. // // You must not make a backward incompatible changes to the AIDL files built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package android.aidl.tests.nonvintf; parcelable NonVintfExtendableParcelable { ParcelableHolder ext; } ./PaxHeaders.X/tests_stability_test_aidl_api_aidl_test_nonvintf_parcelable_1_android_aidl_tests_non0100644 0000000 0000000 00000000227 15172120304 033462 xustar000000000 0000000 123 path=tests/stability_test/aidl_api/aidl_test_nonvintf_parcelable/1/android/aidl/tests/nonvintf/NonVintfParcelable.aidl 28 mtime=1776853188.7880000 tests/stability_test/aidl_api/aidl_test_nonvintf_parcelable/1/android/aidl/tests/nonvintf/NonVintfPa0100644 0000000 0000000 00000002145 15172120304 033255 0ustar000000000 0000000 /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL interface (or parcelable). Do not try to // edit this file. It looks like you are doing that because you have modified // an AIDL interface in a backward-incompatible way, e.g., deleting a function // from an interface or a field from a parcelable and it broke the build. That // breakage is intended. // // You must not make a backward incompatible changes to the AIDL files built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package android.aidl.tests.nonvintf; parcelable NonVintfParcelable { int a; } ./PaxHeaders.X/tests_stability_test_aidl_api_aidl_test_nonvintf_parcelable_current_0100644 0000000 0000000 00000000034 15172120304 030352 xustar000000000 0000000 28 mtime=1776853188.7880000 tests/stability_test/aidl_api/aidl_test_nonvintf_parcelable/current/0040755 0000000 0000000 00000000000 15172120304 025277 5ustar000000000 0000000 ./PaxHeaders.X/tests_stability_test_aidl_api_aidl_test_nonvintf_parcelable_current_android_0100644 0000000 0000000 00000000034 15172120304 032052 xustar000000000 0000000 28 mtime=1776853188.7880000 tests/stability_test/aidl_api/aidl_test_nonvintf_parcelable/current/android/0040755 0000000 0000000 00000000000 15172120304 026717 5ustar000000000 0000000 ./PaxHeaders.X/tests_stability_test_aidl_api_aidl_test_nonvintf_parcelable_current_android_aidl_0100644 0000000 0000000 00000000034 15172120304 033043 xustar000000000 0000000 28 mtime=1776853188.7880000 tests/stability_test/aidl_api/aidl_test_nonvintf_parcelable/current/android/aidl/0040755 0000000 0000000 00000000000 15172120304 027630 5ustar000000000 0000000 ./PaxHeaders.X/tests_stability_test_aidl_api_aidl_test_nonvintf_parcelable_current_android_aidl_tes0100644 0000000 0000000 00000000034 15172120304 033557 xustar000000000 0000000 28 mtime=1776853188.7880000 tests/stability_test/aidl_api/aidl_test_nonvintf_parcelable/current/android/aidl/tests/0040755 0000000 0000000 00000000000 15172120304 030772 5ustar000000000 0000000 ./PaxHeaders.X/tests_stability_test_aidl_api_aidl_test_nonvintf_parcelable_current_android_aidl_tes0100644 0000000 0000000 00000000034 15172120304 033557 xustar000000000 0000000 28 mtime=1776853188.7880000 tests/stability_test/aidl_api/aidl_test_nonvintf_parcelable/current/android/aidl/tests/nonvintf/0040755 0000000 0000000 00000000000 15172120304 032633 5ustar000000000 0000000 ./PaxHeaders.X/tests_stability_test_aidl_api_aidl_test_nonvintf_parcelable_current_android_aidl_tes0100644 0000000 0000000 00000000247 15172120304 033565 xustar000000000 0000000 139 path=tests/stability_test/aidl_api/aidl_test_nonvintf_parcelable/current/android/aidl/tests/nonvintf/NonVintfExtendableParcelable.aidl 28 mtime=1776853188.7880000 tests/stability_test/aidl_api/aidl_test_nonvintf_parcelable/current/android/aidl/tests/nonvintf/NonV0100644 0000000 0000000 00000003423 15172120304 033435 0ustar000000000 0000000 /* * 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. */ /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL file. Do not edit it manually. There are // two cases: // 1). this is a frozen version file - do not edit this in any case. // 2). this is a 'current' file. If you make a backwards compatible change to // the interface (from the latest frozen version), the build system will // prompt you to update this file with `m -update-api`. // // You must not make a backward incompatible change to any AIDL file built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package android.aidl.tests.nonvintf; parcelable NonVintfExtendableParcelable { ParcelableHolder ext; } ./PaxHeaders.X/tests_stability_test_aidl_api_aidl_test_nonvintf_parcelable_current_android_aidl_tes0100644 0000000 0000000 00000000235 15172120304 033562 xustar000000000 0000000 129 path=tests/stability_test/aidl_api/aidl_test_nonvintf_parcelable/current/android/aidl/tests/nonvintf/NonVintfParcelable.aidl 28 mtime=1776853188.7880000 tests/stability_test/aidl_api/aidl_test_nonvintf_parcelable/current/android/aidl/tests/nonvintf/NonV0100644 0000000 0000000 00000003372 15172120304 033440 0ustar000000000 0000000 /* * 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. */ /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL file. Do not edit it manually. There are // two cases: // 1). this is a frozen version file - do not edit this in any case. // 2). this is a 'current' file. If you make a backwards compatible change to // the interface (from the latest frozen version), the build system will // prompt you to update this file with `m -update-api`. // // You must not make a backward incompatible change to any AIDL file built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package android.aidl.tests.nonvintf; parcelable NonVintfParcelable { int a; } ./PaxHeaders.X/tests_stability_test_aidl_api_aidl_test_vintf_parcelable_0100644 0000000 0000000 00000000034 15172120304 026075 xustar000000000 0000000 28 mtime=1776853188.7880000 tests/stability_test/aidl_api/aidl_test_vintf_parcelable/0040755 0000000 0000000 00000000000 15172120304 023102 5ustar000000000 0000000 ./PaxHeaders.X/tests_stability_test_aidl_api_aidl_test_vintf_parcelable_1_0100644 0000000 0000000 00000000034 15172120304 026315 xustar000000000 0000000 28 mtime=1776853188.7880000 tests/stability_test/aidl_api/aidl_test_vintf_parcelable/1/0040755 0000000 0000000 00000000000 15172120304 023242 5ustar000000000 0000000 ./PaxHeaders.X/tests_stability_test_aidl_api_aidl_test_vintf_parcelable_1_.hash0100644 0000000 0000000 00000000034 15172120304 027237 xustar000000000 0000000 28 mtime=1776853188.7880000 tests/stability_test/aidl_api/aidl_test_vintf_parcelable/1/.hash0100644 0000000 0000000 00000000051 15172120304 024157 0ustar000000000 0000000 10def8b50cda5b371cb022d66b5f7425da9eec4f ./PaxHeaders.X/tests_stability_test_aidl_api_aidl_test_vintf_parcelable_1_android_0100644 0000000 0000000 00000000034 15172120304 030015 xustar000000000 0000000 28 mtime=1776853188.7880000 tests/stability_test/aidl_api/aidl_test_vintf_parcelable/1/android/0040755 0000000 0000000 00000000000 15172120304 024662 5ustar000000000 0000000 ./PaxHeaders.X/tests_stability_test_aidl_api_aidl_test_vintf_parcelable_1_android_aidl_0100644 0000000 0000000 00000000034 15172120304 031006 xustar000000000 0000000 28 mtime=1776853188.7880000 tests/stability_test/aidl_api/aidl_test_vintf_parcelable/1/android/aidl/0040755 0000000 0000000 00000000000 15172120304 025573 5ustar000000000 0000000 ./PaxHeaders.X/tests_stability_test_aidl_api_aidl_test_vintf_parcelable_1_android_aidl_tests_0100644 0000000 0000000 00000000034 15172120304 032230 xustar000000000 0000000 28 mtime=1776853188.7880000 tests/stability_test/aidl_api/aidl_test_vintf_parcelable/1/android/aidl/tests/0040755 0000000 0000000 00000000000 15172120304 026735 5ustar000000000 0000000 ./PaxHeaders.X/tests_stability_test_aidl_api_aidl_test_vintf_parcelable_1_android_aidl_tests_vintf_0100644 0000000 0000000 00000000034 15172120304 033436 xustar000000000 0000000 28 mtime=1776853188.7880000 tests/stability_test/aidl_api/aidl_test_vintf_parcelable/1/android/aidl/tests/vintf/0040755 0000000 0000000 00000000000 15172120304 030063 5ustar000000000 0000000 ./PaxHeaders.X/tests_stability_test_aidl_api_aidl_test_vintf_parcelable_1_android_aidl_tests_vintf_0100644 0000000 0000000 00000000230 15172120304 033434 xustar000000000 0000000 124 path=tests/stability_test/aidl_api/aidl_test_vintf_parcelable/1/android/aidl/tests/vintf/VintfExtendableParcelable.aidl 28 mtime=1776853188.7880000 tests/stability_test/aidl_api/aidl_test_vintf_parcelable/1/android/aidl/tests/vintf/VintfExtendableP0100644 0000000 0000000 00000002210 15172120304 033200 0ustar000000000 0000000 /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL interface (or parcelable). Do not try to // edit this file. It looks like you are doing that because you have modified // an AIDL interface in a backward-incompatible way, e.g., deleting a function // from an interface or a field from a parcelable and it broke the build. That // breakage is intended. // // You must not make a backward incompatible changes to the AIDL files built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package android.aidl.tests.vintf; @VintfStability parcelable VintfExtendableParcelable { ParcelableHolder ext; } ./PaxHeaders.X/tests_stability_test_aidl_api_aidl_test_vintf_parcelable_1_android_aidl_tests_vintf_0100644 0000000 0000000 00000000216 15172120304 033440 xustar000000000 0000000 114 path=tests/stability_test/aidl_api/aidl_test_vintf_parcelable/1/android/aidl/tests/vintf/VintfParcelable.aidl 28 mtime=1776853188.7880000 tests/stability_test/aidl_api/aidl_test_vintf_parcelable/1/android/aidl/tests/vintf/VintfParcelable.0100644 0000000 0000000 00000002157 15172120304 033127 0ustar000000000 0000000 /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL interface (or parcelable). Do not try to // edit this file. It looks like you are doing that because you have modified // an AIDL interface in a backward-incompatible way, e.g., deleting a function // from an interface or a field from a parcelable and it broke the build. That // breakage is intended. // // You must not make a backward incompatible changes to the AIDL files built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package android.aidl.tests.vintf; @VintfStability parcelable VintfParcelable { int a; } ./PaxHeaders.X/tests_stability_test_aidl_api_aidl_test_vintf_parcelable_current_0100644 0000000 0000000 00000000034 15172120304 027637 xustar000000000 0000000 28 mtime=1776853188.7880000 tests/stability_test/aidl_api/aidl_test_vintf_parcelable/current/0040755 0000000 0000000 00000000000 15172120304 024564 5ustar000000000 0000000 ./PaxHeaders.X/tests_stability_test_aidl_api_aidl_test_vintf_parcelable_current_android_0100644 0000000 0000000 00000000034 15172120304 031337 xustar000000000 0000000 28 mtime=1776853188.7880000 tests/stability_test/aidl_api/aidl_test_vintf_parcelable/current/android/0040755 0000000 0000000 00000000000 15172120304 026204 5ustar000000000 0000000 ./PaxHeaders.X/tests_stability_test_aidl_api_aidl_test_vintf_parcelable_current_android_aidl_0100644 0000000 0000000 00000000034 15172120304 032330 xustar000000000 0000000 28 mtime=1776853188.7890000 tests/stability_test/aidl_api/aidl_test_vintf_parcelable/current/android/aidl/0040755 0000000 0000000 00000000000 15172120304 027115 5ustar000000000 0000000 ./PaxHeaders.X/tests_stability_test_aidl_api_aidl_test_vintf_parcelable_current_android_aidl_tests_0100644 0000000 0000000 00000000034 15172120304 033552 xustar000000000 0000000 28 mtime=1776853188.7890000 tests/stability_test/aidl_api/aidl_test_vintf_parcelable/current/android/aidl/tests/0040755 0000000 0000000 00000000000 15172120304 030257 5ustar000000000 0000000 ./PaxHeaders.X/tests_stability_test_aidl_api_aidl_test_vintf_parcelable_current_android_aidl_tests_0100644 0000000 0000000 00000000034 15172120304 033552 xustar000000000 0000000 28 mtime=1776853188.7890000 tests/stability_test/aidl_api/aidl_test_vintf_parcelable/current/android/aidl/tests/vintf/0040755 0000000 0000000 00000000000 15172120304 031405 5ustar000000000 0000000 ./PaxHeaders.X/tests_stability_test_aidl_api_aidl_test_vintf_parcelable_current_android_aidl_tests_0100644 0000000 0000000 00000000236 15172120304 033556 xustar000000000 0000000 130 path=tests/stability_test/aidl_api/aidl_test_vintf_parcelable/current/android/aidl/tests/vintf/VintfExtendableParcelable.aidl 28 mtime=1776853188.7890000 tests/stability_test/aidl_api/aidl_test_vintf_parcelable/current/android/aidl/tests/vintf/VintfExten0100644 0000000 0000000 00000003435 15172120304 033424 0ustar000000000 0000000 /* * 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. */ /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL file. Do not edit it manually. There are // two cases: // 1). this is a frozen version file - do not edit this in any case. // 2). this is a 'current' file. If you make a backwards compatible change to // the interface (from the latest frozen version), the build system will // prompt you to update this file with `m -update-api`. // // You must not make a backward incompatible change to any AIDL file built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package android.aidl.tests.vintf; @VintfStability parcelable VintfExtendableParcelable { ParcelableHolder ext; } ./PaxHeaders.X/tests_stability_test_aidl_api_aidl_test_vintf_parcelable_current_android_aidl_tests_0100644 0000000 0000000 00000000224 15172120304 033553 xustar000000000 0000000 120 path=tests/stability_test/aidl_api/aidl_test_vintf_parcelable/current/android/aidl/tests/vintf/VintfParcelable.aidl 28 mtime=1776853188.7890000 tests/stability_test/aidl_api/aidl_test_vintf_parcelable/current/android/aidl/tests/vintf/VintfParce0100644 0000000 0000000 00000003404 15172120304 033367 0ustar000000000 0000000 /* * 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. */ /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL file. Do not edit it manually. There are // two cases: // 1). this is a frozen version file - do not edit this in any case. // 2). this is a 'current' file. If you make a backwards compatible change to // the interface (from the latest frozen version), the build system will // prompt you to update this file with `m -update-api`. // // You must not make a backward incompatible change to any AIDL file built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package android.aidl.tests.vintf; @VintfStability parcelable VintfParcelable { int a; } ./PaxHeaders.X/tests_stability_test_android_0100644 0000000 0000000 00000000034 15172120304 020343 xustar000000000 0000000 28 mtime=1776853188.7890000 tests/stability_test/android/0040755 0000000 0000000 00000000000 15172120304 015430 5ustar000000000 0000000 ./PaxHeaders.X/tests_stability_test_android_aidl_0100644 0000000 0000000 00000000034 15172120304 021334 xustar000000000 0000000 28 mtime=1776853188.7890000 tests/stability_test/android/aidl/0040755 0000000 0000000 00000000000 15172120304 016341 5ustar000000000 0000000 ./PaxHeaders.X/tests_stability_test_android_aidl_tests_0100644 0000000 0000000 00000000034 15172120304 022556 xustar000000000 0000000 28 mtime=1776853188.7890000 tests/stability_test/android/aidl/tests/0040755 0000000 0000000 00000000000 15172120304 017503 5ustar000000000 0000000 ./PaxHeaders.X/tests_stability_test_android_aidl_tests_nonvintf_0100644 0000000 0000000 00000000034 15172120304 024477 xustar000000000 0000000 28 mtime=1776853188.7890000 tests/stability_test/android/aidl/tests/nonvintf/0040755 0000000 0000000 00000000000 15172120304 021344 5ustar000000000 0000000 ./PaxHeaders.X/tests_stability_test_android_aidl_tests_nonvintf_NonVintfExtendableParcelable.aidl0100644 0000000 0000000 00000000034 15172120304 033040 xustar000000000 0000000 28 mtime=1776853188.7890000 tests/stability_test/android/aidl/tests/nonvintf/NonVintfExtendableParcelable.aidl0100644 0000000 0000000 00000001331 15172120304 027702 0ustar000000000 0000000 /* * 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. */ package android.aidl.tests.nonvintf; parcelable NonVintfExtendableParcelable { ParcelableHolder ext; } ./PaxHeaders.X/tests_stability_test_android_aidl_tests_nonvintf_NonVintfParcelable.aidl0100644 0000000 0000000 00000000034 15172120304 031044 xustar000000000 0000000 28 mtime=1776853188.7890000 tests/stability_test/android/aidl/tests/nonvintf/NonVintfParcelable.aidl0100644 0000000 0000000 00000001300 15172120304 025702 0ustar000000000 0000000 /* * 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. */ package android.aidl.tests.nonvintf; parcelable NonVintfParcelable { int a; } ./PaxHeaders.X/tests_stability_test_android_aidl_tests_unstable_0100644 0000000 0000000 00000000034 15172120304 024453 xustar000000000 0000000 28 mtime=1776853188.7890000 tests/stability_test/android/aidl/tests/unstable/0040755 0000000 0000000 00000000000 15172120304 021320 5ustar000000000 0000000 ./PaxHeaders.X/tests_stability_test_android_aidl_tests_unstable_UnstableExtendableParcelable.aidl0100644 0000000 0000000 00000000034 15172120304 033030 xustar000000000 0000000 28 mtime=1776853188.7890000 tests/stability_test/android/aidl/tests/unstable/UnstableExtendableParcelable.aidl0100644 0000000 0000000 00000001331 15172120304 027672 0ustar000000000 0000000 /* * 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. */ package android.aidl.tests.unstable; parcelable UnstableExtendableParcelable { ParcelableHolder ext; } ./PaxHeaders.X/tests_stability_test_android_aidl_tests_unstable_UnstableParcelable.aidl0100644 0000000 0000000 00000000034 15172120304 031034 xustar000000000 0000000 28 mtime=1776853188.7890000 tests/stability_test/android/aidl/tests/unstable/UnstableParcelable.aidl0100644 0000000 0000000 00000001300 15172120304 025672 0ustar000000000 0000000 /* * 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. */ package android.aidl.tests.unstable; parcelable UnstableParcelable { int a; } ./PaxHeaders.X/tests_stability_test_android_aidl_tests_vintf_0100644 0000000 0000000 00000000034 15172120304 023764 xustar000000000 0000000 28 mtime=1776853188.7890000 tests/stability_test/android/aidl/tests/vintf/0040755 0000000 0000000 00000000000 15172120304 020631 5ustar000000000 0000000 ./PaxHeaders.X/tests_stability_test_android_aidl_tests_vintf_VintfExtendableParcelable.aidl0100644 0000000 0000000 00000000034 15172120304 031652 xustar000000000 0000000 28 mtime=1776853188.7890000 tests/stability_test/android/aidl/tests/vintf/VintfExtendableParcelable.aidl0100644 0000000 0000000 00000001343 15172120304 026517 0ustar000000000 0000000 /* * 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. */ package android.aidl.tests.vintf; @VintfStability parcelable VintfExtendableParcelable { ParcelableHolder ext; } ./PaxHeaders.X/tests_stability_test_android_aidl_tests_vintf_VintfParcelable.aidl0100644 0000000 0000000 00000000034 15172120304 027656 xustar000000000 0000000 28 mtime=1776853188.7890000 tests/stability_test/android/aidl/tests/vintf/VintfParcelable.aidl0100644 0000000 0000000 00000001312 15172120304 024517 0ustar000000000 0000000 /* * 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. */ package android.aidl.tests.vintf; @VintfStability parcelable VintfParcelable { int a; } ./PaxHeaders.X/tests_test_util.cpp0100644 0000000 0000000 00000000034 15172120304 016236 xustar000000000 0000000 28 mtime=1776853188.7890000 tests/test_util.cpp0100644 0000000 0000000 00000010370 15172120304 013463 0ustar000000000 0000000 /* * Copyright (C) 2015, 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 #include #include #include #include "os.h" #include "tests/test_util.h" using android::base::Split; using android::base::Join; using std::string; using std::vector; using std::cout; using std::endl; using std::distance; namespace android { namespace aidl { namespace test { string CanonicalNameToPath(const char* package_class, const char* extension) { string rel_path{package_class}; for (char& c : rel_path) { if (c == '.') { c = OS_PATH_SEPARATOR; } } rel_path += extension; return rel_path; } void SplitPackageClass(const string& package_class, string* rel_path, string* package, string* class_name) { *package = string{package_class, 0, package_class.rfind('.')}; *class_name = string{package_class, package_class.rfind('.') + 1}; *rel_path = CanonicalNameToPath(package_class.c_str(), ".aidl"); } void PrintDiff(const string& a, const string& b) { const int LEFT = 1; const int UP = 2; const int UP_LEFT = 4; auto a_lines = Split(a, "\n"); auto b_lines = Split(b, "\n"); struct diff_table_entry { size_t longest_common_subsequence_length; int propagation_directions; }; diff_table_entry table[a_lines.size() + 1][b_lines.size() + 1]; for (size_t i = 0; i < a_lines.size() + 1; ++i) { for (size_t j = 0; j < b_lines.size() + 1; ++j) { if (i == 0 || j == 0) { int directions = 0; if (i) { directions |= UP; } if (j) { directions |= LEFT; } table[i][j].longest_common_subsequence_length = 0; table[i][j].propagation_directions = directions; } else if (a_lines[i-1] == b_lines[j-1]) { table[i][j].longest_common_subsequence_length = table[i-1][j-1].longest_common_subsequence_length + 1; table[i][j].propagation_directions = UP_LEFT; } else { size_t length_up = table[i-1][j].longest_common_subsequence_length; size_t length_left = table[i][j-1].longest_common_subsequence_length; int directions = 0; size_t length; if (length_up >= length_left) { directions |= UP; length = length_up; } if (length_left >= length_up) { directions |= LEFT; length = length_left; } table[i][j].longest_common_subsequence_length = length; table[i][j].propagation_directions = directions; } } } size_t i = a_lines.size(); size_t j = b_lines.size(); vector output; while (table[i][j].propagation_directions) { if (table[i][j].propagation_directions & UP_LEFT) { output.push_back(" " + a_lines[i-1]); i--; j--; } else if (table[i][j].propagation_directions & UP) { output.push_back("-" + a_lines[i-1]); i--; } else { output.push_back("+" + b_lines[j-1]); j--; } } int print_mask = 0; bool printed_last = false; size_t line_number = 0; for (auto it = output.crbegin(), frontier = output.crbegin(); it != output.crend(); ++it) { while (frontier != output.crend() && distance(it, frontier) <= 3) { print_mask <<= 1; print_mask &= 0x7f; if ((*frontier)[0] != ' ') { print_mask |= 1; } frontier++; } if ((*it)[0] != '-') { line_number++; } if (print_mask) { if (!printed_last) { cout << "Line: " << line_number << endl; } cout << *it << endl; printed_last = true; } else { printed_last = false; } } } } // namespace test } // namespace aidl } // namespace android ./PaxHeaders.X/tests_test_util.h0100644 0000000 0000000 00000000034 15172120304 015703 xustar000000000 0000000 28 mtime=1776853188.7890000 tests/test_util.h0100644 0000000 0000000 00000002324 15172120304 013130 0ustar000000000 0000000 /* * Copyright (C) 2015, 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. */ #ifndef AIDL_TESTS_TEST_UTIL_H_ #define AIDL_TESTS_TEST_UTIL_H_ #include namespace android { namespace aidl { namespace test { std::string CanonicalNameToPath(const char* package_class, const char* extension); void SplitPackageClass(const std::string& package_class, std::string* rel_path, std::string* package, std::string* class_name); void PrintDiff(const std::string& a, const std::string& b); } // namespace test } // namespace aidl } // namespace android #endif // AIDL_TESTS_TEST_UTIL_H_ ./PaxHeaders.X/tests_trunk_stable_test_0100644 0000000 0000000 00000000034 15172120304 017334 xustar000000000 0000000 28 mtime=1776853188.7890000 tests/trunk_stable_test/0040755 0000000 0000000 00000000000 15172120304 014501 5ustar000000000 0000000 ./PaxHeaders.X/tests_trunk_stable_test_Android.bp0100644 0000000 0000000 00000000034 15172120304 021235 xustar000000000 0000000 28 mtime=1776853188.7900000 tests/trunk_stable_test/Android.bp0100644 0000000 0000000 00000005277 15172120304 016414 0ustar000000000 0000000 // Copyright (C) 2023 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. package { // See: http://go/android-license-faq // A large-scale-change added 'default_applicable_licenses' to import // all of the 'license_kinds' from "system_tools_aidl_license" // to get the below license kinds: // SPDX-license-identifier-Apache-2.0 default_applicable_licenses: ["system_tools_aidl_license"], } aidl_interface { name: "android.aidl.test.trunk", srcs: ["android/aidl/test/trunk/*.aidl"], flags: ["-Werror"], gen_trace: true, backend: { cpp: { gen_log: true, }, ndk: { gen_log: true, }, java: { platform_apis: true, }, rust: { enabled: true, }, }, versions_with_info: [ { version: "1", imports: [], }, ], frozen: false, // Some tests rely on the last version not being frozen. // Owner is set so the interface isn't frozen with the rest. owner: "aosp", } // Test using the same client and server source code including different // versions of the generated AIDL library. // This is an example of a possible solution to dealing with different // configurations of the build without needing to modify the source code. // This is the version of the test that uses the V1 library with the // V2 code behind #ifdefs. cc_test { name: "aidl_ndk_V1_trunk_stable_unittest", srcs: ["trunk_ndk_unittest.cpp"], shared_libs: [ "libbinder_ndk", "libbase", "libcutils", "liblog", ], cflags: [ "-DAIDL_TEST_TRUNK_VER=1", ], static_libs: [ "android.aidl.test.trunk-V1-ndk", ], require_root: true, } // This is the version of the test that uses the latest V2 library. cc_test { name: "aidl_ndk_V2_trunk_stable_unittest", srcs: ["trunk_ndk_unittest.cpp"], shared_libs: [ "libcutils", "liblog", "libbinder_ndk", "libbase", ], cflags: [ "-DAIDL_TEST_TRUNK_VER=2", ], static_libs: [ "android.aidl.test.trunk-V2-ndk", ], require_root: true, } ./PaxHeaders.X/tests_trunk_stable_test_aidl_api_0100644 0000000 0000000 00000000034 15172120304 021156 xustar000000000 0000000 28 mtime=1776853188.7900000 tests/trunk_stable_test/aidl_api/0040755 0000000 0000000 00000000000 15172120304 016243 5ustar000000000 0000000 ./PaxHeaders.X/tests_trunk_stable_test_aidl_api_android.aidl.test.trunk_0100644 0000000 0000000 00000000034 15172120304 025706 xustar000000000 0000000 28 mtime=1776853188.7900000 tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/0040755 0000000 0000000 00000000000 15172120304 022713 5ustar000000000 0000000 ./PaxHeaders.X/tests_trunk_stable_test_aidl_api_android.aidl.test.trunk_1_0100644 0000000 0000000 00000000034 15172120304 026126 xustar000000000 0000000 28 mtime=1776853188.7900000 tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/0040755 0000000 0000000 00000000000 15172120304 023053 5ustar000000000 0000000 ./PaxHeaders.X/tests_trunk_stable_test_aidl_api_android.aidl.test.trunk_1_.hash0100644 0000000 0000000 00000000034 15172120304 027050 xustar000000000 0000000 28 mtime=1776853188.7900000 tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/.hash0100644 0000000 0000000 00000000051 15172120304 023770 0ustar000000000 0000000 88311b9118fb6fe9eff4a2ca19121de0587f6d5f ./PaxHeaders.X/tests_trunk_stable_test_aidl_api_android.aidl.test.trunk_1_android_0100644 0000000 0000000 00000000034 15172120304 027626 xustar000000000 0000000 28 mtime=1776853188.7900000 tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/android/0040755 0000000 0000000 00000000000 15172120304 024473 5ustar000000000 0000000 ./PaxHeaders.X/tests_trunk_stable_test_aidl_api_android.aidl.test.trunk_1_android_aidl_0100644 0000000 0000000 00000000034 15172120304 030617 xustar000000000 0000000 28 mtime=1776853188.7900000 tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/android/aidl/0040755 0000000 0000000 00000000000 15172120304 025404 5ustar000000000 0000000 ./PaxHeaders.X/tests_trunk_stable_test_aidl_api_android.aidl.test.trunk_1_android_aidl_test_0100644 0000000 0000000 00000000034 15172120304 031656 xustar000000000 0000000 28 mtime=1776853188.7900000 tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/android/aidl/test/0040755 0000000 0000000 00000000000 15172120304 026363 5ustar000000000 0000000 ./PaxHeaders.X/tests_trunk_stable_test_aidl_api_android.aidl.test.trunk_1_android_aidl_test_trunk_0100644 0000000 0000000 00000000034 15172120304 033101 xustar000000000 0000000 28 mtime=1776853188.7900000 tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/android/aidl/test/trunk/0040755 0000000 0000000 00000000000 15172120304 027526 5ustar000000000 0000000 ./PaxHeaders.X/tests_trunk_stable_test_aidl_api_android.aidl.test.trunk_1_android_aidl_test_trunk_I0100644 0000000 0000000 00000000216 15172120304 033214 xustar000000000 0000000 114 path=tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/android/aidl/test/trunk/ITrunkStableTest.aidl 28 mtime=1776853188.7900000 tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/1/android/aidl/test/trunk/ITrunkStableTest.0100644 0000000 0000000 00000004201 15172120304 032730 0ustar000000000 0000000 /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL file. Do not edit it manually. There are // two cases: // 1). this is a frozen version file - do not edit this in any case. // 2). this is a 'current' file. If you make a backwards compatible change to // the interface (from the latest frozen version), the build system will // prompt you to update this file with `m -update-api`. // // You must not make a backward incompatible change to any AIDL file built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package android.aidl.test.trunk; interface ITrunkStableTest { android.aidl.test.trunk.ITrunkStableTest.MyParcelable repeatParcelable(in android.aidl.test.trunk.ITrunkStableTest.MyParcelable input); android.aidl.test.trunk.ITrunkStableTest.MyEnum repeatEnum(in android.aidl.test.trunk.ITrunkStableTest.MyEnum input); android.aidl.test.trunk.ITrunkStableTest.MyUnion repeatUnion(in android.aidl.test.trunk.ITrunkStableTest.MyUnion input); void callMyCallback(in android.aidl.test.trunk.ITrunkStableTest.IMyCallback cb); parcelable MyParcelable { int a; int b; } enum MyEnum { ZERO, ONE, TWO, } union MyUnion { int a; int b; } interface IMyCallback { android.aidl.test.trunk.ITrunkStableTest.MyParcelable repeatParcelable(in android.aidl.test.trunk.ITrunkStableTest.MyParcelable input); android.aidl.test.trunk.ITrunkStableTest.MyEnum repeatEnum(in android.aidl.test.trunk.ITrunkStableTest.MyEnum input); android.aidl.test.trunk.ITrunkStableTest.MyUnion repeatUnion(in android.aidl.test.trunk.ITrunkStableTest.MyUnion input); } } ./PaxHeaders.X/tests_trunk_stable_test_aidl_api_android.aidl.test.trunk_current_0100644 0000000 0000000 00000000034 15172120304 027450 xustar000000000 0000000 28 mtime=1776853188.7900000 tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/current/0040755 0000000 0000000 00000000000 15172120304 024375 5ustar000000000 0000000 ./PaxHeaders.X/tests_trunk_stable_test_aidl_api_android.aidl.test.trunk_current_android_0100644 0000000 0000000 00000000034 15172120304 031150 xustar000000000 0000000 28 mtime=1776853188.7900000 tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/current/android/0040755 0000000 0000000 00000000000 15172120304 026015 5ustar000000000 0000000 ./PaxHeaders.X/tests_trunk_stable_test_aidl_api_android.aidl.test.trunk_current_android_aidl_0100644 0000000 0000000 00000000034 15172120304 032141 xustar000000000 0000000 28 mtime=1776853188.7900000 tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/current/android/aidl/0040755 0000000 0000000 00000000000 15172120304 026726 5ustar000000000 0000000 ./PaxHeaders.X/tests_trunk_stable_test_aidl_api_android.aidl.test.trunk_current_android_aidl_test_0100644 0000000 0000000 00000000034 15172120304 033200 xustar000000000 0000000 28 mtime=1776853188.7900000 tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/current/android/aidl/test/0040755 0000000 0000000 00000000000 15172120304 027705 5ustar000000000 0000000 ./PaxHeaders.X/tests_trunk_stable_test_aidl_api_android.aidl.test.trunk_current_android_aidl_test_t0100644 0000000 0000000 00000000034 15172120304 033364 xustar000000000 0000000 28 mtime=1776853188.7910000 tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/current/android/aidl/test/trunk/0040755 0000000 0000000 00000000000 15172120304 031050 5ustar000000000 0000000 ./PaxHeaders.X/tests_trunk_stable_test_aidl_api_android.aidl.test.trunk_current_android_aidl_test_t0100644 0000000 0000000 00000000224 15172120304 033365 xustar000000000 0000000 120 path=tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/current/android/aidl/test/trunk/ITrunkStableTest.aidl 28 mtime=1776853188.7910000 tests/trunk_stable_test/aidl_api/android.aidl.test.trunk/current/android/aidl/test/trunk/ITrunkStabl0100644 0000000 0000000 00000005021 15172120304 033170 0ustar000000000 0000000 /////////////////////////////////////////////////////////////////////////////// // THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // /////////////////////////////////////////////////////////////////////////////// // This file is a snapshot of an AIDL file. Do not edit it manually. There are // two cases: // 1). this is a frozen version file - do not edit this in any case. // 2). this is a 'current' file. If you make a backwards compatible change to // the interface (from the latest frozen version), the build system will // prompt you to update this file with `m -update-api`. // // You must not make a backward incompatible change to any AIDL file built // with the aidl_interface module type with versions property set. The module // type is used to build AIDL files in a way that they can be used across // independently updatable components of the system. If a device is shipped // with such a backward incompatible change, it has a high risk of breaking // later when a module using the interface is updated, e.g., Mainline modules. package android.aidl.test.trunk; interface ITrunkStableTest { android.aidl.test.trunk.ITrunkStableTest.MyParcelable repeatParcelable(in android.aidl.test.trunk.ITrunkStableTest.MyParcelable input); android.aidl.test.trunk.ITrunkStableTest.MyEnum repeatEnum(in android.aidl.test.trunk.ITrunkStableTest.MyEnum input); android.aidl.test.trunk.ITrunkStableTest.MyUnion repeatUnion(in android.aidl.test.trunk.ITrunkStableTest.MyUnion input); void callMyCallback(in android.aidl.test.trunk.ITrunkStableTest.IMyCallback cb); android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable repeatOtherParcelable(in android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable input); parcelable MyParcelable { int a; int b; int c; } enum MyEnum { ZERO, ONE, TWO, THREE, } union MyUnion { int a; int b; int c; } interface IMyCallback { android.aidl.test.trunk.ITrunkStableTest.MyParcelable repeatParcelable(in android.aidl.test.trunk.ITrunkStableTest.MyParcelable input); android.aidl.test.trunk.ITrunkStableTest.MyEnum repeatEnum(in android.aidl.test.trunk.ITrunkStableTest.MyEnum input); android.aidl.test.trunk.ITrunkStableTest.MyUnion repeatUnion(in android.aidl.test.trunk.ITrunkStableTest.MyUnion input); android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable repeatOtherParcelable(in android.aidl.test.trunk.ITrunkStableTest.MyOtherParcelable input); } parcelable MyOtherParcelable { int a; int b; } } ./PaxHeaders.X/tests_trunk_stable_test_android_0100644 0000000 0000000 00000000034 15172120304 021034 xustar000000000 0000000 28 mtime=1776853188.7910000 tests/trunk_stable_test/android/0040755 0000000 0000000 00000000000 15172120304 016121 5ustar000000000 0000000 ./PaxHeaders.X/tests_trunk_stable_test_android_aidl_0100644 0000000 0000000 00000000034 15172120304 022025 xustar000000000 0000000 28 mtime=1776853188.7910000 tests/trunk_stable_test/android/aidl/0040755 0000000 0000000 00000000000 15172120304 017032 5ustar000000000 0000000 ./PaxHeaders.X/tests_trunk_stable_test_android_aidl_test_0100644 0000000 0000000 00000000034 15172120304 023064 xustar000000000 0000000 28 mtime=1776853188.7910000 tests/trunk_stable_test/android/aidl/test/0040755 0000000 0000000 00000000000 15172120304 020011 5ustar000000000 0000000 ./PaxHeaders.X/tests_trunk_stable_test_android_aidl_test_trunk_0100644 0000000 0000000 00000000034 15172120304 024307 xustar000000000 0000000 28 mtime=1776853188.7910000 tests/trunk_stable_test/android/aidl/test/trunk/0040755 0000000 0000000 00000000000 15172120304 021154 5ustar000000000 0000000 ./PaxHeaders.X/tests_trunk_stable_test_android_aidl_test_trunk_ITrunkStableTest.aidl0100644 0000000 0000000 00000000034 15172120304 030347 xustar000000000 0000000 28 mtime=1776853188.7910000 tests/trunk_stable_test/android/aidl/test/trunk/ITrunkStableTest.aidl0100644 0000000 0000000 00000001713 15172120304 025215 0ustar000000000 0000000 package android.aidl.test.trunk; interface ITrunkStableTest { parcelable MyParcelable { int a; int b; // New in V2 int c; } enum MyEnum { ZERO, ONE, TWO, // New in V2 THREE, } union MyUnion { int a; int b; // New in V3 int c; } interface IMyCallback { MyParcelable repeatParcelable(in MyParcelable input); MyEnum repeatEnum(in MyEnum input); MyUnion repeatUnion(in MyUnion input); MyOtherParcelable repeatOtherParcelable(in MyOtherParcelable input); } MyParcelable repeatParcelable(in MyParcelable input); MyEnum repeatEnum(in MyEnum input); MyUnion repeatUnion(in MyUnion input); void callMyCallback(in IMyCallback cb); // New in V2 parcelable MyOtherParcelable { int a; int b; } MyOtherParcelable repeatOtherParcelable(in MyOtherParcelable input); } ./PaxHeaders.X/tests_trunk_stable_test_trunk_ndk_unittest.cpp0100644 0000000 0000000 00000000034 15172120304 023774 xustar000000000 0000000 28 mtime=1776853188.7910000 tests/trunk_stable_test/trunk_ndk_unittest.cpp0100644 0000000 0000000 00000013062 15172120304 021142 0ustar000000000 0000000 /* * Copyright (C) 2023, 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 "gtest/gtest.h" /* Shared Client/Service includes */ #include #include #include #include #include /* AIDL Client includes */ /* AIDL Service includes */ #include #ifndef AIDL_TEST_TRUNK_VER #define AIDL_TEST_TRUNK_VER 2 #endif using ::aidl::android::aidl::test::trunk::ITrunkStableTest; using ndk::ScopedAStatus; /* AIDL Client definition */ class MyCallback : public ITrunkStableTest::BnMyCallback { public: ScopedAStatus repeatParcelable(const ITrunkStableTest::MyParcelable& in_input, ITrunkStableTest::MyParcelable* _aidl_return) override { *_aidl_return = in_input; repeatParcelableCalled = true; return ScopedAStatus::ok(); } ScopedAStatus repeatEnum(const ITrunkStableTest::MyEnum in_input, ITrunkStableTest::MyEnum* _aidl_return) override { *_aidl_return = in_input; repeatEnumCalled = true; return ScopedAStatus::ok(); } ScopedAStatus repeatUnion(const ITrunkStableTest::MyUnion& in_input, ITrunkStableTest::MyUnion* _aidl_return) override { *_aidl_return = in_input; repeatUnionCalled = true; return ScopedAStatus::ok(); } #if AIDL_TEST_TRUNK_VER >= 2 ScopedAStatus repeatOtherParcelable(const ITrunkStableTest::MyOtherParcelable& in_input, ITrunkStableTest::MyOtherParcelable* _aidl_return) override { *_aidl_return = in_input; repeatOtherParcelableCalled = true; return ScopedAStatus::ok(); } bool repeatOtherParcelableCalled = false; #endif bool repeatParcelableCalled = false; bool repeatEnumCalled = false; bool repeatUnionCalled = false; }; class ClientTest : public testing::Test { public: void SetUp() override { mService = ITrunkStableTest::fromBinder( ndk::SpAIBinder(AServiceManager_waitForService(ITrunkStableTest::descriptor))); ASSERT_NE(nullptr, mService); } std::shared_ptr mService; }; TEST_F(ClientTest, SanityCheck) { ITrunkStableTest::MyParcelable a, b; a.a = 12; a.b = 13; #if AIDL_TEST_TRUNK_VER >= 2 a.c = 14; #endif auto status = mService->repeatParcelable(a, &b); EXPECT_TRUE(status.isOk()); EXPECT_EQ(a, b); } TEST_F(ClientTest, Callback) { auto cb = ndk::SharedRefBase::make(); auto status = mService->callMyCallback(cb); EXPECT_TRUE(status.isOk()); EXPECT_TRUE(cb->repeatParcelableCalled); EXPECT_TRUE(cb->repeatEnumCalled); EXPECT_TRUE(cb->repeatUnionCalled); #if AIDL_TEST_TRUNK_VER >= 2 EXPECT_TRUE(cb->repeatOtherParcelableCalled); #endif } #if AIDL_TEST_TRUNK_VER >= 2 TEST_F(ClientTest, CallV2Method) { ITrunkStableTest::MyOtherParcelable a, b; a.a = 12; a.b = 13; auto status = mService->repeatOtherParcelable(a, &b); EXPECT_TRUE(status.isOk()); EXPECT_EQ(a, b); } #endif /* AIDL service definition */ using ::aidl::android::aidl::test::trunk::BnTrunkStableTest; class TrunkStableTest : public BnTrunkStableTest { ScopedAStatus repeatParcelable(const MyParcelable& in_input, MyParcelable* _aidl_return) override { *_aidl_return = in_input; return ScopedAStatus::ok(); } ScopedAStatus repeatEnum(const MyEnum in_input, MyEnum* _aidl_return) override { *_aidl_return = in_input; return ScopedAStatus::ok(); } ScopedAStatus repeatUnion(const MyUnion& in_input, MyUnion* _aidl_return) override { *_aidl_return = in_input; return ScopedAStatus::ok(); } ScopedAStatus callMyCallback(const std::shared_ptr& in_cb) override { MyParcelable a, b; MyEnum c = MyEnum::ZERO, d = MyEnum::ZERO; MyUnion e, f; auto status = in_cb->repeatParcelable(a, &b); if (!status.isOk()) { return status; } status = in_cb->repeatEnum(c, &d); if (!status.isOk()) { return status; } status = in_cb->repeatUnion(e, &f); #if AIDL_TEST_TRUNK_VER >= 2 if (!status.isOk()) { return status; } MyOtherParcelable g, h; status = in_cb->repeatOtherParcelable(g, &h); #endif return status; } #if AIDL_TEST_TRUNK_VER >= 2 ScopedAStatus repeatOtherParcelable(const ITrunkStableTest::MyOtherParcelable& in_input, ITrunkStableTest::MyOtherParcelable* _aidl_return) override { *_aidl_return = in_input; return ScopedAStatus::ok(); } #endif }; int run_service() { auto trunk = ndk::SharedRefBase::make(); binder_status_t status = AServiceManager_addService(trunk->asBinder().get(), TrunkStableTest::descriptor); CHECK_EQ(status, STATUS_OK); ABinderProcess_joinThreadPool(); return EXIT_FAILURE; // should not reach } int main(int argc, char* argv[]) { if (fork() == 0) { prctl(PR_SET_PDEATHSIG, SIGHUP); run_service(); } ::testing::InitGoogleTest(&argc, argv); return RUN_ALL_TESTS(); } ./PaxHeaders.X/tests_versioned_0100644 0000000 0000000 00000000034 15172120304 015576 xustar000000000 0000000 28 mtime=1776853188.7910000 tests/versioned/0040755 0000000 0000000 00000000000 15172120304 012743 5ustar000000000 0000000 ./PaxHeaders.X/tests_versioned_android_0100644 0000000 0000000 00000000034 15172120304 017276 xustar000000000 0000000 28 mtime=1776853188.7910000 tests/versioned/android/0040755 0000000 0000000 00000000000 15172120304 014363 5ustar000000000 0000000 ./PaxHeaders.X/tests_versioned_android_aidl_0100644 0000000 0000000 00000000034 15172120304 020267 xustar000000000 0000000 28 mtime=1776853188.7910000 tests/versioned/android/aidl/0040755 0000000 0000000 00000000000 15172120304 015274 5ustar000000000 0000000 ./PaxHeaders.X/tests_versioned_android_aidl_versioned_0100644 0000000 0000000 00000000034 15172120304 022345 xustar000000000 0000000 28 mtime=1776853188.7910000 tests/versioned/android/aidl/versioned/0040755 0000000 0000000 00000000000 15172120304 017272 5ustar000000000 0000000 ./PaxHeaders.X/tests_versioned_android_aidl_versioned_tests_0100644 0000000 0000000 00000000034 15172120304 023567 xustar000000000 0000000 28 mtime=1776853188.7910000 tests/versioned/android/aidl/versioned/tests/0040755 0000000 0000000 00000000000 15172120304 020434 5ustar000000000 0000000 ./PaxHeaders.X/tests_versioned_android_aidl_versioned_tests_BazUnion.aidl0100644 0000000 0000000 00000000034 15172120304 026145 xustar000000000 0000000 28 mtime=1776853188.7910000 tests/versioned/android/aidl/versioned/tests/BazUnion.aidl0100644 0000000 0000000 00000000160 15172120304 023006 0ustar000000000 0000000 package android.aidl.versioned.tests; union BazUnion { // V1 int intNum; // V2 long longNum; } ./PaxHeaders.X/tests_versioned_android_aidl_versioned_tests_Foo.aidl0100644 0000000 0000000 00000000034 15172120304 025143 xustar000000000 0000000 28 mtime=1776853188.7910000 tests/versioned/android/aidl/versioned/tests/Foo.aidl0100644 0000000 0000000 00000000220 15172120304 022001 0ustar000000000 0000000 package android.aidl.versioned.tests; @JavaSuppressLint({"NewApi"}) parcelable Foo { // V1 is empty // V2 int intDefault42 = 42; } ./PaxHeaders.X/tests_versioned_android_aidl_versioned_tests_IFooInterface.aidl0100644 0000000 0000000 00000000034 15172120304 027075 xustar000000000 0000000 28 mtime=1776853188.7910000 tests/versioned/android/aidl/versioned/tests/IFooInterface.aidl0100644 0000000 0000000 00000000756 15172120304 023751 0ustar000000000 0000000 package android.aidl.versioned.tests; import android.aidl.versioned.tests.BazUnion; import android.aidl.versioned.tests.Foo; @JavaDelegator interface IFooInterface { // V1 void originalApi(); @utf8InCpp String acceptUnionAndReturnString(in BazUnion u); @SuppressWarnings(value={"inout-parameter"}) int ignoreParcelablesAndRepeatInt(in Foo inFoo, inout Foo inoutFoo, out Foo outFoo, int value); int returnsLengthOfFooArray(in Foo[] foos); // V2 void newApi(); } ./PaxHeaders.X/trace_0100644 0000000 0000000 00000000034 15172120304 013454 xustar000000000 0000000 28 mtime=1776853188.7910000 trace/0040755 0000000 0000000 00000000000 15172120304 010701 5ustar000000000 0000000 ./PaxHeaders.X/trace_android_0100644 0000000 0000000 00000000034 15172120304 015154 xustar000000000 0000000 28 mtime=1776853188.7910000 trace/android/0040755 0000000 0000000 00000000000 15172120304 012321 5ustar000000000 0000000 ./PaxHeaders.X/trace_android_trace.h0100644 0000000 0000000 00000000034 15172120304 016421 xustar000000000 0000000 28 mtime=1776853188.7910000 trace/android/trace.h0100644 0000000 0000000 00000001504 15172120304 013565 0ustar000000000 0000000 /* * 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. */ #pragma once #include inline void ATrace_beginSection(const char* sectionName) { atrace_begin(ATRACE_TAG_AIDL, sectionName); } inline void ATrace_endSection() { atrace_end(ATRACE_TAG_AIDL); }